/**********************************************************************
// @@@ 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:         exp_datetime.C
 * Description:  Datetime Type
 *
 *
 * Created:      8/20/96
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "Platform.h"


#include "exp_stdh.h"
#include "SQLTypeDefs.h"
#include "exp_datetime.h"
#include "exp_interval.h"
#include "exp_clause_derived.h"
#include "NAAssert.h"
#include "exp_bignum.h"


#undef DllImport
#define DllImport __declspec ( dllimport )
#include "rosetta/rosgen.h"

#define ptimez_h_juliantimestamp
#define ptimez_h_including_section
#include "guardian/ptimez.h"
#ifdef ptimez_h_juliantimestamp
Section missing, generate compiler error
#endif

#define ptimez_h_converttimestamp
#define ptimez_h_including_section
#include "guardian/ptimez.h"
#ifdef ptimez_h_converttimestamp
Section missing, generate compiler error
#endif

#define ptimez_h_interprettimestamp
#define ptimez_h_including_section
#include "guardian/ptimez.h"
#ifdef ptimez_h_interprettimestamp
Section missing, generate compiler error
#endif

#define ptimez_h_computetimestamp
#define ptimez_h_including_section
#include "guardian/ptimez.h"
#ifdef ptimez_h_computetimestamp
Section missing, generate compiler error
#endif

// Forword declaration of static helper function.
//
static short
copyDatetimeFields(rec_datetime_field startField,
                   rec_datetime_field endField,
                   short srcFractPrec,
                   short dstFractPrec,
                   char *srcData,
                   char *dstData,
                   Lng32 dstLen,
                   NABoolean *roundedDownFlag);

// Helper function to format extra error message text and report error
// srcData is not null terminated, so need a buffer copy to build a C-style string
// 
static void 
raiseDateConvErrorWithSrcData(int srcLen, ComDiagsArea** diagsArea, char *srcData, CollHeap *heap)
{
    char errstr[MAX_OFFENDING_SOURCE_DATA_DISPLAY_LEN];
    str_pad(errstr, sizeof(errstr), 0 );
    if(srcLen > MAX_OFFENDING_SOURCE_DATA_DISPLAY_LEN -1 )
      srcLen = MAX_OFFENDING_SOURCE_DATA_DISPLAY_LEN -1;
    str_cpy_all(errstr, srcData, srcLen);
    ExRaiseSqlError(heap, diagsArea, EXE_CONVERT_DATETIME_ERROR,NULL,NULL,NULL,NULL,errstr);
}

// Helper function to format extra error message text and report error
// 
static void 
raiseDateConvErrorWithSrcDataNumeric(ComDiagsArea** diagsArea, long srcData, CollHeap *heap)
{
   char errstr[MAX_OFFENDING_SOURCE_DATA_DISPLAY_LEN];
   str_pad(errstr, sizeof(errstr), 0 );
   str_sprintf(errstr,"%ld",srcData);
   ExRaiseSqlError(heap, diagsArea, EXE_CONVERT_DATETIME_ERROR,NULL,NULL,NULL,NULL,errstr);
}
//////////////////////////////////////////////
// Defined in exp_datetime.h
//
//  struct DatetimeFormatInfo
//  {
//    Lng32 format;
//    const char * str;
//    Lng32 minLen;
//    Lng32 maxLen
//  };
////////////////////////////////////////////// 
const ExpDatetime::DatetimeFormatInfo ExpDatetime::datetimeFormat[] =
  {
    {ExpDatetime::DATETIME_FORMAT_DEFAULT,   "YYYY-MM-DD",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_USA,       "MM/DD/YYYY",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_EUROPEAN,  "DD.MM.YYYY",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_DEFAULT2,  "YYYY-MM",                7,  7},
    {ExpDatetime::DATETIME_FORMAT_USA2,      "MM/DD/YYYY",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_USA3,      "YYYY/MM/DD",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_USA4,      "YYYYMMDD",               8,  8},
    {ExpDatetime::DATETIME_FORMAT_USA5,      "YY/MM/DD",               8,  8},
    {ExpDatetime::DATETIME_FORMAT_USA6,      "MM/DD/YY",               8,  8},
    {ExpDatetime::DATETIME_FORMAT_USA7,      "MM-DD-YYYY",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_USA8,      "YYYYMM",                 6,  6},
    {ExpDatetime::DATETIME_FORMAT_EUROPEAN2, "DD-MM-YYYY",            10, 10},
    {ExpDatetime::DATETIME_FORMAT_EUROPEAN3, "DD-MON-YYYY",           11, 11},
    {ExpDatetime::DATETIME_FORMAT_EUROPEAN4, "DDMONYYYY",              9,  9},

    {ExpDatetime::DATETIME_FORMAT_TS4,       "HH24:MI:SS",             8,  8},

    {ExpDatetime::DATETIME_FORMAT_TS1,       "YYYYMMDDHH24MISS",      14, 14},
    {ExpDatetime::DATETIME_FORMAT_TS2,       "DD.MM.YYYY:HH24.MI.SS", 19, 19},
    {ExpDatetime::DATETIME_FORMAT_TS3,       "YYYY-MM-DD HH24:MI:SS", 19, 19},
    {ExpDatetime::DATETIME_FORMAT_TS5,       "YYYYMMDD:HH24:MI:SS",   17, 17},
    {ExpDatetime::DATETIME_FORMAT_TS6,       "MMDDYYYY HH24:MI:SS",   17, 17},
    {ExpDatetime::DATETIME_FORMAT_TS7,       "MM/DD/YYYY HH24:MI:SS", 19, 19},
    {ExpDatetime::DATETIME_FORMAT_TS8,       "DD-MON-YYYY HH:MI:SS",  20, 20},
    {ExpDatetime::DATETIME_FORMAT_TS9,       "MONTH DD, YYYY, HH:MI", 19, 25},
    {ExpDatetime::DATETIME_FORMAT_TS10,      "DD.MM.YYYY HH24.MI.SS", 19, 19},
    {ExpDatetime::DATETIME_FORMAT_TS11,      "YYYY/MM/DD HH24:MI:SS", 19, 19},
 
    {ExpDatetime::DATETIME_FORMAT_NUM1,      "99:99:99:99",           11, 11},
    {ExpDatetime::DATETIME_FORMAT_NUM2,      "-99:99:99:99",          12, 12},

    {ExpDatetime::DATETIME_FORMAT_EXTRA_HH,  "HH",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_HH12,"HH12",                   2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_HH24,"HH24",                   2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_MI,  "MI",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_SS,  "SS",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_YYYY,"YYYY",                   4,  4},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_YYY, "YYY",                    3,  3},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_YY,  "YY",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_Y,   "Y",                      1,  1},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_MON, "MON",                    3,  3},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_MM,  "MM",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_DY,  "DY",                     3,  3},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_DAY, "DAY",                    6,  9},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_CC,  "CC",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_D,   "D",                      1,  1},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_DD,  "DD",                     2,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_DDD, "DDD",                    1,  3},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_W,   "W",                      1,  1},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_WW,  "WW",                     1,  2},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_J,   "J",                      7,  7},
    {ExpDatetime::DATETIME_FORMAT_EXTRA_Q,   "Q",                      1,  1},

    // formats that are replaced by one of the other formats at bind time
    {ExpDatetime::DATETIME_FORMAT_UNSPECIFIED,   "UNSPECIFIED",       11, 11}
  };

UInt32 Date2Julian(int y, int m ,int d)
{
  int myjulian = 0;
  int mycentury = 0;
  if ( m <= 2)
    {
      m = m+13;
      y = y+4799;
    }
  else
    {
      m = m+1;
      y = y+4800;
    }

  mycentury = y / 100;
  myjulian = y * 365 - 32167;
  myjulian += y/4 - mycentury + mycentury / 4;
  myjulian += 7834 * m / 256 + d;
  return myjulian;
}

ExpDatetime::ExpDatetime()
{
  setClassID(SimpleTypeID);
}

ExpDatetime::~ExpDatetime()
{
}
Attributes * ExpDatetime::newCopy()
{
  ExpDatetime * new_copy = new ExpDatetime();
  *new_copy = *this;
  return new_copy;
};
Attributes * ExpDatetime::newCopy(CollHeap * heap)
{
  ExpDatetime * new_copy = new(heap) ExpDatetime();
  *new_copy = *this;
  return new_copy;
};
void ExpDatetime::copyAttrs(Attributes *source_) // copy source attrs to this.
{
  *this = *((ExpDatetime *)source_);
  return;
};
ExpDatetime * 
ExpDatetime::castToExpDatetime()
{
  return this;
} 

Int64 ExpDatetime::getTotalDays(short year, short month, short day)
{
  //
  // Return the number of days since 01/01/0001.
  //
  static const short daysBeforeMonth[] = {
    /* Jan */  0,
    /* Feb */  31,
    /* Mar */  31 + 28,
    /* Apr */  31 + 28 + 31,
    /* May */  31 + 28 + 31 + 30,
    /* Jun */  31 + 28 + 31 + 30 + 31,
    /* Jul */  31 + 28 + 31 + 30 + 31 + 30,
    /* Aug */  31 + 28 + 31 + 30 + 31 + 30 + 31,
    /* Sep */  31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
    /* Oct */  31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
    /* Nov */  31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
    /* Dec */  31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
  };
  Int64 totalDays = ((year - 1) * 365) + daysBeforeMonth[month - 1] + (day - 1);
  //
  // If the month is January or February, don't include the current year when
  // adjusting for leap years.
  //
  if (month <= 2)
    year--;
  totalDays += (year / 4) - (year / 100) + (year / 400);
  return totalDays;
}

// getDatetimeFields() ===============================================
// This static method returns the start and end fields based on the
// given REC_DATETIME_CODE value.  This method should be the only
// place in the expression evaluator which deals with the
// REC_DATETIME_CODE enumeration values.  All other uses should call
// this method and be based on the start and end fields.
//
// This method has been modified as part of the MP Datetime
// Compatibility project.  It has been extended to handle the
// non-standard SQL/MP datetime types.
//
short ExpDatetime::getDatetimeFields(Lng32 datetimeCode,
                                     rec_datetime_field &startField,
                                     rec_datetime_field &endField)
{
  switch (datetimeCode) {
  case REC_DTCODE_DATE:
  case REC_DTCODE_TIMESTAMP:
  case REC_DTCODE_YEAR:
  case REC_DTCODE_YEAR_MONTH:
  case REC_DTCODE_YEAR_DAY:
  case REC_DTCODE_YEAR_HOUR:
  case REC_DTCODE_YEAR_MINUTE:
  case REC_DTCODE_YEAR_SECOND:
    startField = REC_DATE_YEAR;
    break;
  case REC_DTCODE_MONTH:
  case REC_DTCODE_MONTH_DAY:
  case REC_DTCODE_MONTH_HOUR:
  case REC_DTCODE_MONTH_MINUTE:
  case REC_DTCODE_MONTH_SECOND:
    startField = REC_DATE_MONTH;
    break;
  case REC_DTCODE_DAY:
  case REC_DTCODE_DAY_HOUR:
  case REC_DTCODE_DAY_MINUTE:
  case REC_DTCODE_DAY_SECOND:
    startField = REC_DATE_DAY;
    break;
  case REC_DTCODE_TIME:
  case REC_DTCODE_HOUR:
  case REC_DTCODE_HOUR_MINUTE:
  case REC_DTCODE_HOUR_SECOND:
    startField = REC_DATE_HOUR;
    break;
  case REC_DTCODE_MINUTE:
  case REC_DTCODE_MINUTE_SECOND:
    startField = REC_DATE_MINUTE;
    break;
  case REC_DTCODE_SECOND:
    startField = REC_DATE_SECOND;
    break;
  default:
    return -1;
  }

  switch (datetimeCode) {
  case REC_DTCODE_YEAR:
    endField = REC_DATE_YEAR;
    break;
  case REC_DTCODE_YEAR_MONTH:
  case REC_DTCODE_MONTH:
    endField = REC_DATE_MONTH;
    break;
  case REC_DTCODE_DATE:
  case REC_DTCODE_YEAR_DAY:
  case REC_DTCODE_MONTH_DAY:
  case REC_DTCODE_DAY:
    endField = REC_DATE_DAY;
    break;
  case REC_DTCODE_YEAR_HOUR:
  case REC_DTCODE_MONTH_HOUR:
  case REC_DTCODE_DAY_HOUR:
  case REC_DTCODE_HOUR:
    endField = REC_DATE_HOUR;
    break;
  case REC_DTCODE_YEAR_MINUTE:
  case REC_DTCODE_MONTH_MINUTE:
  case REC_DTCODE_DAY_MINUTE:
  case REC_DTCODE_HOUR_MINUTE:
  case REC_DTCODE_MINUTE:
    endField = REC_DATE_MINUTE;
    break;
  case REC_DTCODE_TIMESTAMP:
  case REC_DTCODE_YEAR_SECOND:
  case REC_DTCODE_MONTH_SECOND:
  case REC_DTCODE_DAY_SECOND:
  case REC_DTCODE_TIME:
  case REC_DTCODE_HOUR_SECOND:
  case REC_DTCODE_MINUTE_SECOND:
  case REC_DTCODE_SECOND:
    endField = REC_DATE_SECOND;
    break;
  default:
    return -1;
  }

  return 0;
}

static const Lng32 powersOfTen[] = {1, 10 ,100, 1000, 10000, 100000, 1000000,
                                    10000000, 100000000, 1000000000};

void ExpDatetime::convertDatetimeToInterval
( rec_datetime_field datetimeStartField
, rec_datetime_field datetimeEndField
, short fractionPrecision
, rec_datetime_field intervalEndField
, char *datetimeOpData
, Int64 &interval
, char * intervalBignum
, NABoolean &isBignum
) const
{
  short rc = 0;

  isBignum = FALSE;

  interval = 0;
  short year;
  char month;
  char day;
  for (Int32 field = datetimeStartField; field <= intervalEndField; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      str_cpy_all((char *) &year, datetimeOpData, sizeof(year));
      datetimeOpData += sizeof(year);
      interval = year - 1;
      break;
    case REC_DATE_MONTH:
      str_cpy_all((char *) &month, datetimeOpData, sizeof(month));
      datetimeOpData += sizeof(month);
      interval = (interval * 12) + (month - 1);
      break;
    case REC_DATE_DAY:
      str_cpy_all((char *) &day, datetimeOpData, sizeof(day));
      datetimeOpData += sizeof(day);
      interval = getTotalDays(year, month, day);
      break;
    case REC_DATE_HOUR:
      interval *= 24;
      if (field <= datetimeEndField) {
        char hour;
        str_cpy_all((char *) &hour, datetimeOpData, sizeof(hour));
        datetimeOpData += sizeof(hour);
        interval = interval + hour;
      }
      break;
    case REC_DATE_MINUTE:
      interval *= 60;
      if (field <= datetimeEndField) {
        char minute;
        str_cpy_all((char *) &minute, datetimeOpData, sizeof(minute));
        datetimeOpData += sizeof(minute);
        interval = interval + minute;
      }
      break;
    case REC_DATE_SECOND:
      interval *= 60;

      if (field <= datetimeEndField) {
        char second;
        str_cpy_all((char *) &second, datetimeOpData, sizeof(second));
        datetimeOpData += sizeof(second);
        interval = interval + second;
        if (fractionPrecision > 0) {
          Lng32 fraction;
          Int64 fraction64;

          str_cpy_all((char *) &fraction, datetimeOpData, sizeof(fraction));

          Int64 multiplicator = powersOfTen[fractionPrecision];
          if (fractionPrecision <= MAX_DATETIME_MICROS_FRACT_PREC) 
            {
              interval *= multiplicator;
              interval = interval + fraction;
            }
          else
            {
              // Int64 may run into an overflow if fract precision is > 6
              // Use bignum computation to do:
              //   interval = interval * multiplicator
              //   interval = interval + fraction
              SimpleType op1ST(REC_BIN64_SIGNED, sizeof(Int64), 0, 0,
                               ExpTupleDesc::SQLMX_FORMAT,
                               8, 0, 0, 0, Attributes::NO_DEFAULT, 0);

              char *op_data[3];
              char mulBignum[BigNum::BIGNUM_TEMP_LEN]; // 16 bytes bignum result length

              op_data[0] = mulBignum; // result
              op_data[1] = (char*) &interval;
              op_data[2] = (char*) &multiplicator;
              rc = EXP_FIXED_BIGN_OV_MUL(&op1ST, &op1ST, op_data);

              BigNum op1BN(BigNum::BIGNUM_TEMP_LEN, BigNum::BIGNUM_TEMP_PRECISION, 0, 0);
              
              char addBignum[BigNum::BIGNUM_TEMP_LEN];
              fraction64 = fraction;

              op_data[0] = addBignum;
              op_data[1] = mulBignum;
              op_data[2] = (char*)&fraction64;
              rc = EXP_FIXED_BIGN_OV_ADD(&op1BN, &op1ST, op_data);
              
              if (intervalBignum)
                {
                  str_cpy_all(intervalBignum, addBignum, BigNum::BIGNUM_TEMP_LEN);
                  isBignum = TRUE;
                }
            }
        }
      }
      break;
    }
  }
}

short ExpDatetime::getYearMonthDay(Int64 totalDays,
                                   short &year,
                                   char &month,
                                   char &day)
{
  const unsigned short daysPerYear = 365;
  const unsigned short daysPer4Years = daysPerYear * 4 + 1;
  const unsigned short daysPer100Years = daysPer4Years * 25 - 1;
  const Int64 daysPer400Years = daysPer100Years * 4 + 1;
  Int64 numLeapCenturies = totalDays / daysPer400Years;
  totalDays -= numLeapCenturies * daysPer400Years;
  Int64 numCenturies = totalDays / daysPer100Years;
  //
  // If the date is the last day of a leap century, e.g. 12/31/2000, then
  // numCenturies will be 4 since the century had an extra day.  Correct
  // numCenturies to 3.
  //
  if (numCenturies > 3)
    numCenturies = 3;
  totalDays -= numCenturies * daysPer100Years;
  Int64 numLeapYears = totalDays / daysPer4Years;
  totalDays -= numLeapYears * daysPer4Years;
  Int64 numYears = totalDays / daysPerYear;
  //
  // If the date is the last day of a leap year, e.g. 12/31/1996, numYears
  // will be 4 since the year had an extra day.  Correct numYears to 3.
  //
  if (numYears > 3)
    numYears = 3;
  totalDays -= numYears * daysPerYear;
  numYears += (numLeapCenturies * 400) +
              (numCenturies * 100) +
              (numLeapYears * 4) +
              1;  /* the base year is 0001 */
  if (numYears > 9999)
    return -1;
  year = (short) int64ToInt32(numYears);
  static const short daysInMonth[] = {
    0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  };
  for (month = 1; totalDays >= daysInMonth[month]; month++) {
    if ((month == 2) &&  /* February */
        ((year % 4) == 0) &&
        (((year % 100) != 0) || ((year % 400) == 0))) {  /* leap year */
      if (totalDays == 28)  /* leap day */
        break;
      totalDays -= 29;
    } else
      totalDays -= daysInMonth[month];
  }
  day = (char) int64ToInt32(totalDays);
  day++;  /* each month begins at day 1 */
  return 0;
}

short ExpDatetime::convertIntervalToDatetime(Int64 interval,
                                             char * intervalBignum,
                                             rec_datetime_field startField,
                                             rec_datetime_field endField,
                                             short fractionPrecision,
                                             char *datetimeOpData) const
{
  short rc = 0;

  short year;
  char month;
  char day;
  char hour;
  char minute;
  char second;
  Lng32 fraction;
  Int32 field = endField;
  for (; field >= startField; field--) {
    switch (field) {
    case REC_DATE_SECOND:
      if (fractionPrecision > 0) {

        //Int64 multiplicator = powersOfTen[fractionPrecision];
        Int64 divisor = powersOfTen[fractionPrecision];
        Int64 dividend = 0;
        if (fractionPrecision <= MAX_DATETIME_MICROS_FRACT_PREC)
          {
            Int64 dividend = interval;
            interval = dividend / divisor;
            dividend = dividend - (interval * divisor);
            //
            // Underflow is allowed for time types, so wrap around if necessary.
            //
            if (dividend < 0) {
              dividend += divisor;
              interval -= 1;
            }
            fraction = int64ToInt32(dividend);
          }
        else
          {
            SimpleType opST(REC_BIN64_SIGNED, sizeof(Int64), 0, 0,
                            ExpTupleDesc::SQLMX_FORMAT,
                            8, 0, 0, 0, Attributes::NO_DEFAULT, 0);
            BigNum opBN(BigNum::BIGNUM_TEMP_LEN, BigNum::BIGNUM_TEMP_PRECISION, 0, 0);
            
            char *op_data[2];
            
            op_data[0] = intervalBignum;
            op_data[1] = (char*) &divisor;
            Int64 quotient = -1;
            short ov;
            dividend = 
              EXP_FIXED_BIGN_OV_MOD(&opBN, &opST, op_data, &ov, &quotient);
            interval = quotient;

            fraction = int64ToInt32(dividend);
          }

      }
      //
      // Underflow is allowed for time types, so wrap around if necessary.
      // But be aware that the sign of the result of a modulus operation
      // involving a negative operand is implementation-dependent according
      // to the C++ reference manual.  In this case, we prefer the result to
      // be negative.
      //
      {
        Int32 sec = (Int32) (interval % 60);
        if ((interval < 0) && ( sec > 0))
          sec = - sec;
        interval /= 60;
        if ( sec < 0) {
          sec+= 60;
          interval -= 1;
        }
        second = (char) sec;
        break;
      }
    case REC_DATE_MINUTE:
      //
      // Underflow is allowed for time types, so wrap around if necessary.
      // But be aware that the sign of the result of a modulus operation
      // involving a negative operand is implementation-dependent according
      // to the C++ reference manual.  In this case, we prefer the result to
      // be negative.
      //
      {
        Int32 mins = (Int32) (interval % 60);
        if ((interval < 0) && (mins > 0))
          mins = - mins;
        interval /= 60;
        if (mins < 0) {
          mins += 60;
          interval -= 1;
        }
        minute = (char) mins;
        break;
      }
    case REC_DATE_HOUR:
      //
      // Underflow is allowed for time types, so wrap around if necessary.
      // But be aware that the sign of the result of a modulus operation
      // involving a negative operand is implementation-dependent according
      // to the C++ reference manual.  In this case, we prefer the result to
      // be negative.
      //
      {
        Int32 hrs = (Int32) (interval % 24);
        if ((interval < 0) && (hrs > 0))
          hrs = - hrs;
        interval /= 24;
        if (hrs < 0) {
          hrs += 24;
          interval -= 1;
        }
        hour = (char) hrs;
        break;
      }
    case REC_DATE_DAY:
      if (getYearMonthDay(interval, year, month, day) != 0)
        return -1;
      break;
    case REC_DATE_MONTH:
      if (endField < REC_DATE_DAY) {
        month = char ((interval % 12) + 1);
        interval /= 12;
      }
      break;
    case REC_DATE_YEAR:
      if (endField < REC_DATE_DAY) {
        interval += 1;  /* the base year is 0001 */
        if (interval > 9999)
          return -1;
        year = (short) int64ToInt32(interval);
      }
      break;
    }
  }
  for (field = startField; field <= endField; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      str_cpy_all(datetimeOpData, (char *) &year, sizeof(year));
      datetimeOpData += sizeof(year);
      break;
    case REC_DATE_MONTH:
      str_cpy_all(datetimeOpData, (char *) &month, sizeof(month));
      datetimeOpData += sizeof(month);
      break;
    case REC_DATE_DAY:
      str_cpy_all(datetimeOpData, (char *) &day, sizeof(day));
      datetimeOpData += sizeof(day);
      break;
    case REC_DATE_HOUR:
      str_cpy_all(datetimeOpData, (char *) &hour, sizeof(hour));
      datetimeOpData += sizeof(hour);
      break;
    case REC_DATE_MINUTE:
      str_cpy_all(datetimeOpData, (char *) &minute, sizeof(minute));
      datetimeOpData += sizeof(minute);
      break;
    case REC_DATE_SECOND:
      str_cpy_all(datetimeOpData, (char *) &second, sizeof(second));
      datetimeOpData += sizeof(second);
      if (fractionPrecision > 0)
        str_cpy_all(datetimeOpData, (char *) &fraction, sizeof(fraction));
      break;
    }
  }
  return 0;
}

short ExpDatetime::validateDate(rec_datetime_field startField,
                                rec_datetime_field endField,
                                char *datetimeOpData,
                                ExpDatetime *attr,
                                short intervalFlag,
                                NABoolean &LastDayPrevMonth)
{

  // Initialize to a valid date.  The year is set to 4 so that if all
  // we have is a month and a day, 02/29 is valid as it should
  // be. Month is set to 1, so that if all we have is a day, 31 is
  // valid.
  //
  short year = 4;
  char month = 1;
  char day = 1;
  short uselastdateflag = FALSE;
  short uselastdateonerrflag = FALSE;
  short ErrorOnInterval = FALSE; 

  for (Int32 field = startField; field <= endField; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      str_cpy_all((char *) &year, datetimeOpData, sizeof(year));
      datetimeOpData += sizeof(year);
      break;
    case REC_DATE_MONTH:
      month = *datetimeOpData;
      datetimeOpData += sizeof(month);
      break;
    case REC_DATE_DAY:
      day = *datetimeOpData;
      datetimeOpData += sizeof(day);
      break;
    default:
      // Only validating date fields. Ignore all others.
      //
      break;
    }
  }

  // Round to the last day of the month.
  if ((intervalFlag) && attr->getlastdaymonthflag())
    uselastdateflag = TRUE;

  // If ending day of resulting date is invalid, day will be rounded
  // down to the last day of the month.
  if ((intervalFlag) && attr->getlastdayonerrflag())
    uselastdateonerrflag = TRUE;

  // Check basic range of the fields of the date.
  //
  if (year > 9999 || year < 1 || month > 12 || month < 1 || day < 1)
    return -1;

  //
  // If the days field is more than the number of days in the month, the date
  // is invalid.
  //
  static const short daysInMonth[] = {
    0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  };

  static const short daysInMonthNonLeap[] = {
    0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  };

  if (day > daysInMonth[month])
    // Return error if we're not adjusting for intervals only validating
    // the date.  This is default behavior.  If add_month or date_add 
    // functions are used, then intervalFlag would be set.
    if ((!uselastdateonerrflag) && (!uselastdateflag)) 
       return -1;
    else
    if (!intervalFlag)
       return -1;
    else
    if (uselastdateonerrflag)
       ErrorOnInterval = TRUE; 

  //
  // If the month field is February and the year is not a leap year, the
  // maximum number of days is 28.
  //
  if ((month == 2) && (day > 28) &&
      (((year % 4) != 0) ||
       (((year % 100) == 0) && ((year % 400) != 0))))

    // Return error if we're not adjusting for interval dates, only validating
    // dates. (The default behavior)
    if ((!uselastdateonerrflag) && (!uselastdateflag)) 
       return -1;
    else
    if (!intervalFlag)
       return -1;
    else
    if (uselastdateonerrflag)
       ErrorOnInterval = TRUE; 

  // Check to see whether the month value of the incoming date is the 
  // last day of the month, then set flag here.  We're validating the
  // the incoming 1st date, not the resulting adjusted date.
  if (!intervalFlag)
    {
     // it's a non-leap year
     if (((year % 4) != 0) ||
        (((year % 100) == 0) && ((year % 400) != 0)))
        if (day == daysInMonthNonLeap[month])
           LastDayPrevMonth = TRUE;
        else
           LastDayPrevMonth = FALSE;
     else
        if (day == daysInMonth[month])
           LastDayPrevMonth = TRUE;
        else
           LastDayPrevMonth = FALSE;
    }

  // Adjust resulting date only if one of the flags are set.
  // If not set, then revert to previous behavior and don't adjust dates.
  if ((uselastdateonerrflag) || (uselastdateflag))
    if (intervalFlag)
      {
       if (uselastdateonerrflag) // adjust date only if resulting day is invalid
         {
          // Didn't get an error, so return and don't adjust the date
          if (!ErrorOnInterval)
             return 0;
         }
       else
       if (uselastdateflag)
         {
         // If incoming adjusted day is not at the end of the month,
         // don't adjust the resulting day to the end of the month
         if (!LastDayPrevMonth)
           { 
            // If the final date is in Feb.
            // we may need to adjust, return if not Feb.
            if ((month == 2) && (day > 28))  
              {}
            else
              return 0;
           };
         };

      day = (char) daysInMonth[month];
      if ((month == 2) && (day > 28) &&
         (((year % 4) != 0) ||
         (((year % 100) == 0) && ((year % 400) != 0))))
         day = 28;
  
      datetimeOpData -= sizeof(day);
      *datetimeOpData = day;

      } // if (intervalFlag)

  return 0;
}

// returns 0 if valid time, -1 if not
// validates hour, minute, second
short ExpDatetime::validateTime(const char *datetimeOpData)
{
  int hour = datetimeOpData[0];
  if ((hour < 0) || (hour > 23))
    return -1;

  int minute = datetimeOpData[1];
  if ((minute < 0) || (minute > 59))
    return -1;

  int second = datetimeOpData[2];
  if ((second < 0) || (second > 59))
    return -1;

  return 0;
}

// compDatetimes() ===================================================
// This method compares two datetime values of the same subtype and
// returns a value indicating if the first value is less than (-1),
// equal to (0), or greater than (+1) the second value.
//
// This method has been modified as part of the MP Datetime
// Compatibility project.  It has been made more generic so that it is
// based on the start and end fields of the datetime type.
// ===================================================================
short ExpDatetime::compDatetimes(char *datetimeOpData1,
                                 char *datetimeOpData2)
{
  rec_datetime_field startField;
  rec_datetime_field endField;

  // Get the start and end fields for this Datetime type.
  //
  getDatetimeFields(getPrecision(),
                    startField,
                    endField);

  // Compare each field from highest significance (YEAR) to least
  // significance (FRACTION).  The format is: YYMDHMSFFFF
  //
  for (Int32 field = startField; field <= endField; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      {
        short year1;
        short year2;

        // Don't know if the datetimeOpData{1,2} pointers point to
        // aligned data, so use str_cpy_all.
        //
        str_cpy_all((char *) &year1, datetimeOpData1, sizeof(year1));
        str_cpy_all((char *) &year2, datetimeOpData2, sizeof(year2));

        if (year1 < year2)
          return -1;
        if (year1 > year2)
          return 1;

        datetimeOpData1 += sizeof(year1);
        datetimeOpData2 += sizeof(year2);
        break;
      }
    case REC_DATE_MONTH:
    case REC_DATE_DAY:
    case REC_DATE_HOUR:
    case REC_DATE_MINUTE:
      {
        // 1 byte field comparisons
        //
        if (*datetimeOpData1 < *datetimeOpData2)
          return -1;
        if (*datetimeOpData1 > *datetimeOpData2)
          return 1;

        datetimeOpData1++;
        datetimeOpData2++;
        break;
      }
    case REC_DATE_SECOND:
      {
        // second comparison is also one byte, but has an optional
        // trailing fractional precision
        //
        if (*datetimeOpData1 < *datetimeOpData2)
          return -1;
        if (*datetimeOpData1 > *datetimeOpData2)
          return 1;

        datetimeOpData1++;
        datetimeOpData2++;

        // check for fractional part
        if (getScale() > 0)
          {
            Lng32 fraction1;
            Lng32 fraction2;

            // Don't know if the datetimeOpData{1,2} pointers point to
            // aligned data, so use str_cpy_all.
            //
            str_cpy_all((char *) &fraction1, datetimeOpData1, sizeof(fraction1));
            str_cpy_all((char *) &fraction2, datetimeOpData2, sizeof(fraction2));

            if (fraction1 < fraction2)
              return -1;
            if (fraction1 > fraction2)
              return 1;
          }
        break;
      }
    default:
      // Should never get here.
      //
      assert(0);
      break;
    } // switch ...
  } // for ...

  // All fields compare equal.  Therefore, the values are equal.
  //
  return 0;
}

// arithDatetimeInterval() ===========================================
// This method is used to add or subtract an interval value to/from a
// datetime value.  To perform the arithmetic operation, the following
// steps will be taken:
//
// - The datetime value will have been extended to contain a YEAR
// field if needed (see BiArith::preCodeGen()).  The value will need
// to be extended if it contains a DAY field.  This is necessary since
// with the introduction of non-standard SQL/MP datetime types, it is
// possible to have a datetime value which has a DAY field but not a
// YEAR or not a MONTH field.  In this situation, it is not possible
// to define a meaningful way to do the operation.  Does the DAY field
// wrap at 30, 31, 28, or 29.  So to make this operation meaningful,
// the value is extended to the current timestamp.
//
// - Ensure that this is a valid datetime value (use validateDate).
// For example, the datetime value "DATETIME 02-29 MONTH TO DAY"
// extended to the current timestamp in a non-leap year would result
// in an invalid timestamp.  Presumably, this check should have been
// done before calling this method.
//
// - Convert the given datetime value to an interval scaled to
// match the given interval value (use convertDatetimeToInterval)
//
// - Perform the arithmetic operation on the two interval values (they
// are integer values).
//
// - Convert the resulting value back to a datetime value (use
// convertIntervalToDatetime).
//
// - If necessary, validate the resulting datetime value.  It will be
// necessary if the interval being added/subtract to the datetime
// value is in units of months or years and if the original datetime
// value contained a day field.
//
// - Extract the desired fields from the resulting datetime value as
// the final result (use extractDatetime).  The desired fields are the
// range of fields of the original datetime value.
//
// This method has been modified as part of the MP Datetime
// Compatibility project.  It has been modified to handle non-standard
// datetime types.
// ====================================================================
//
short
ExpDatetime::arithDatetimeInterval(arithOps operation,
                                   ExpDatetime *datetimeOpType,
                                   Attributes *intervalOpType,
                                   char *datetimeOpData,
                                   char *intervalOpData,
                                   char *resultData,
                                   CollHeap *heap,
                                   ComDiagsArea** diagsArea)
{
  short rc = 0;

  if (operation != DATETIME_ADD && 
      operation != DATETIME_SUB) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  rec_datetime_field datetimeStartField;
  rec_datetime_field datetimeEndField;

  NABoolean LastDayPrevMonth = FALSE;

  // Get the start and end fields of the given Datetime type.
  //
  if (getDatetimeFields(datetimeOpType->getPrecision(),
                        datetimeStartField,
                        datetimeEndField) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  rec_datetime_field intervalEndField;

  // Get the end field of the given Interval type.
  //
  if (ExpInterval::getIntervalEndField(intervalOpType->getDatatype(),
                       intervalEndField) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  // Make sure that the given datetime value has enough fields to
  // perform this operation.  If there is a DAY field, there also has
  // to be as YEAR field.
  //
  if (datetimeStartField <= REC_DATE_DAY &&
      datetimeEndField >= REC_DATE_DAY &&
      datetimeStartField > REC_DATE_YEAR) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  // Copy the given datetime value to a local buffer.
  // This will contain the result of the operation, but may 
  // have more fields that the destination.
  //
  char dateTimeValue[MAX_DATETIME_SIZE];

  // Copy given datetime value to a local buffer.
  //
  if (copyDatetimeFields(datetimeStartField,
                         datetimeEndField,
                         datetimeOpType->getScale(),
                         datetimeOpType->getScale(),
                         datetimeOpData,
                         dateTimeValue,
                         MAX_DATETIME_SIZE,
                         NULL) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  // Ensure that the given value is a valid datetime value.  For
  // example, the datetime value "DATETIME 02-29 MONTH TO DAY"
  // extended with the current timestamp in a non-leap year would
  // result in an invalid date. (This check presumably is also done by
  // the code which performed the extension).
  //
  if ((datetimeStartField == REC_DATE_YEAR) &&
      (datetimeEndField >= REC_DATE_DAY) &&
      (validateDate(REC_DATE_YEAR, REC_DATE_DAY, 
                    dateTimeValue, NULL, FALSE, 
                    LastDayPrevMonth) != 0)) {
    ExRaiseSqlError(heap, diagsArea, EXE_DATETIME_FIELD_OVERFLOW);
    return -1;
  }

  // Convert the datetime value to an interval with the same precision
  // (endField) as the Interval operand.  We want to make sure we
  // add/subtract MONTHs to MONTHs, etc.
  //
  Int64 value = -1;
  char intervalBignum[BigNum::BIGNUM_TEMP_LEN];
  char resultBignum[BigNum::BIGNUM_TEMP_LEN];
  NABoolean isBignum = FALSE;
  convertDatetimeToInterval(datetimeStartField,
                            datetimeEndField,
                            datetimeOpType->getScale(),
                            intervalEndField,
                            dateTimeValue,
                            value,
                            intervalBignum,
                            isBignum);

  // Perform the arithmetic operation.
  //
  Int64 interval64 = 0;
  switch (intervalOpType->getLength()) {
  case SQL_SMALL_SIZE: {
    short interval;
    str_cpy_all((char *) &interval, intervalOpData, sizeof(interval));
    interval64 = interval;
    break;
  }
  case SQL_INT_SIZE: {
    Lng32 interval;
    str_cpy_all((char *) &interval, intervalOpData, sizeof(interval));
    interval64 = interval;
    break;
  }
  case SQL_LARGE_SIZE: {
    Int64 interval;
    str_cpy_all((char *) &interval, intervalOpData, sizeof(interval));
    interval64 = interval;
    break;
  }
  default:
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }

  if (NOT isBignum) { // result is not a bignum  
    value += ((operation == DATETIME_ADD) ? interval64 : -interval64);
  } else {
    // result is a bignum
    char *op_data[3];
    
    BigNum op1BN(BigNum::BIGNUM_TEMP_LEN, BigNum::BIGNUM_TEMP_PRECISION, 0, 0);
    SimpleType intST(REC_BIN64_SIGNED, sizeof(Int64), 0, 0,
                     ExpTupleDesc::SQLMX_FORMAT,
                     8, 0, 0, 0, Attributes::NO_DEFAULT, 0);

    op_data[0] = resultBignum;
    op_data[1] = intervalBignum;
    op_data[2] = (char*)&interval64;
    
    if (operation == DATETIME_ADD) {
      rc = EXP_FIXED_BIGN_OV_ADD(&op1BN, &intST, op_data);
    } else {
      rc = EXP_FIXED_BIGN_OV_SUB(&op1BN, &intST, op_data);
    }
  }

  // Underflow is ok for time only datetime types.  Arithmetic on the
  // hour field is computed modulo 24.  For datetime types containing
  // a date portion, underflow is an error.
  //
  if ((NOT isBignum) && (value < 0) && 
      (datetimeStartField < REC_DATE_HOUR)) {
    ExRaiseSqlError(heap, diagsArea, EXE_DATETIME_FIELD_OVERFLOW);
    return -1;
  }

  // Convert result back to datetime.  Note that this is overlaying the
  // local copy of the datetime value.
  //
  if (convertIntervalToDatetime(value,
                                (isBignum ?  resultBignum : NULL),
                                datetimeStartField,
                                intervalEndField,
                                datetimeOpType->getScale(),
                                dateTimeValue) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_DATETIME_FIELD_OVERFLOW);
    return -1;
  }

  // If we are adding/subtracting in units of MONTHS or YEARS, and the
  // original datetime value contains a DAY field, then the result
  // could be invalid.  For example:
  //
  //   DATETIME '1-31' MONTH TO DAY + INTERVAL '1' MONTH -> ERROR
  //
  //   DATETIME '1' MONTH + INTERVAL '1' MONTH -> DATETIME '2' MONTH
  //   (even if the current date is 2000-1-31)
  //

  if ((intervalEndField <= REC_DATE_MONTH) &&
      (datetimeStartField <= REC_DATE_DAY) &&
      (datetimeEndField >= REC_DATE_DAY) &&
      (validateDate(datetimeStartField,
                    REC_DATE_DAY,
                    dateTimeValue, this, TRUE, LastDayPrevMonth) != 0)) {
    ExRaiseSqlError(heap, diagsArea, EXE_DATETIME_FIELD_OVERFLOW);
    return -1;
  }

  // Extract the result from the datetime value. The result fields
  // could be different from the fields of the given datetime value.
  //
  if (extractDatetime(datetimeStartField,
                      datetimeEndField,
                      datetimeOpType->getScale(),
                      dateTimeValue,
                      resultData) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_DATETIME_FIELD_OVERFLOW);
    return -1;
  }

  return 0;
}

short ExpDatetime::subDatetimeDatetime(Attributes *datetimeOpType,
                                       Attributes *intervalOpType,
                                       char *datetimeOpData1,
                                       char *datetimeOpData2,
                                       char *resultData,
                                       CollHeap *heap,
                                       ComDiagsArea** diagsArea) const
{
  short rc = 0;

  rec_datetime_field datetimeStartField;
  rec_datetime_field datetimeEndField;
  if (getDatetimeFields(datetimeOpType->getPrecision(),
                        datetimeStartField,
                        datetimeEndField) != 0) {
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }
  rec_datetime_field intervalEndField;
  if (DFS2REC::isInterval(intervalOpType->getDatatype()))
    {
      if (ExpInterval::getIntervalEndField(intervalOpType->getDatatype(),
                                           intervalEndField) != 0) {
        ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
        return -1;
      }
    }
  else if ((DFS2REC::isBinaryNumeric(intervalOpType->getDatatype())) &&
           (datetimeEndField == REC_DATE_DAY))
    {
      // special modeSpecial4 case.
      // DATE - DATE with result as NUMBER.
      intervalEndField = REC_DATE_DAY;
    }
  else
    {
      ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
      return -1;
    }

  Int64 value1;
  char intervalBignum1[BigNum::BIGNUM_TEMP_LEN];
  NABoolean isBignum1 = FALSE;
  NABoolean isBignum2 = FALSE;
  convertDatetimeToInterval(datetimeStartField,
                            datetimeEndField,
                            datetimeOpType->getScale(),
                            intervalEndField,
                            datetimeOpData1,
                            value1,
                            intervalBignum1,
                            isBignum1);

  Int64 value2;
  char intervalBignum2[BigNum::BIGNUM_TEMP_LEN];
  convertDatetimeToInterval(datetimeStartField,
                            datetimeEndField,
                            datetimeOpType->getScale(),
                            intervalEndField,
                            datetimeOpData2,
                            value2,
                            intervalBignum2,
                            isBignum2);

  Int64 result = 0;

  if ((NOT isBignum1) && (NOT isBignum2)) // neither is bignum
    result = value1 - value2;
  else
    {
      BigNum opBN(BigNum::BIGNUM_TEMP_LEN, BigNum::BIGNUM_TEMP_PRECISION, 0, 0);
      SimpleType opST(REC_BIN64_SIGNED, sizeof(Int64), 0, 0,
                      ExpTupleDesc::SQLMX_FORMAT,
                      8, 0, 0, 0, Attributes::NO_DEFAULT, 0);

      char *op_data[3];

      char resultBN[BigNum::BIGNUM_TEMP_LEN];
      op_data[0] = resultBN;
      op_data[1] = (isBignum1 ? intervalBignum1 : (char*)&value1);
      op_data[2] = (isBignum2 ? intervalBignum2 : (char*)&value2);
     
      rc = EXP_FIXED_BIGN_OV_SUB((isBignum1 ? (Attributes*)&opBN : (Attributes*)&opST), 
                                 (isBignum2 ? (Attributes*)&opBN : (Attributes*)&opST), 
                                 op_data); 
      if (rc)
        {
          ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
          return -1;
        }

      rc = convDoIt(op_data[0], BigNum::BIGNUM_TEMP_LEN, REC_NUM_BIG_SIGNED, BigNum::BIGNUM_TEMP_PRECISION, 0,
                    (char*)&result,  8, REC_BIN64_SIGNED, 0, 0,
                    NULL, 0, NULL, NULL);
      if (rc)
        {
          // convert interval value to ascii format
          char invalidVal[BigNum::BIGNUM_TEMP_PRECISION+1];
          Int32 len = BigNum::BIGNUM_TEMP_PRECISION;
          memset(invalidVal, ' ', len);
          convDoIt(op_data[0], BigNum::BIGNUM_TEMP_LEN, REC_NUM_BIG_SIGNED, BigNum::BIGNUM_TEMP_PRECISION, 0,
                   invalidVal, BigNum::BIGNUM_TEMP_PRECISION, REC_BYTE_F_ASCII, 0, 0,
                   NULL, 0, NULL, NULL);
          len--;
          while (invalidVal[len] == ' ')
            len--;
          len++;
          invalidVal[len]  = 0;

          ExRaiseSqlError(heap, diagsArea, EXE_INVALID_INTERVAL_RESULT,
                          NULL, NULL, NULL, NULL,
                          invalidVal);
          return -1;
        }
    }

  //
  // Scale the result to the interval qualifier's fractional precision.
  //
  if (intervalEndField == REC_DATE_SECOND) {
    short fpDiff = intervalOpType->getScale() - datetimeOpType->getScale();
    if (fpDiff > 0) {
      do {
        result *= 10;
      } while (--fpDiff > 0);
    } else {
      while (fpDiff < 0) {
        result /= 10;
        fpDiff++;
      }
    }
  }
  switch (intervalOpType->getLength()) {
  case SQL_SMALL_SIZE: {
    short interval = (short) int64ToInt32(result);
    str_cpy_all(resultData, (char*) &interval, sizeof(interval));
    break;
  }
  case SQL_INT_SIZE: {
    Lng32 interval = int64ToInt32(result);
    str_cpy_all(resultData, (char*) &interval, sizeof(interval));
    break;
  }
  case SQL_LARGE_SIZE:
    str_cpy_all(resultData, (char*) &result, sizeof(result));
    break;
  default:
    ExRaiseSqlError(heap, diagsArea, EXE_INTERNAL_ERROR);
    return -1;
  }
  return 0;
};

// scaleFraction() ===================================================
// This static helper function to the ExpDatetime class is used to
// scale the fraction value from one precision to another.  If the
// scaling results in loss of data, the roundedDownFlag, if provided,
// is set to TRUE.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// ===================================================================
//
static Lng32
scaleFraction(Int32 srcFractPrec,
              Lng32 srcFraction,
              Int32 dstFractPrec,
              NABoolean *roundedDownFlag = NULL)
{

  // The roundedDownFlag indicates if any data is lost when scaling
  // the fraction field of the datetime value.
  //
  if (roundedDownFlag)
    *roundedDownFlag = FALSE; // assume success

  Lng32 fraction = 0;
 
  // If there is a fraction value in the destination and there is a
  // fraction value in the source, scale the fraction to the
  // destination precision.
  //
  if (dstFractPrec >= 0 && srcFractPrec > 0) {

    fraction = srcFraction;

    if (srcFractPrec < dstFractPrec) {

      Lng32 multiplier = powersOfTen[dstFractPrec - srcFractPrec];
      fraction *= multiplier;

    } else if (srcFractPrec > dstFractPrec) {

      Lng32 divisor = powersOfTen[srcFractPrec - dstFractPrec];
      fraction /= divisor;

      if (roundedDownFlag && ((fraction * divisor) < srcFraction)) {
          *roundedDownFlag = TRUE;
      }
    }

    // If the two precisions are equal, no scaling is required.
    //
  }
  return fraction;
}

// currentTimeStamp() ================================================
// This static method populates the given buffer (char *) with the
// value of the current timestamp in the format of an ExpDatetime
// value (i.e., 2-1-1-1-1-1-4 for YEAR through FRACTION).  This method
// can be used anywhere the current timestamp is needed in this
// form. For instance ex_function_current::eval() in
// exp/exp_function.cpp.
//
// The result is returned in the buffer pointed to by the parameter
// 'resultData'.  This buffer must be allocated by the caller and it
// must be large enough to hold a complete timestamp (11 bytes).
//
// This method was added as part of the MP Datetime Compatibility
// project.  The code for the method came from
// ex_function_current::eval() in exp_function.cpp
// ===================================================================
short
ExpDatetime::currentTimeStamp(char *dstData,
                              rec_datetime_field startField,
                              rec_datetime_field endField,
                              short fractPrec)
{
  // The Timestamp fields decared to have the same size as the
  // corresponding field of the ExpDatetime format (YYMDHMSFFFF).
  //
  short year;
  char month;
  char day;
  char hour;
  char minute;
  char second;
  Lng32 fraction;

  // Get the value of the current timestamp.
  //
  Int64 juliantimestamp = CONVERTTIMESTAMP(JULIANTIMESTAMP(0,0,0,-1),0,-1,0);

  // Convert the timestamp into an array of shorts with each element
  // containing the value of one field of the timestamp.
  //
  short timestamp[8];
  INTERPRETTIMESTAMP(juliantimestamp, timestamp);

  // Extract the fields into local variables which correspond in size
  // to the fields of the ExpDatetime format (YYMDHMSFFFF).
  //
  year = timestamp[0];
  month = (char) timestamp[1];
  day = (char) timestamp[2];
  hour = (char) timestamp[3];
  minute = (char) timestamp[4];
  second = (char) timestamp[5];
  fraction = timestamp[6] * 1000 + timestamp[7];

  // Copy all the fields to the result value.
  //
  for (Int32 field = startField; field <= endField; field++) {

    switch (field) {
    case REC_DATE_YEAR:
      str_cpy_all(dstData, (char *) &year, sizeof(year));
      dstData += sizeof(year);
      break;
    case REC_DATE_MONTH:
      *dstData++ = month;
      break;
    case REC_DATE_DAY:
      *dstData++ = day;
      break;
    case REC_DATE_HOUR:
      *dstData++ = hour;
      break;
    case REC_DATE_MINUTE:
      *dstData++ = minute;
      break;
    case REC_DATE_SECOND:
      *dstData++ = second;

      // If there is a fractional precision in the destination,
      // copy and scale it from the source.
      //
      if (fractPrec > 0) {

        fraction = scaleFraction(MAX_DATETIME_FRACT_PREC, fraction,fractPrec);
        str_cpy_all(dstData, (char *) &fraction, sizeof(fraction));
      }
      break;
    default:
      return -1;
    }
  }

  return 0;
}

// sizeofDatetimeFields() ==============================================
// This static helper function for the ExpDatetime class is used to
// determine the size in number of bytes, of a range of datetime fields.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static Lng32
sizeofDatetimeFields(rec_datetime_field startField,
                     rec_datetime_field endField,
                     short fractPrec)
{
  Lng32 sizeInBytes = 0;

  if (startField <= endField) {
    
    // All fields have at least one byte.
    //
    sizeInBytes = endField - startField + 1;
    
    // The YEAR field has two bytes, so add an extra.
    //
    if(startField == REC_DATE_YEAR) {
      sizeInBytes++;
    }

    // The FRACTION field has 4 bytes, so if it is present add 4.
    //
    if(endField == REC_DATE_SECOND && fractPrec > 0) {
      sizeInBytes += sizeof(Lng32);
    }
  }

  return sizeInBytes;
}

// copyDatetimeFields() ==============================================
// This static helper function for the ExpDatetime class is used to
// copy a set of fields from one datetime value to another.  If
// present, the fraction value is scaled to match the destination
// before coping.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static short
copyDatetimeFields(rec_datetime_field startField,
                   rec_datetime_field endField,
                   short srcFractPrec,
                   short dstFractPrec,
                   char *srcData,
                   char *dstData,
                   Lng32 dstLen,
                   NABoolean *roundedDownFlag)
{

  // get the size of all the fields, excluding the fraction field if
  // present.
  //
  Lng32 size = sizeofDatetimeFields(startField, endField, 0);

  // Copy all the fields, excluding the fraction field.
  //
  str_cpy_all(dstData, srcData, size);

  dstData += size;
  srcData += size;

  // If there is a fractional precision in the destination,
  // copy and scale the fraction from the source.
  //
  if (endField == REC_DATE_SECOND && dstFractPrec >= 0) {
    Lng32 fraction = 0;

    // If there is a fraction precision in the source datetime
    // value, scale it to the precision of the destination
    // datetime If no fractional precision is given, use the
    // default value of 0.
    //
    if (srcFractPrec > 0) {
      str_cpy_all((char *)&fraction, srcData, sizeof(fraction));
      
      fraction = scaleFraction(srcFractPrec,
                               fraction,
                               dstFractPrec,
                               roundedDownFlag);
    }
    // if destination has space for fraction, copy it.
    if ((dstLen > 0) && (dstLen >= (size + sizeof(fraction))))
      str_cpy_all(dstData, (char *) &fraction, sizeof(fraction));
  }
  return 0;
}

// minimumTimeStamp() ================================================
// This static helper function for the ExpDatetime class is used to
// construct a minimum datetime value for the given start and end
// fields.
//
// The Minimum timestamp is:
//
//   0001-01-01 00:00:00.000000
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static short
minimumTimeStamp(char *dstData,
                 rec_datetime_field dstStartField,
                 rec_datetime_field dstEndField,
                 short dstFractPrec)
{

  for (Int32 field = dstStartField; field <= dstEndField; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      {
        short year = 1;
        str_cpy_all(dstData, (char *)&year, sizeof(year));
        dstData += sizeof(year);
        break;
      }
    case REC_DATE_MONTH:
    case REC_DATE_DAY:
      *dstData++ = (char) 1;
      break;
    case REC_DATE_HOUR:
    case REC_DATE_MINUTE:
      *dstData++ = (char) 0;
      break;
    case REC_DATE_SECOND:
      *dstData++ = (char) 0;
      if (dstFractPrec) {
        Lng32 fraction = 0;
        str_cpy_all(dstData, (char *)&fraction, sizeof(Lng32));
        dstData += sizeof(Lng32);
      }
      break;
    default:
      return -1;
    }
  }
  return 0;
}

// convDatetimeDatetime() ============================================
// This method is used to convert the given datetime value to another
// datetime value.  Missing leading fields are handled by
// Cast::preCodeGen() this method should never see them.  Missing
// trailing fields are padded with their minimum value.  This method
// will be used by convDatetimeDatetime (in exp_conv.cpp)
//
// The result is returned in the buffer pointed to by the parameter
// 'dstData'.  This buffer must be allocated by the caller and it
// must be large enough to hold the result.
//
// This method was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
short
ExpDatetime::convDatetimeDatetime(char *srcData,
                                  rec_datetime_field dstStartField,
                                  rec_datetime_field dstEndField,
                                  short dstFractPrec,
                                  char *dstData,
                                  Lng32 dstLen,
                                  short validateFlag,
                                  NABoolean *roundedDownFlag)
{

  rec_datetime_field srcStartField;
  rec_datetime_field srcEndField;
  
  rec_datetime_field endField;
  NABoolean LastDayPrevMonth = FALSE;

  // Get the start and end fields for the source datetime type.
  //
  if (getDatetimeFields(getPrecision(),
                        srcStartField,
                        srcEndField) != 0) {
    return -1;
  }

  // Are there any missing leading fields or do the src and dst fields
  // not overlap?  If so, this is an error.  (missing leading fields
  // are handled by Cast::preCodeGen()).
  //
  if (dstStartField < srcStartField ||
      srcEndField < dstStartField ||
      dstEndField < srcStartField) {
    return -1;
  }

  // Skip over source fields that are not in the destination.
  //
  srcData += sizeofDatetimeFields(srcStartField, 
                                  (rec_datetime_field)(dstStartField - 1),
                                  getScale());
  srcStartField = dstStartField;
  endField = srcEndField;
  if (endField > dstEndField) {
    endField = dstEndField;
  }

  // Copy required source fields to destination.
  //
  if (copyDatetimeFields(dstStartField,
                         endField,
                         getScale(),
                         dstFractPrec,
                         srcData,
                         dstData,
                         dstLen,
                         roundedDownFlag) != 0) {
    return -1;
  }

  if (validateFlag && validateDate(dstStartField, endField, 
                                   dstData, NULL, FALSE,
                                   LastDayPrevMonth)) 
    return -1;
 
  // Skip over copied source fields.
  //
  dstData += sizeofDatetimeFields(dstStartField, endField, dstFractPrec);
  dstStartField = (rec_datetime_field)(endField + 1);
  
  // If we still have more fields in the destination, pad them with
  // the minimum timestamp.
  //
  if (dstStartField <= dstEndField) {
    if (minimumTimeStamp(dstData,
                         dstStartField,
                         dstEndField,
                         dstFractPrec) != 0) {
      return -1;
    }
  }

  return 0;
}

// extractDatetime ===================================================
// This method is used to extract a given range of fields from a
// timestamp value.  This method is used by
// ExpDatetime::addDatetimeInterval and ExpDatetime::subDatetimeInterval.
//
// This method was added as part of the MP Datetime Compatibility
// project.
// ===================================================================
//
short
ExpDatetime::extractDatetime(rec_datetime_field srcStartField,
                             rec_datetime_field srcEndField,
                             short srcFractPrec,
                             char *srcData,
                             char *dstData)
{

  rec_datetime_field dstStartField;
  rec_datetime_field dstEndField;

  // Get the start and end fields for the destination datetime type.
  //
  if (getDatetimeFields(getPrecision(),
                        dstStartField,
                        dstEndField) != 0) {
    return -1;
  }

  if (srcStartField > dstStartField || srcEndField < dstEndField) {
    return -1;
  }

  srcData += sizeofDatetimeFields(srcStartField, 
                                  (rec_datetime_field)(dstStartField - 1),
                                  srcFractPrec);
  
  if (copyDatetimeFields(dstStartField,
                         dstEndField,
                         srcFractPrec,
                         getScale(),
                         srcData,
                         dstData,
                         getLength(),
                         NULL) != 0) {
    return -1;
  }
  
  return 0;
}

// determineFormat() =================================================
// This static helper function for the ExpDatetime class is used to
// determine the datetime format (DEFAULT, USA, or EUROPEAN) of an
// ASCII string.
//
// The ASCII string can be in one of three formats:
//
//  Default : yyyy-mm-dd hh:mm:ss.msssss
//  USA     : mm/dd/yyyy hh:mm:ss.msssss [am|pm]
//  European: dd.mm.yyyy hh.mm.ss.msssss
//
// There are some variations on the formats above:
//   - the delimiter between the date and the time portion
//     can be either a ' ' (space) or a ':'
//   - the [am|pm] in the USA format is case insensitive.
//   - any range of consectutive (YEAR to SECOND) fields may
//     be present.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static
ExpDatetime::DatetimeFormats
determineFormat(char *src,
                rec_datetime_field startField,
                rec_datetime_field endField)
{

  // Find the first non-digit character.  This is the first delimiter
  //
  const char* s = src;
  Int32 firstFieldSize = 0;
  while (isDigit8859_1(*s)) {
    s++;
    firstFieldSize++;
  }

  if ((startField == endField) ||
      (startField == REC_DATE_DAY && endField == REC_DATE_HOUR)) {

    // In this case there is nothing to distinguish the different
    // formats.  Any of them could be used.  Use USA to allow for a
    // possible AM/PM
    //
    return ExpDatetime::DATETIME_FORMAT_USA;

  } else if (((startField == REC_DATE_YEAR) && (endField > REC_DATE_YEAR)) ||
             ((startField < REC_DATE_DAY) && (endField >= REC_DATE_DAY))) {

    // In this case there is a delimiter in the DATE portion of the
    // DATETIME value.  The delimiter will determine the format.
    //
    switch(*s) {
    case '-':
      return ExpDatetime::DATETIME_FORMAT_DEFAULT;
    case '/':
      {
	if (firstFieldSize == 2)
	  return ExpDatetime::DATETIME_FORMAT_USA;
	else
	  return ExpDatetime::DATETIME_FORMAT_ERROR;
      }
    case '.':
      return ExpDatetime::DATETIME_FORMAT_EUROPEAN;
    default:
      return ExpDatetime::DATETIME_FORMAT_ERROR;
    }
  } else if (((startField <= REC_DATE_HOUR) && (endField > REC_DATE_HOUR)) ||
             ((startField < REC_DATE_SECOND) && (endField == REC_DATE_SECOND))) {
    // In this case there is no delimiter in the DATE portion, but
    // there is one in the TIME portion of the DATETIME value.  This
    // delimiter will determine the format.
    //

    // If the is a delimiter before the TIME portion, go to the next
    // delimiter.  This can happen if the DATE portion only has a DAY
    // field.
    //
    if (startField == REC_DATE_DAY) {
      s++;
      while (isDigit8859_1(*s)) {
        s++;
      }
    }

    // : could be either USA or DEFAULT.  Use USA to allow for a
    // possible AM/PM.
    //
    switch(*s) {
    case ':' :
      return ExpDatetime::DATETIME_FORMAT_USA;
    case '.' :
      return ExpDatetime::DATETIME_FORMAT_EUROPEAN;
    default:
      return ExpDatetime::DATETIME_FORMAT_ERROR;
    }
  }
  
  // Any other delimiter is an error.
  //
  return ExpDatetime::DATETIME_FORMAT_ERROR;
}

// containsField() ===================================================
// This static helper function for the ExpDatetime class is used to
// determine if a given field is contained within the range of the
// given start and end fields.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static
NABoolean
containsField(rec_datetime_field field,
              rec_datetime_field startField,
              rec_datetime_field endField)
{
  // The field is contained within the range if it is bounded by the
  // start and end fields OR if the field is FRACTION and the range
  // contains a SECOND field.  In the latter case, the FRACTION field
  // is optional, but this function still returns TRUE.
  //
  if ((field >= startField && field <= endField) ||
      ((endField == REC_DATE_SECOND) && (field == REC_DATE_FRACTION_MP))) {
    return TRUE;
  } else {
    return FALSE;
  }
}

// scanField() =======================================================
// This static helper function for the ExpDatetime class is used to
// scan the various fields of a ASCII datetime value.
//
// parameters:
//
// src - IN/OUT
//       Pointer to field of the ASCII datetime value.  As an input,
//       it should point to the delimiter before the field to be
//       scanned.  If no delimiter is expected, it should point to the
//       field to be scanned. As an output, upon return, this
//       parameter will point to the character just beyond this field,
//       or the first non-digit character encounter while scanning the
//       field.
//
// srcEnd - IN
//       Pointer to the character just beyond the end of the datetime
//       value.  This is required since the datetime value will not
//       always be NULL terminated.
//
// field - IN
//       The type of field to be scanned.
//
// exptDelim - IN
//       The expected leading delimiter. The NULL character if a
//       delimiter is not expected.
//
// fractPrec - IN
//       The fractional precision of the destination.  Used to perform
//       scaling of the sources fraction.
//
// value - OUT
//       The numeric value of the scanned field
//
// heap and diagsArea
//       Used to report some errors while scanning.
//
// return - OUT
//       returns FALSE if an error occurred while scanning, TRUE
//       otherwise.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static
NABoolean
scanField(char *&src,
          char *srcEnd,
          rec_datetime_field field,
          char exptDelim,
          Lng32 &fractPrec,
          Lng32 &value,
          CollHeap *heap,
          ComDiagsArea** diagsArea,
	  ULng32 flags) 
{
  NABoolean noDatetimeValidation = (flags & CONV_NO_DATETIME_VALIDATION) != 0;
  NABoolean noHadoopDateFix = (flags & CONV_NO_HADOOP_DATE_FIX) != 0;

  // The maximum lengths of the various fields.  Since the value of
  // REC_DATE_YEAR is 1, the first entry is just a place holder.
  //
  static const Lng32 maxLens[] =  { 0,    4,  2,  2,  2,  2,  2,         9 };
  static const Lng32 minValue[] = { 0, 0001, 01, 01, 00, 00, 00, 000000000 };
  static const Lng32 maxValue[] = { 0, 9999, 12, 31, 23, 59, 59, 999999999 };

  // The length of the scanned field.
  //
  short len = 0;

  // The numeric value of the scanned field.
  //
  value = 0;

  // The leading delimiter in the source string.
  //
  char delim;

  // If we are expecting a leading delimiter, make sure the actual
  // delimiter matches the expected.
  //
  if (exptDelim) {

    // Get the actual delimiter
    //
    if (src < srcEnd && *src) {
      delim = *src++;
    } else {
      delim = '\0';
    }

    // Check actual delimiter against the expected delimiter. 
    // An expected delimiter of ';' matches a ':' or a ' ' (space).
    // An expected delimiter of '|' matches a ':' or a ' ' (space) or 'T' (ISO format).
    // A NULL actual delimiter matches any expected delimiter.
    //
    if (delim) {
      if (exptDelim == '-' ||
          exptDelim == '/' ||
          exptDelim == '.' ||
          exptDelim == ':' ||
          exptDelim == ' ') {
        if (delim != exptDelim) {
          return FALSE;
        }
      } else if (exptDelim == ';') {
        if (delim != ':' && delim != ' ') {
          return FALSE;
        }
      } else if (exptDelim == '|') {
        if (delim != ':' && delim != ' ' && delim != 'T') {
          return FALSE;
        }
      } else {
        return FALSE;
      }
    }
  }

  
  // Convert the string of digits into a numeric value.  Stop scanning
  // when the max. number of digits for this field have been scanned
  // or if a non-digit is encountered or if the end of the source was
  // reached
  //

  for (len = 0;
       len < maxLens[field] && src < srcEnd && isDigit8859_1(*src);
       len++) {
    value = (value * 10) + (*src++ - '0');
  }

  // Scale the fraction of the source to match the fractional
  // precision of the destination.
  //
  if (field == REC_DATE_FRACTION_MP) {
    value = scaleFraction(len, value, fractPrec);
    fractPrec = len;
  }

  // For all but the FRACTION field, datetime fields are required to
  // have the maximum length.
  //
  if (len < maxLens[field] && field != REC_DATE_FRACTION_MP) {

    if ((NOT noHadoopDateFix) &&
        (field >= REC_DATE_HOUR)) {
      // extend with zeroes
      value = 0;
    }
    else {
      // An unknown character was encountered in the string.
      //
      char hexstr[MAX_OFFENDING_SOURCE_DATA_DISPLAY_LEN];
      ExRaiseSqlError(heap, diagsArea, EXE_CONVERT_STRING_ERROR,NULL,NULL,NULL,NULL,stringToHex(hexstr, sizeof(hexstr), src, srcEnd-src));

      return FALSE;
    }
  } else if (src < srcEnd && isDigit8859_1(*src)) {
    return FALSE;
  }

  // If the value is too small or too large, the field is invalid.
  //
  if ((NOT noDatetimeValidation) &&
      (value < minValue[field] || value > maxValue[field])) {
    return FALSE;
  }

  return TRUE;
}

short
ExpDatetime::convAsciiToDatetime(char *srcData,
                                 Lng32 srcLen,
                                 char *dstData,
                                 Lng32 dstLen,
                                 rec_datetime_field dstStartField,
                                 rec_datetime_field dstEndField,
                                 Lng32 format,
                                 Lng32 &scale,
                                 CollHeap *heap,
                                 ComDiagsArea** diagsArea,
				 ULng32 flags)
{

  NABoolean noDatetimeValidation = (flags & CONV_NO_DATETIME_VALIDATION) != 0;
  Lng32 originalSrcLen = srcLen;
  char * originalSrcData = srcData; 
  // skip leading and trailing blanks and adjust srcData and srcLen
  // accordingly
  //
  NABoolean LastDayPrevMonth = FALSE;

  Lng32 i;
  for (i = 0; i < srcLen && *srcData == ' '; i++) {
    srcData++;
  }

  if (i == srcLen) {
    // string contains only blanks.
    //
    ExRaiseSqlError(heap, diagsArea, EXE_CONVERT_DATETIME_ERROR);
    if(*diagsArea != NULL)
      **diagsArea << DgString0("(string contains only blanks)");   
    return -1;
  };

  srcLen -= i;

  // we know that we found at least one non-blank character.
  // so we just decrement srcLen till we scanned all
  // trailing blanks
  //
  while (srcData[srcLen - 1] == ' ') {
    srcLen--;
  }

  // Indicates if an " AM" or " PM" strings appears at the end of the
  // source.
  // 0 - means no AM/PM indicator
  // 1 - means AM 
  // 2 - means PM
  //
  short usaAmPm = 0;

  // Check for the " AM" or " PM" at the end of the source.  If it is
  // there, record and adjust the srcLen to in effect remove it from
  // the source.
  //
  if ((srcData[srcLen - 3] == ' ') &&
      ((srcData[srcLen - 2] == 'A') || (srcData[srcLen - 2] == 'a')) &&
      ((srcData[srcLen - 1] == 'M') || (srcData[srcLen - 1] == 'm'))) {
    usaAmPm = 1;
    srcLen -= 3;
  } else if ((srcData[srcLen - 3] == ' ') &&
             ((srcData[srcLen - 2] == 'P') || (srcData[srcLen - 2] == 'p')) &&
             ((srcData[srcLen - 1] == 'M') || (srcData[srcLen - 1] == 'm'))) {
    usaAmPm = 2;
    srcLen -= 3;
  }    

  // Indicates if a 'Z' appears at the end of source.
  // 'Z' is a local timezone indicator for ISO format datetime values.
  // 0 - means no 'Z' indicator
  // 1 - means Z
  //
  short defZ = 0;

  // Check for the " AM" or " PM" at the end of the source.  If it is
  // there, record and adjust the srcLen to in effect remove it from
  // the source.
  //
  if ((usaAmPm == 0) && (srcData[srcLen - 1] == 'Z')) {
    defZ = 1;
    srcLen -= 1;
  } 

  char *src = srcData;
  char *srcEnd = srcData + srcLen;

  // Determine the format of the source string.
  //
  if (format == DATETIME_FORMAT_NONE)
    format = determineFormat(src, dstStartField, dstEndField);
  
  // If the format could not be determined, issue an error.
  //
  if (format == DATETIME_FORMAT_ERROR) {
    raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
    return -1;
  }

  // check to see if they are timezone adjustment designator
  // as per ISO8601 datetime format.
  // TZD is of the form: +HH:MM pr -HH:MM
  //
  NABoolean TZD = FALSE;
  NABoolean isAdd = FALSE;
  Lng32 hh = 0;
  Lng32 mm = 0;
  Lng32 tzdSize = strlen("+HH:MM");
  char * tzd = NULL;
  if ((srcLen > tzdSize) &&
      (tzd = (srcEnd - tzdSize)) &&
      ((tzd[0] == '+') ||
       (tzd[0] == '-')) &&
      (tzd[3] == ':')) {
    hh = str_atoi(&tzd[1], strlen("HH"));
    mm = str_atoi(&tzd[4], strlen("MM"));
    
    if (tzd[0] == '+')
      isAdd = FALSE;
    else
      isAdd = TRUE;
    
    TZD = TRUE;
    
    srcLen -= tzdSize;
    srcEnd -= tzdSize;
  } // tzd specified

  // if timezone is specified and end field is not DAY, return error.
  if ((defZ || TZD) && (dstEndField == REC_DATE_DAY))
    {
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
    }

  //  The order of the fields for the various formats.
  //
  static const rec_datetime_field realFields[][DATETIME_MAX_NUM_FIELDS] = {
    { REC_DATE_YEAR,
      REC_DATE_MONTH,
      REC_DATE_DAY,
      REC_DATE_HOUR,
      REC_DATE_MINUTE,
      REC_DATE_SECOND,
      REC_DATE_FRACTION_MP},   // DEFAULT

    { REC_DATE_MONTH,
      REC_DATE_DAY,
      REC_DATE_YEAR,
      REC_DATE_HOUR,
      REC_DATE_MINUTE,
      REC_DATE_SECOND,
      REC_DATE_FRACTION_MP},   // USA

    { REC_DATE_DAY,
      REC_DATE_MONTH,
      REC_DATE_YEAR,
      REC_DATE_HOUR,
      REC_DATE_MINUTE,
      REC_DATE_SECOND,
      REC_DATE_FRACTION_MP}    // EUROPEAN

  };
    
  // The order of the leading delimiters for the various formats.  
  // 'x' - indicates the no leading delimiter is expected for the
  // first field.
  //
  static const char delimiters[][DATETIME_MAX_NUM_FIELDS+1] = {
    "x--|::.",  // DEFAULT
    "x//;::.",  // USA
    "x..;..."   // EUROPEAN
  };

  // Used to hold the scanned values of the datetime value.
  //
  Lng32 datetimeValues[DATETIME_MAX_NUM_FIELDS+1];
  
  // Until the first field is scanned, no leading delimiter is
  // expected.
  //
  NABoolean needDelimiter = FALSE;

  // The expected delimiter.  The Null character indicates to
  // scanField that no leading delimiter is expected.
  //
  char delim = '\0';

  // Iterate over all the fields in the order dictated by the format.
  // Only fields the should be present are actually scanned.
  //
  Int32 field;
  Lng32 trueScale = scale;
  for (field = 0; field < DATETIME_MAX_NUM_FIELDS; field++) {
    
    // Determine the field expected for this format.
    //
    rec_datetime_field realField = realFields[format][field];
  
    // Scan this field only if it is contained within the destinations
    // start and end field.
    //
    if (containsField(realField, dstStartField, dstEndField)) {

      // Get the expected leading delimiter if one is required.
      //
      if(needDelimiter)
        delim = delimiters[format][field];
      
      // After the first field is scanned, a leading delimiter is
      // always required.
      //
      needDelimiter = TRUE;

      // Scan the field.
      // src - advanced to the next field.
      // datetimeVValues[realField] is set to the scanned value.
      //
      if (!scanField(src,
                     srcEnd,
                     realField,
                     delim,
                     trueScale,
                     datetimeValues[realField],
                     heap,
                     diagsArea,
   	             flags)) {
        raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
        return -1;
      }
    }
  }

  // If there are any remaining characters in the input string.
  if (src != srcEnd) {
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
  }

  // Adjust the value of the hour field if an "AM" or "PM" was
  // present.
  //
  if (format == DATETIME_FORMAT_USA && 
      containsField(REC_DATE_HOUR, dstStartField, dstEndField) &&
      usaAmPm) {
    if (datetimeValues[REC_DATE_HOUR] > 12) {
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
    }

    if (usaAmPm == 1) {

      // " AM" present.
      //
      if (datetimeValues[REC_DATE_HOUR] == 12) {
        datetimeValues[REC_DATE_HOUR] = 0;
      }
    } else {

      // " PM" present.
      //
      if (datetimeValues[REC_DATE_HOUR] < 12) {
        datetimeValues[REC_DATE_HOUR] += 12;
      }
    }
  } else if (usaAmPm) {
    raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
    return -1;
  }
    
  short year = 1900;
  char month = 1;
  char day = 1;
  char hour = 0;
  char minute = 0;
  char second = 0;
  Lng32 fraction = 0;
  
  // Copy the parsed values to the destination.
  //
  char *dst = dstData;
  for (field = dstStartField; field <= dstEndField ; field++) {
    switch (field) {
    case REC_DATE_YEAR:
      {
        year = (short)datetimeValues[field];
        str_cpy_all(dst, (char *)&year, sizeof(year));
        dst += sizeof(year);
      }
      break;
    case REC_DATE_MONTH:
      month = (char)datetimeValues[field];
      *dst++ = month;
      break;
    case REC_DATE_DAY:
      day = (char)datetimeValues[field];
      *dst++ = day;
      break;
    case REC_DATE_HOUR:
      hour = (char)datetimeValues[field];
      *dst++ = hour;
      break;
    case REC_DATE_MINUTE:
      minute = (char)datetimeValues[field];
      *dst++ = minute;
      break;
    case REC_DATE_SECOND:
      second = (char)datetimeValues[field];
      *dst++ = second;
      if (scale) {
        fraction = datetimeValues[field + 1];
        str_cpy_all(dst, (char *)&fraction, sizeof(fraction));
        dst += sizeof(fraction);
      }
      break;
    default:
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
    }
  }

  scale = trueScale;

  // Validate the date fields of the result.
  //
  if (NOT noDatetimeValidation)
    if (validateDate(dstStartField, dstEndField, 
		     dstData, NULL, FALSE, 
		     LastDayPrevMonth)) {
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
    };

  if (TZD) {
    // timezone specified. Compute the new datetime value.

    // first, convert current datetime value to juliantimestamp
    Lng32 jtsFraction = fraction / 1000;
    short timestamp[] = {
      year, month, day, hour, minute, second, 
      (short)(jtsFraction / 1000), (short)(jtsFraction % 1000)
    };
    
    short error;
    Int64 juliantimestamp = COMPUTETIMESTAMP(timestamp, &error);
    if (error) {
      raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
      return -1;
    }

    Int64 usec = (hh*60L + mm) * 60L * 1000000L;
    if (isAdd)
      juliantimestamp += usec;
    else
      juliantimestamp -= usec;

    INTERPRETTIMESTAMP(juliantimestamp, timestamp);
    
    char *dst = dstData;
    for (field = dstStartField; field <= dstEndField ; field++) {
      switch (field) {
      case REC_DATE_YEAR:
        {
          year = timestamp[0];
          str_cpy_all(dst, (char *)&year, sizeof(year));
          dst += sizeof(year);
        }
        break;
      case REC_DATE_MONTH:
        month = (char) timestamp[1];
        *dst++ = month;
        break;
      case REC_DATE_DAY:
        day = (char) timestamp[2];
        *dst++ = day;
        break;
      case REC_DATE_HOUR:
        hour = (char) timestamp[3];
        *dst++ = hour;
        break;
      case REC_DATE_MINUTE:
        minute = (char) timestamp[4];
        *dst++ = minute;
        break;
      case REC_DATE_SECOND:
        second = (char) timestamp[5];
        *dst++ = second;
        if (scale) {
          //fraction = timestamp[6] * 1000 + timestamp[7];
          str_cpy_all(dst, (char *)&fraction, sizeof(fraction));
          dst += sizeof(fraction);
        }
        break;
      default:
        raiseDateConvErrorWithSrcData(originalSrcLen,diagsArea, originalSrcData, heap);
        return -1;
      }
    }
    
  } // TZD
  
  // Success
  //
  return 0;
    
}

short
ExpDatetime::convAsciiToDatetime(char *srcData,
                                 Lng32 srcLen,
                                 char *dstData,
                                 Lng32 dstLen,
                                 Lng32 format,
                                 CollHeap *heap,
                                 ComDiagsArea** diagsArea,
				 ULng32 flags)
{
  rec_datetime_field dstStartField;
  rec_datetime_field dstEndField;

  if (getDatetimeFields(getPrecision(),
                        dstStartField,
                        dstEndField) != 0) {
    return -1;
  }

  Lng32 scale = getScale();
  return convAsciiToDatetime(srcData, srcLen, dstData, dstLen,
                             dstStartField, dstEndField, format, scale,
                             heap, diagsArea, flags);
}

static NABoolean convertStrToMonth(char* &srcData, char *result,
                                   const char * nextByte,
                                   CollHeap * heap, ComDiagsArea** diagsArea)
{
  int copyLen = strlen(srcData);
  char * originalSrcData = srcData;
  const char * months[] = 
  {
    "JAN", 
    "FEB", 
    "MAR", 
    "APR", 
    "MAY", 
    "JUN", 
    "JUL", 
    "AUG", 
    "SEP", 
    "OCT",
    "NOV", 
    "DEC"
  };

  for (Int32 i = 0; i < 12; i++)
    {
      char upVal[3];
      str_cpy_convert(upVal, srcData, 3, 1);
      if (memcmp(upVal, months[i], 3) == 0)
	{
	  *result = (char)(i + 1);

          srcData += 3;

          if (nextByte)
            {
              if (*srcData != *nextByte)
                {
                  // string contains non-digit
                  raiseDateConvErrorWithSrcData(copyLen,diagsArea, originalSrcData, heap);
                  return FALSE; // error
                }    
              srcData++;
            }

	  return TRUE;
	}
    } // for
  
  // error
  raiseDateConvErrorWithSrcData(copyLen,diagsArea, originalSrcData, heap);
  return FALSE;
}

static NABoolean 
convertStrToMonthLongFormat(char* &value, char *result)
{
  const char * months[] = 
  {
    "JANUARY", 
    "FEBRUARY", 
    "MARCH", 
    "APRIL", 
    "MAY", 
    "JUNE", 
    "JULY", 
    "AUGUST", 
    "SEPTEMBER", 
    "OCTOBER",
    "NOVEMBER", 
    "DECEMBER"
  };

  for (Int32 i = 0; i < 12; i++)
    {
      char upVal[10];
      str_cpy_convert(upVal, value, strlen(months[i]), 1);
      if (memcmp(upVal, months[i], strlen(months[i])) == 0)
	{
	  *result = (char)(i + 1);
          value += strlen(months[i]);
	  return TRUE;
	}
    }

  // error
  return FALSE;
}

static short convSrcDataToDst(Lng32 numSrcBytes, char* &srcData, 
                               Lng32 numTgtBytes, char *dstData,
                               const char * nextByte,
                               CollHeap * heap, ComDiagsArea** diagsArea)
{
  Lng32 src = 0;
  Lng32 val = 0;
  for (val = 0, src = 0; src < numSrcBytes && isDigit8859_1(*srcData); 
       src++, srcData++)
    val = val * 10 + (*srcData - '0');
  
  if (src < numSrcBytes) 
    {
      // string contains non-digit
      raiseDateConvErrorWithSrcData(numSrcBytes,diagsArea, srcData, heap);
      return -1;
    }

  if (numTgtBytes == sizeof(Lng32))
    *(Lng32*)dstData = val;
  else if (numTgtBytes == sizeof(short))
    *(short*)dstData = val;
  else if (numTgtBytes == sizeof(char))
    *(char*)dstData = val;
  else 
    return -1;

  if (nextByte && (strlen(nextByte) > 0))
    {
      if (*srcData != *nextByte)
        {
          // string contains non-digit
          raiseDateConvErrorWithSrcData(numSrcBytes,diagsArea, srcData, heap);
          return -1;
        }    

      srcData++;
    }

  return 0;
}

//////////////////////////////////////////////////////////////////////////
// ExpDatetime::convAsciiToDate() ================================
// This method is used to convert the given ASCII string
// to a datetime date value.
//
// The result is returned in the buffer pointed to by the parameter
// 'dstData'. This buffer must be allocated by the caller and it
// must be large enough to hold the result.
//
// This method is called assuming the correct source format. The source
// string must contain date and, possibly, leading and trailing blanks
// only. The size of destination buffer should be just enough to hold
// internal representation of the date value, i.e. 4 bytes.
//
// target dstData has the format:
//  Timestamp:
//    dstData[0..1]               2-bytes for year.
//    dstData[2] .. dstData[6]    1-byte for month through second.
//    dstData[7..10]              4-bytes for fraction.
// Date:
//    dstData[0..1]               2-bytes for year.
//    dstData[2] .. dstData[3]    1-byte for month through day.
//  Time:
//    dstData[0] .. dstData[2]    1-byte for hour through second.
// =====================================================================
//
short
ExpDatetime::convAsciiToDate(char *srcData,
                             Lng32 inSrcLen,
                             char *dstData,
                             Lng32 dstLen,
			     Int32 format,
                             CollHeap *heap,
                             ComDiagsArea** diagsArea,
			     ULng32 flags)
{
  NABoolean noDatetimeValidation = (flags & CONV_NO_DATETIME_VALIDATION) != 0;
  char * timeData = NULL;  // assume no time data
  char * origSrcData = srcData;

  short year;
  Lng32  srcFormat, i;
  NABoolean LastDayPrevMonth = FALSE;

  Lng32 srcLen = inSrcLen;
  if (*srcData == ' ') {
    // skip leading blanks and adjust srcData and srcLen accordingly
    //
    for (i = 0; i < srcLen && *srcData == ' '; i++) {
      srcData++;
    }

    if (i == srcLen) {
      // string contains only blanks.
      raiseDateConvErrorWithSrcData(inSrcLen,diagsArea, srcData, heap);
      return -1;
    };

    srcLen -= i;
  };

  // need to decide what the source format is
  // 
  if (format == DATETIME_FORMAT_NONE)
    srcFormat = determineFormat(srcData, REC_DATE_YEAR, REC_DATE_DAY);
  else
    srcFormat = format;

  Lng32 minLength = getDatetimeFormatLen(srcFormat, TRUE,
					REC_DATE_YEAR, REC_DATE_DAY);
  if ((minLength <= 0) || (srcLen < minLength)) {
    // string doesn't seem to contain all date fields.
    //
    raiseDateConvErrorWithSrcData(inSrcLen,diagsArea, srcData, heap);
    return -1;
  };

  switch (srcFormat) {
  case DATETIME_FORMAT_DEFAULT: // YYYY-MM-DD
    {
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, "-", heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], "-", heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], NULL, heap, diagsArea))
        return -1;
    }; 
    break;

  case DATETIME_FORMAT_DEFAULT2: // YYYY-MM
    {
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, "-", heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], NULL, heap, diagsArea))
        return -1;

      // the day
      // day is not specified, fill in as '1' (first day of month).
      dstData[3] = 1;
    }; 
    break;

  case DATETIME_FORMAT_TS3: // YYYY-MM-DD HH24:MI:SS
    {
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, "-", heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], "-", heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], " ", heap, diagsArea))
        return -1;
      
      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ":", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], ":", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
    };  
    break;

  case DATETIME_FORMAT_USA:   // MM/DD/YYYY AM|PM
  case DATETIME_FORMAT_USA2:  // MM/DD/YYYY
  case DATETIME_FORMAT_USA6:  // MM/DD/YY
  case DATETIME_FORMAT_USA7:  // MM-DD-YYYY
    {
      char sep = (srcFormat == DATETIME_FORMAT_USA7 ? '-' : '/');

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], &sep, heap,diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], &sep, heap, diagsArea))
        return -1;

      // the year
      Int32 numOfYdigits = (srcFormat == DATETIME_FORMAT_USA6 ? 2 : 4);
      if (convSrcDataToDst(numOfYdigits, srcData, 2, dstData, NULL, heap, diagsArea))
        return -1;
    }; 
    break;

  case DATETIME_FORMAT_TS6:   // MMDDYYYY HH24:MI:SS
  case DATETIME_FORMAT_TS7:   // MM/DD/YYYY HH24:MI:SS
    {
      char sep = '/';
      char * septr = (srcFormat == DATETIME_FORMAT_TS7 ? &sep : NULL);

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], septr, heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], septr, heap, diagsArea))
        return -1;
      
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, " ", heap, diagsArea))
        return -1;

      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ":", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], ":", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
     };
    break;

  case DATETIME_FORMAT_USA3: // YYYY/MM/DD
  case DATETIME_FORMAT_USA4: // YYYYMMDD
  case DATETIME_FORMAT_USA5: // YY/MM/DD
    {
      // the year
      Lng32 numYearDigits = (srcFormat == DATETIME_FORMAT_USA5 ? 2 : 4);
      char sep = '/';
      char * septr = (srcFormat == DATETIME_FORMAT_USA4 ? NULL : &sep);

      // the year
      if (convSrcDataToDst(numYearDigits, srcData, 2, dstData, septr, heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], septr, heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], NULL, heap, diagsArea))
        return -1;

     };
    break;

  case DATETIME_FORMAT_USA8: // YYYYMM
    {
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, NULL, heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], NULL, heap, diagsArea))
        return -1;

      // the day
      // day is not specified, fill in as '1' (first day of month).
      dstData[3] = 1;
    };
    break;

  case DATETIME_FORMAT_TS1: // YYYYMMDDHH24MISS
  case DATETIME_FORMAT_TS5: // YYYYMMDD:HH24:MI:SS
    {
      char sep = ':';
      char * septr = (srcFormat == DATETIME_FORMAT_TS1 ? NULL : &sep);
      
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, NULL, heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], NULL, heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], septr, heap, diagsArea))
        return -1;
      
      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], septr, heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], septr, heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
     };  
    break;

  case DATETIME_FORMAT_TS9: // MONTH DD, YYYY, HH:MI AM|PM
    {
      // the month
      char * prevSrcData = srcData;
      if (! convertStrToMonthLongFormat(srcData, &dstData[2])) {
        raiseDateConvErrorWithSrcData(inSrcLen,diagsArea, srcData, heap);
        return -1;
      }
      minLength += (srcData - prevSrcData);
      srcData += 1; // skip blank after "Month"

      // the day
     if (convSrcDataToDst(2, srcData, 1, &dstData[3], ",", heap, diagsArea))
        return -1;
      srcData++;  // skip over blank

      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, ",", heap, diagsArea))
        return -1;
      srcData++;  // skip over blank
      
      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ":", heap, diagsArea))
        return -1;
      
      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], NULL, heap, diagsArea))
        return -1;
      
      dstData[6]  = 0;
      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
    }
    break;

  case DATETIME_FORMAT_EUROPEAN:  // DD.MM.YYYY
  case DATETIME_FORMAT_EUROPEAN2: // DD-MM-YYYY
    {
      char sep = (srcFormat == DATETIME_FORMAT_EUROPEAN ? '.' : '-');

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], &sep, heap, diagsArea))
        return -1;
      
      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], &sep, heap, diagsArea))
        return -1;
      
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, NULL, heap, diagsArea))
        return -1;
    };  
    break;

  case DATETIME_FORMAT_EUROPEAN3: // DD-MON-YYYY
  case DATETIME_FORMAT_EUROPEAN4: // DDMONYYYY
    {
      char sep = '-';
      char * septr = (srcFormat == DATETIME_FORMAT_EUROPEAN3 ? &sep : NULL);
      
      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], septr, heap, diagsArea))
        return -1;
      
      // the month
      if (! convertStrToMonth(srcData, &dstData[2], septr, heap, diagsArea))
        return -1;

      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, NULL, heap, diagsArea))
        return -1;
    };  
    break;

  case DATETIME_FORMAT_TS2:  // DD.MM.YYYY:HH24.MI.SS
  case DATETIME_FORMAT_TS10: // DD.MM.YYYY HH24.MI.SS
    {
      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], ".", heap, diagsArea))
        return -1;
      
      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], ".", heap, diagsArea))
        return -1;
      
      // the year
      if (srcFormat == DATETIME_FORMAT_TS2)
        {
          if (convSrcDataToDst(4, srcData, 2, dstData, ":", heap, diagsArea))
            return -1;
        }
      else
        {
          if (convSrcDataToDst(4, srcData, 2, dstData, " ", heap, diagsArea))
            return -1;
        }
        
      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ".", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], ".", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
    };  
    break;

  case DATETIME_FORMAT_TS11: // YYYY/MM/DD HH24:MI:SS
    {
      char sep = '/';

      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, &sep, heap, diagsArea))
        return -1;

      // the month
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], &sep, heap, diagsArea))
        return -1;

      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], " ", heap, diagsArea))
        return -1;

      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ":", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], ":", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
    };  
    break;

  case DATETIME_FORMAT_TS8: // DD-MON-YYYY HH:MI:SS
    {
      // the day
      if (convSrcDataToDst(2, srcData, 1, &dstData[3], "-", heap, diagsArea))
        return -1;
      
      // the month
      if (! convertStrToMonth(srcData, &dstData[2], "-", heap, diagsArea))
        return -1;
      
      // the year
      if (convSrcDataToDst(4, srcData, 2, dstData, " ", heap, diagsArea))
        return -1;

      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[4], ":", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[5], ":", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[6], NULL, heap, diagsArea))
        return -1;

      dstData[7]  = 0;
      dstData[8]  = 0;
      dstData[9]  = 0;
      dstData[10] = 0;

      timeData = &dstData[4];
     };  
    break;

  case DATETIME_FORMAT_TS4: // HH24:MI:SS
    {
      // the hour
      if (convSrcDataToDst(2, srcData, 1, &dstData[0], ":", heap, diagsArea))
        return -1;

      // the minute
      if (convSrcDataToDst(2, srcData, 1, &dstData[1], ":", heap, diagsArea))
        return -1;

      // the second
      if (convSrcDataToDst(2, srcData, 1, &dstData[2], NULL, heap, diagsArea))
        return -1;

      timeData = &dstData[0];
    };
  break;

  default:
    {
    // Format could not be determined, issue an error.
    raiseDateConvErrorWithSrcData(inSrcLen,diagsArea, srcData, heap);
    return -1;
    }
  };

  // done for all fields. if the source string is not exhausted
  // make sure it contains only blanks
  if (srcLen > minLength) {
    srcLen -= minLength;
    for (i = 0; i < srcLen; i++) {
      if (srcData[i] != ' ') {
        // string contains only blanks.
        raiseDateConvErrorWithSrcData(inSrcLen,diagsArea,srcData,heap);
        return -1;
      }
    }
  }  // if srcLen > 10

  // Validate the date fields of the result.
  //
  if (srcFormat != DATETIME_FORMAT_TS4)
    {
      if (NOT noDatetimeValidation)
	if (validateDate(REC_DATE_YEAR, REC_DATE_DAY, 
			 dstData, NULL, FALSE, 
			 LastDayPrevMonth)) {
          raiseDateConvErrorWithSrcData(inSrcLen,diagsArea,origSrcData,heap);
	  return -1;
	};
    }

  // Validate the time fields of the result
  //
  if (timeData)
    {
      if (NOT noDatetimeValidation)
        if (validateTime(timeData))
          {
            raiseDateConvErrorWithSrcData(inSrcLen,diagsArea,origSrcData,heap);
	    return -1;
          }
    }

  // Success
  //
  return 0;
}

// convertToAscii() ==============================================
// This static helper function of the ExpDatetime class is used by
// convDatetimeToASCII() to convert a numeric value to a string of the
// given width.
//
// 'value' is an input containing the numeric value to be formatted.
//
// 'result' is an input/output parameter pointing to the destination.
// As an output it points to the next available byte in the result
// buffer.
// 
// 'width' is an input specifying the required width of the value.
//
// This function assumes that the value will fit within the specified
// width.
//
// This function was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
static void
convertToAscii(Lng32 value, char *&result, UInt32 width)
{
  UInt32 i = width;
  
  // Format value as a string.
  //
  while ((value != 0) && (i > 0)) {
    result[--i] = '0' + (char) (value % 10);
    value /= 10;
  }

  // Fill in remaining leading characters with '0'
  //
  while (i > 0)
    result[--i] = '0';

  // Update result pointer to point to end of string.
  //
  result += width;
}

static void 
convertMonthToStr(Lng32 value, char *&result, UInt32 width)
{
  const char * months[] = 
  {
    "JAN", 
    "FEB", 
    "MAR", 
    "APR", 
    "MAY", 
    "JUN", 
    "JUL", 
    "AUG", 
    "SEP", 
    "OCT",
    "NOV", 
    "DEC"
  };

  strcpy(result, months[value-1]);

  // Update result pointer to point to end of string.
  //
  result += width;
}

static void
convertDayOfWeekToStr(Lng32 value, char *&result, NABoolean bAbbreviation, UInt32 width)
{
  const char* dayofweek[] =
  {
    "SUNDAY   ",
    "MONDAY   ",
    "TUESDAY  ",
    "WEDNESDAY",
    "THURSDAY ",
    "FRIDAY   ",
    "SATURDAY "
  };

  const char* dayofweek_abb[] =
  {
    "SUN",
    "MON",
    "TUE",
    "WED",
    "THU",
    "FRI",
    "SAT"
  };

  if (bAbbreviation)
    strcpy(result, dayofweek_abb[value-1]);
  else
    strcpy(result, dayofweek[value-1]);
  // Update result pointer to point to end of string.
  result += width;
}

static void 
convertMonthToStrLongFormat(Lng32 value, char *&result, UInt32 width)
{
  const char * months[] = 
  {
    "January", 
    "February", 
    "March", 
    "April", 
    "May", 
    "June", 
    "July", 
    "August", 
    "September", 
    "October",
    "November", 
    "December"
  };

  strcpy(result, months[value-1]);

  // Update result pointer to point to end of string.
  //
  result += strlen(months[value-1]);
}

Lng32 ExpDatetime::getDatetimeFormatLen(Lng32 format, NABoolean to_date,
				       rec_datetime_field startField,
				       rec_datetime_field endField)
{
  switch (format)
    {
    case DATETIME_FORMAT_DEFAULT:   
    case DATETIME_FORMAT_USA:       
    case DATETIME_FORMAT_EUROPEAN:       
      {
	if (to_date)
	  {
            return ExpDatetime::getDatetimeFormatLen(format);
 	  }
	else
	  {
	    Lng32 minReqDstLen = 0;
	    Int32 field;
	    for (field = startField; field <= endField; field++) {
	      switch (field) {
	      case REC_DATE_YEAR:
		minReqDstLen += 5;
		break;
	      case REC_DATE_MONTH:
		minReqDstLen += 3;
		break;
	      case REC_DATE_DAY:
	      case REC_DATE_MINUTE:
		minReqDstLen += 3;
		break;
	      case REC_DATE_HOUR:
		minReqDstLen += 3;
		if (format == DATETIME_FORMAT_USA)
		  minReqDstLen += 3;
		break;
	      case REC_DATE_SECOND:
		minReqDstLen += 3;
		break;
	      default:
		return -1;
	      }
	    }
	    
	    // No trailing delimiter required.
	    //
	    minReqDstLen--;
	    return minReqDstLen;
	  }
      }
    break;

    default:
      return ExpDatetime::getDatetimeFormatLen(format);
    }

  return 0;
}

// convDatetimeToASCII() ============================================
// This method is used to convert the given datetime value to an ASCII
// string in one of three formats (DEFAULT, EUROPEAN, and USA).
//
// This method was added as part of the MP Datetime Compatibility
// project.
// =====================================================================
//
Lng32
ExpDatetime::convDatetimeToASCII(char *srcData,
                                 char *dstData,
                                 Lng32 dstLen,
                                 Int32 format,
				 char *formatStr,
                                 CollHeap *heap,
                                 ComDiagsArea** diagsArea)
{
  // Get the start and end fields of the datetime value.
  //
  rec_datetime_field startField;
  rec_datetime_field endField;
  if (getDatetimeFields(getPrecision(),
                        startField,
                        endField) != 0) {
    return -1;
  }

  // Variable for the Date portion of the datetime value.  We need to
  // store these values since the order in which they appear in the
  // string result, depends on the format.
  //
  short year=0;
  char month=0;
  char day=0;
  
  // Remember the original hour in case we need to output an 'AM' or
  // 'PM'
  //
  char militaryHour = 0;

  char *dstDataPtr = dstData;

  // Calculate the minimum length required to store the string
  // result. The fraction portion of the second field can be left off
  // or only partially present, so do not include it in this
  // calculation.
  //
  Lng32 minReqDstLen = 0;

  minReqDstLen = getDatetimeFormatLen(format, FALSE, startField, endField);
  
  // Make sure we have enough room for at least the minimum.
  //
  if((minReqDstLen <= 0) || (minReqDstLen > dstLen)) {
    ExRaiseSqlError(heap, diagsArea, EXE_STRING_OVERFLOW);
    return -1;
  }

  // Capture the date portion of the datetime value in the
  // corresponding variable.
  //
  Int32 field;
  for (field = startField;
       field <= endField && field <= REC_DATE_DAY;
       field++) {

    switch (field) {
    case REC_DATE_YEAR:
      str_cpy_all((char *) &year, srcData, sizeof(year));
      srcData += sizeof(year);
      break;
    case REC_DATE_MONTH:
      month = *srcData++;
      break;
    case REC_DATE_DAY:
      day = *srcData++;
      break;
    default:
      return -1;

    }
  }

  // Format the Date portion in the proper format.
  //
  switch (format) {
  case DATETIME_FORMAT_DEFAULT:
  case DATETIME_FORMAT_DEFAULT2:
  case DATETIME_FORMAT_USA3:
  case DATETIME_FORMAT_USA4:
  case DATETIME_FORMAT_USA5:
  case DATETIME_FORMAT_USA8:
  case DATETIME_FORMAT_TS1:
  case DATETIME_FORMAT_TS3:
  case DATETIME_FORMAT_TS5:
  case DATETIME_FORMAT_TS11:
    if (year) {
      if (format == DATETIME_FORMAT_USA5)
	convertToAscii(year, dstDataPtr, 2);
      else
	convertToAscii(year, dstDataPtr, 4);
      if (endField > REC_DATE_YEAR) {
	if ((format == DATETIME_FORMAT_DEFAULT) ||
	    (format == DATETIME_FORMAT_DEFAULT2) ||
	    (format == DATETIME_FORMAT_TS3))
	  *dstDataPtr++ = '-';
	else if ((format == DATETIME_FORMAT_USA3) ||
		 (format == DATETIME_FORMAT_USA5) ||
                 (format == DATETIME_FORMAT_TS11))
	  *dstDataPtr++ = '/';
      }
    }
    if (month) {
      convertToAscii(month, dstDataPtr, 2);
      if (endField > REC_DATE_MONTH) {
	if ((format == DATETIME_FORMAT_DEFAULT) ||
	    (format == DATETIME_FORMAT_TS3))
	  *dstDataPtr++ = '-';
	else if ((format == DATETIME_FORMAT_USA3) ||
		 (format == DATETIME_FORMAT_USA5) ||
		 (format == DATETIME_FORMAT_TS11))
	  *dstDataPtr++ = '/';
      }
    }
  if (day) {
      convertToAscii(day, dstDataPtr, 2);
    }
    break;

  case DATETIME_FORMAT_USA:
  case DATETIME_FORMAT_USA2:
  case DATETIME_FORMAT_USA6:
  case DATETIME_FORMAT_USA7:
  case DATETIME_FORMAT_TS6:
  case DATETIME_FORMAT_TS7:
    {
      char delim = (format == DATETIME_FORMAT_USA7 ? '-' 
		    : (format == DATETIME_FORMAT_TS6 ? 0 : '/'));
      
      if (month) {
	convertToAscii(month, dstDataPtr, 2);
	if ((startField < REC_DATE_MONTH || endField > REC_DATE_MONTH) &&
	    (delim != 0)) {
	  *dstDataPtr++ = delim;
	}
      }
      if (day) {
	convertToAscii(day, dstDataPtr, 2);
	if (startField < REC_DATE_MONTH && 
	    (delim != 0)) {
	  *dstDataPtr++ = delim;
	}
      }
      if (year) {
	Int32 numOfYdigits = (format == DATETIME_FORMAT_USA6 ? 2 : 4);
	
	convertToAscii(year, dstDataPtr, numOfYdigits);
      }
    }
    break;

  case DATETIME_FORMAT_EUROPEAN:
  case DATETIME_FORMAT_EUROPEAN2:
  case DATETIME_FORMAT_EUROPEAN3:
  case DATETIME_FORMAT_EUROPEAN4:
  case DATETIME_FORMAT_TS2:
  case DATETIME_FORMAT_TS8:
  case DATETIME_FORMAT_TS10:
    if (day) {
      convertToAscii(day, dstDataPtr, 2);
      if (startField < REC_DATE_DAY) {
	if ((format == DATETIME_FORMAT_EUROPEAN) ||
	    (format == DATETIME_FORMAT_TS2) ||
	    (format == DATETIME_FORMAT_TS10))
	  *dstDataPtr++ = '.';
	else if (format != DATETIME_FORMAT_EUROPEAN4)
	  *dstDataPtr++ = '-';
      }
    }
    if (month) {
      if ((format == DATETIME_FORMAT_EUROPEAN3) ||
	  (format == DATETIME_FORMAT_EUROPEAN4) ||
          (format == DATETIME_FORMAT_TS8))
	convertMonthToStr(month, dstDataPtr, 3);
      else
	convertToAscii(month, dstDataPtr, 2);
      if (startField < REC_DATE_MONTH) {
	if ((format == DATETIME_FORMAT_EUROPEAN) ||
	    (format == DATETIME_FORMAT_TS2) ||
	    (format == DATETIME_FORMAT_TS10))
	  *dstDataPtr++ = '.';
	else if (format != DATETIME_FORMAT_EUROPEAN4)
	  *dstDataPtr++ = '-';
      }
    }
    if (year) {
      convertToAscii(year, dstDataPtr, 4);
    }
    break;

  case DATETIME_FORMAT_TS9:
    {
      Lng32 length = ExpDatetime::getDatetimeFormatMaxLen(DATETIME_FORMAT_TS9);
      memset(dstDataPtr, ' ', length);
      convertMonthToStrLongFormat(month, dstDataPtr, 3);
      *dstDataPtr++ = ' ';
      
      convertToAscii(day, dstDataPtr, 2);
      *dstDataPtr++ = ',';
      *dstDataPtr++ = ' ';
      
      convertToAscii(year, dstDataPtr, 4);
      *dstDataPtr++ = ',';
    }
    break;

  case DATETIME_FORMAT_TS4:
    {
      // do nothing for date part.
    }
  break;

  case DATETIME_FORMAT_EXTRA_HH:
  case DATETIME_FORMAT_EXTRA_HH24:
  case DATETIME_FORMAT_EXTRA_HH12:
    {
      char hour = *srcData++;
      if ( DATETIME_FORMAT_EXTRA_HH12 == format )
        {
          if (hour > 12)
            hour = hour - 12;
        }
      convertToAscii(hour, dstDataPtr, 2);
      return (dstDataPtr - dstData);
    }
    break;

  case DATETIME_FORMAT_EXTRA_MI:
    {
      char minute = *(srcData+1);
      convertToAscii(minute, dstDataPtr, 2);
      return (dstDataPtr - dstData);
    }
    break;

  case DATETIME_FORMAT_EXTRA_SS:
    {
      char second = *(srcData+2);
      convertToAscii(second, dstDataPtr, 2);
      return (dstDataPtr - dstData);
    }
    break;

  case DATETIME_FORMAT_EXTRA_YYYY:
  case DATETIME_FORMAT_EXTRA_YYY:
  case DATETIME_FORMAT_EXTRA_YY:
  case DATETIME_FORMAT_EXTRA_Y:
    {
      UInt32 nw = 4; //DATETIME_FORMAT_EXTRA_YYYY
      if ( DATETIME_FORMAT_EXTRA_YYY == format )
        {
          nw = 3;
          year = year % 1000;
        }
      else if ( DATETIME_FORMAT_EXTRA_YY == format )
        {
          nw = 2;
          year = year % 100;
        }
      else if ( DATETIME_FORMAT_EXTRA_Y == format )
        {
          nw = 1;
          year = year % 10;
        }
      convertToAscii(year, dstDataPtr, nw);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_CC:
    {
      year = (year+99)/100;
      convertToAscii(year, dstDataPtr,2);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_MON:
  case DATETIME_FORMAT_EXTRA_MM:
    {
      if (DATETIME_FORMAT_EXTRA_MM == format)
        convertToAscii(month, dstDataPtr,2);
      else if (DATETIME_FORMAT_EXTRA_MON == format)
        {
          if (0 == month)
            return -1;
          convertMonthToStr(month, dstDataPtr, 3);
        }
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_DY:
  case DATETIME_FORMAT_EXTRA_DAY:
  case DATETIME_FORMAT_EXTRA_D:
    {
      Int64 interval = getTotalDays(year, month, day);
      short dayofweek = (short)(((interval + 1) % 7) + 1);
      if (DATETIME_FORMAT_EXTRA_D == format)
        {
          convertToAscii(dayofweek,dstDataPtr,1);
        }
      else if (DATETIME_FORMAT_EXTRA_DAY == format
               || DATETIME_FORMAT_EXTRA_DY == format)
        {
          if (0 == day)
            return -1;
          //SUNDAY or SUN
          NABoolean bAbbr = (DATETIME_FORMAT_EXTRA_DY == format ? TRUE:FALSE);
          UInt32 width = 9;
          if (bAbbr)
            width = 3;
          convertDayOfWeekToStr(dayofweek, dstDataPtr, bAbbr, width);
        }
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_DD:
    {
      convertToAscii(day, dstDataPtr, 2);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_DDD:
    {
      int dayofyear = 0;
      if( day )
        dayofyear = Date2Julian(year,month,day)-Date2Julian(year,1,1)+1;
      convertToAscii(dayofyear,dstDataPtr,3);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_W:
    {
      int weekofmonth = 0;
      if (day)
        weekofmonth = (day-1)/7+1;
      convertToAscii(weekofmonth,dstDataPtr,1);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_WW:
    {
      //same with built-in function week
      int weekofmonth = 0;
      if ( day )
        {
          Int64 interval = getTotalDays(year, 1, 1);
          int dayofweek = (int)(((interval + 1) % 7) + 1);
          int dayofyear = Date2Julian(year,month,day)-Date2Julian(year,1,1)+1;
          weekofmonth = (dayofyear-1+dayofweek-1)/7+1;
        }
      convertToAscii(weekofmonth,dstDataPtr,2);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_J:
    {
      int julianday = Date2Julian(year,month,day);
      convertToAscii(julianday,dstDataPtr,7);
      return (dstDataPtr - dstData);
    }
    break;
  case DATETIME_FORMAT_EXTRA_Q:
    {
      if (month)
        {
          month = (month-1)/3+1;
        }
      convertToAscii(month,dstDataPtr,1);
      return (dstDataPtr - dstData);
    }
    break;

  default:
    return -1;
  }


  // Add a delimiter between the date and time portion if required.
  //
  if (field > startField && field <= endField)
    {
      switch (format) {
      case DATETIME_FORMAT_TS1:
	{
	}
      break;

      case DATETIME_FORMAT_TS2:
      case DATETIME_FORMAT_TS5:
	{
	  *dstDataPtr++ = ':';
	}
      break;
	
      default:
	{
	  *dstDataPtr++ = ' ';
	}
      break;
      }
    }

  // Format the Time portion in the proper format.
  //
  for (; field <= endField; field++) {
    switch (field) {
    case REC_DATE_HOUR: {
      char hour = militaryHour = *srcData++;

      // USA format uses AM|PM format.
      //
      if ((format == DATETIME_FORMAT_USA) ||
          (format == DATETIME_FORMAT_TS7)) {
        if (hour < 1)
          hour += 12;
        else if (hour > 12)
          hour -= 12;
      }
      convertToAscii(hour, dstDataPtr, 2);
      if (endField > REC_DATE_HOUR) {
	if ((format == DATETIME_FORMAT_EUROPEAN) ||
            (format == DATETIME_FORMAT_TS10))
	  *dstDataPtr++ = '.';
	else if (format != DATETIME_FORMAT_TS1)
	  *dstDataPtr++ = ':';
      }
      break;
    }
    case REC_DATE_MINUTE: {
      char minute = *srcData++;
      convertToAscii(minute, dstDataPtr, 2);
      if (endField > REC_DATE_MINUTE) {
        if (format == DATETIME_FORMAT_TS9)
          return (dstDataPtr - dstData);
        else if ((format == DATETIME_FORMAT_EUROPEAN) ||
            (format == DATETIME_FORMAT_TS10))
          *dstDataPtr++ = '.';
        else if (format != DATETIME_FORMAT_TS1)
          *dstDataPtr++ = ':';
       }
      break;
    }
    case REC_DATE_SECOND: {
      char second = *srcData++;
      convertToAscii(second, dstDataPtr, 2);

      // If there is a fraction portion of the second field and there
      // is room in the destination string, format as much of the
      // fraction as possible.
      //
      Int32 fractionPrecision = getScale();
      Lng32 fraction;
      if (fractionPrecision > 0) {

        // dstPrecision is the available space in the destination
        // string (minus 1 for delimiter)
        //
        Lng32 dstPrecision = dstLen - minReqDstLen - 1;

        // Get the fraction value.
        //
        str_cpy_all((char *) &fraction, srcData, sizeof(fraction));

        // If it won't all fit, scale it down so it will.
        //
        if(dstPrecision < fractionPrecision) {
          fraction = scaleFraction(fractionPrecision, fraction, dstPrecision);
          fractionPrecision = dstPrecision;
        }
      }

      // If we still have a fraction precision left, format it into
      // the result string.
      //
      if(fractionPrecision > 0) {
	if (format == DATETIME_FORMAT_USA2)
	  {
	    *dstDataPtr++ = ':';
	    convertToAscii(fraction, dstDataPtr, 2);
	  }
	else
	  {
	    *dstDataPtr++ = '.';
	    convertToAscii(fraction, dstDataPtr, fractionPrecision);
	  }
      }
      break;
    }
    default:
      return -1;
    }
  }

  // If the format is USA and there is an HOUR field, add AM or PM.
  //
  if (((format == DATETIME_FORMAT_USA) ||
       (format == DATETIME_FORMAT_TS7)) &&
      startField <= REC_DATE_HOUR &&
      endField >= REC_DATE_HOUR) {
    if (militaryHour < 12) {
      str_cpy_all(dstDataPtr, " AM", 3);
    } else {
      str_cpy_all(dstDataPtr, " PM", 3);
    }

    dstDataPtr += 3;
  }

  // if format includes time field but source is a DATE datatype, extend
  // the returned string with zeroes
  if (isTimestampFormat(format))
    {
      if (format == DATETIME_FORMAT_TS1)
        {
        }
      else if ((format == DATETIME_FORMAT_TS2) ||
               (format == DATETIME_FORMAT_TS5))
        {
          *dstDataPtr = ':';
          dstDataPtr++;
        }
      else
        {
          *dstDataPtr = ' ';
          dstDataPtr++;
        }
      
      if (format == DATETIME_FORMAT_TS1)
        {
          str_cpy_all(dstDataPtr, "000000", 6);
          dstDataPtr += 6;
        }
      else if (format == DATETIME_FORMAT_EUROPEAN)
        {
          str_cpy_all(dstDataPtr, "00.00.00", 8);
          dstDataPtr += 8;
        }
      else
        {
          str_cpy_all(dstDataPtr, "00:00:00", 8);
          dstDataPtr += 8;
        }
    }
      
  // Return the actual number of bytes formatted.
  //
  return dstDataPtr - dstData;
}

// convNumericTimeToASCII() ============================================
// This method is used to convert the given numeric time value to an ASCII
// string in the provided format. It is based on special1 behavior.
//
// Input numeric value is an Int64.
// 
// DATETIME_FORMAT_TIME1:  99:99:99:99
//                         an 8-digit number is broken up into 2 digit
//                         parts separated by : (colon)
//                         Ex, 12345 will be returned as 00:01:23:45
//                         If negative number, sign is ignored.
// 
// DATETIME_FORMAT_TIME2:  -99:99:99:99
//                         an 8-digit number is broken up into 2 digit
//                         parts separated by : (colon)
//                         Ex, -12345 will be returned as -00:01:23:45
// 
// If value is less than -long max or greater than + long max, the
// result will be "**********".
//
// DATETIME_FORMAT_TIME_STR: format is in formatStr. Not yet supported.
// 
// =====================================================================
//
Lng32
ExpDatetime::convNumericTimeToASCII(char *srcData,
				    char *dstData,
				    Lng32 dstLen,
				    Int32 format,
				    char *formatStr,
				    CollHeap *heap,
				    ComDiagsArea** diagsArea)
{
  if ((format != DATETIME_FORMAT_NUM1) &&
      (format != DATETIME_FORMAT_NUM2))
    return -1;

  if ((format == DATETIME_FORMAT_NUM1) &&
      (dstLen < 11))
    return -1;

  if ((format == DATETIME_FORMAT_NUM2) &&
      (dstLen < 12))
    return -1;

  Int64 temp = *(Int64*)srcData;
  NABoolean negative = FALSE;
  if (temp < 0)
    {
      // cannot convert negative number with NUM1 format
      if (format == DATETIME_FORMAT_NUM1)
        {
          raiseDateConvErrorWithSrcDataNumeric(diagsArea,temp,heap);
          return -1;
        }

      temp = -temp;

     if (format == DATETIME_FORMAT_NUM2)
       {
	 negative = TRUE;
       }
    }

  NABoolean overflow = FALSE;
  if ((temp > INT_MAX) ||
      (temp < -INT_MAX))
    {
      overflow = TRUE;
    }
  
  if (overflow)
    {
      str_pad(dstData, dstLen, '*');
    }
  else
    {
      Lng32 part1, part2, part3, part4;
      part4 = (Lng32)(temp - (temp/100)*100);
      temp = temp/100;
      part3 = (Lng32)(temp - (temp/100)*100);
      temp = temp/100;
      part2 = (Lng32)(temp - (temp/100)*100);
      temp = temp/100;
      part1 = (Lng32)(temp - (temp/100)*100);
      temp = temp/100;
  
      // if more digits left in input, error out.
      if (temp > 0)
        {
          raiseDateConvErrorWithSrcDataNumeric(diagsArea,temp,heap);
          return -1;
        }

      if (format == DATETIME_FORMAT_NUM2)
	{
	  if (negative)
	    str_sprintf(dstData, "-%02d:%02d:%02d:%02d", part1, part2, part3, part4);
	  else
	    str_sprintf(dstData, " %02d:%02d:%02d:%02d", part1, part2, part3, part4);
	}
      else
	str_sprintf(dstData, "%02d:%02d:%02d:%02d", part1, part2, part3, part4);
    }

  // number of bytes formatted.
  return 11;
}

static const UInt32 maxFieldLen[]   = {    4,  2,  2,  2,  2,  2, 6 };

short ExpDatetime::getDisplaySize(Lng32 datetimeCode,
                  short fractionPrecision)
{
  rec_datetime_field startField, endField;

  getDatetimeFields(datetimeCode, startField, endField);
  Int32 field = startField - REC_DATE_YEAR;
  size_t displayLength = maxFieldLen[field];
  while (field < (endField - REC_DATE_YEAR))
    displayLength += 1 /* for separator */ + maxFieldLen[++field];
  if (fractionPrecision > 0)
  {
    if (startField == REC_DATE_FRACTION_MP)
    {
      displayLength = fractionPrecision;
    }
    else
    {
     displayLength += 1 /* for separator */ + fractionPrecision;
    }
  }
  return displayLength;
}

short ExpDatetime::convAsciiDatetimeToASCII(char *srcData,
                        Lng32 srcPrecision,
                        Lng32 srcScale,
                        Lng32 srcLen,
                        char *dstData,
                        Lng32 dstLen,
                        Int32 format,
                        CollHeap *heap,
                        ComDiagsArea** diagsArea)
{
  short rc = 0;

  SimpleType tempST(REC_DATETIME, 12, 
            srcScale, srcPrecision,
            ExpTupleDesc::SQLMX_FORMAT,
            0, 0, 0, 0, Attributes::NO_DEFAULT, 0);

  char tempDTBuf[12]; // max length for an internal datetime value.

  ExpDatetime &tempDT = (ExpDatetime&)tempST;
  rc = 
    tempDT.convAsciiToDatetime
    (srcData, srcLen, tempDTBuf, 12, DATETIME_FORMAT_NONE, heap, diagsArea, 0);
  if (rc)
    return rc;

  rc =
    tempDT.convDatetimeToASCII(tempDTBuf, dstData, dstLen, format, NULL,
                   heap, diagsArea);
  if (rc < 0)
    return rc;

  return 0;
}


// getFieldName() ====================================================
// This static helper function of the ExpDatetime class returns the
// string (char *) value of the given datetime field.  For example, if
// given the value REC_DATE_MONTH, this method returns the string
// "MONTH".  This function is used by getDefaultStringValue (see above).
//
// This function was added as part of the MP Datetime Compatibility
// project.
// ===================================================================
//
static
const char*
getFieldName(rec_datetime_field field)
{
  switch (field) {
  case REC_DATE_YEAR:
    return "YEAR";
  case REC_DATE_MONTH:
    return "MONTH";
  case REC_DATE_DAY:
    return "DAY";
  case REC_DATE_HOUR:
    return "HOUR";
  case REC_DATE_MINUTE:
    return "MINUTE";
  case REC_DATE_SECOND:
    return "SECOND";
  default:
    return NULL;
  }
}

// getDefaultStringValue() ===========================================
// This method constructs a string (char *) value representing the
// default value for a datetime type. This method is used to construct
// values for columns that have been added to a table through an ALTER
// TABLE statement.  When a column is added to a table, the existing
// records are not immediately updated.  Rather, when these records
// are selected, a default value for the column is constructed.  As
// described in the SQL/MP reference manual (ALTER TABLE, p..A-37) the
// default value used for all datetime values is based on the
// TimeStamp: '0001-01-01:12:00:00.00000'.  The default value is the
// appropriate range of fields taken from the default TimeStamp.  For
// the non-standard datetime types, the default value must also
// include the datetime qualifier.  For example the default value for
// a non-standard datetime of MONTH TO DAY would be: "DATETIME '01-01'
// MONTH TO DAY".
//
// This method is only called from the generator
// (ExpGenerator::addDefaultValue() in generator/GenExpGenerator.cpp)
//
// This method was added as part of the MP Datetime Compatibility
// project.
// ===================================================================
//
char *
ExpDatetime::getDefaultStringValue(CollHeap *heap)
{

  rec_datetime_field startField;
  rec_datetime_field endField;
  char *ptr;
  Int32 len;

  // Get the start and end fields for this datetime type.
  //
  if(getDatetimeFields(getPrecision(),
                       startField,
                       endField) != 0) {
    return NULL;
  }

  char buffer[MAX_DATETIME_STRING_LEN];
  ptr = buffer;

  // Construct the type name
  //

  const char *dateKW = "DATE '";
  const char *timeKW = "TIME '";
  const char *timeStampKW = "TIMESTAMP '";
  const char *datetimeKW = "DATETIME '";

  switch (getPrecision()) {
  case REC_DTCODE_DATE:
    len = str_len(dateKW);
    str_cpy_all(ptr,dateKW, len);
    break;

  case REC_DTCODE_TIME:
    len = str_len(timeKW);
    str_cpy_all(ptr,timeKW, len);
    break;

  case REC_DTCODE_TIMESTAMP:
    len = str_len(timeStampKW);
    str_cpy_all(ptr,timeStampKW, len);
    break;

  default:
    len = str_len(datetimeKW);
    str_cpy_all(ptr,datetimeKW, len);
    break;
  }

  static const char * const defValues[] = {"", "0001", "01", "01", "12", "00", "00"};

  static const char delims[6] = {'x','-','-',':',':',':'};
    
  // Construct the default value string, based on the start and end
  // fields.
  //
  for (Int32 field = startField; field <= endField; field++) {
    Int32 flen = str_len(defValues[field]);
    str_cpy_all(ptr+len, defValues[field], flen);
    len += flen;
    if(field != endField) {
      ptr[len++] = delims[field];
    }
  }

  ptr[len++] = '\'';

  // Construct the datetime qualifier if needed.
  //
  if(getPrecision() > REC_DTCODE_TIMESTAMP) {
    ptr[len++] = ' ';
    
    Int32 flen = str_len(getFieldName(startField));
    str_cpy_all(ptr+len, getFieldName(startField), flen);
    len += flen;
    if(startField != endField) {
      flen = str_len(" TO ");
      str_cpy_all(ptr+len, " TO ", flen);
      len += flen;
      
      flen = str_len(getFieldName(endField));
      str_cpy_all(ptr+len, getFieldName(endField), flen);
      len += flen;
    }
  }

  ptr[len++] = ';';
  ptr[len++] = '\0';

  // Allocate space for the default string (including NULL char) and
  // copy from local buffer
  //
  ptr = new (heap) char[str_len(buffer) + 1];
  str_cpy_all(ptr, buffer, str_len(buffer) + 1);

  return ptr;
}