/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
#ifndef DATETIMETYPE_H
#define DATETIMETYPE_H
/* -*-C++-*-
**************************************************************************
*
* File:         DatetimeType.h
* Description:  Datetime Type
* Created:      2/1/96
* Language:     C++
*
*
**************************************************************************
*/

// -----------------------------------------------------------------------

#include "NAType.h"
#include "DTICommonType.h"
#include "IntervalType.h"
#include "SQLCLIdev.h"

// -----------------------------------------------------------------------
// contents of this file
// -----------------------------------------------------------------------
class DatetimeType;
class SQLDate;
class SQLTime;
class SQLTimestamp;
class DatetimeValue;

extern NAString LiteralDate;
extern NAString LiteralTime;
extern NAString LiteralTimestamp;
extern NAString LiteralDateTime;
extern NAString DEFAULT_DATE_DISPLAY_FORMAT;

// static NAString DEFAULT_TIME_DISPLAY_FORMAT("HH:MM:SS");
// static NAString DEFAULT_TIMESTAMP_DISPLAY_FORMAT("YYYY-MM-DD HH:MM:SS.FFFFF");

// ***********************************************************************
//
//  DatetimeType : The datetime data type
//
// ***********************************************************************
class DatetimeType : public DatetimeIntervalCommonType
{
public:

  enum { DEFAULT_FRACTION_PRECISION = 0 };      // See ANSI 6.1 SR 25: zero
  enum { MAX_FRACTION_PRECISION_USEC = 6 }; // max microseconds fract precision
  enum { MAX_FRACTION_PRECISION = 9 };  // See ANSI 6.1 SR 26: max is at least 6.
                                        // Changed to 9 to support nano secs 
                                        // fractional precision

  enum Subtype { SUBTYPE_ILLEGAL,
                 SUBTYPE_SQLDate, 
                 SUBTYPE_SQLTime, 
                 SUBTYPE_SQLTimestamp, 
                 SUBTYPE_SQLMPDatetime };

  static Subtype validate(rec_datetime_field startField,
			  rec_datetime_field endField,
			  UInt32 fractionPrecision);

  static DatetimeType* constructSubtype(NABoolean allowSQLnull,
					rec_datetime_field startField,
			    		rec_datetime_field endField,
					UInt32 fractionPrecision,
					NAMemory* h=0);

  static Lng32 getStorageSize(rec_datetime_field startField,
			     rec_datetime_field endField,
			     UInt32 fractionPrecision = 0);

  // Used by DatetimeValue
  static Int32 getExtendedEndField(rec_datetime_field endField,
				 UInt32 fractionPrecision);

  void datetimeToLong(void *bufPtr,
                      ULng32 values[]) const;
  

  Lng32 getRecDateTimeCode() const  // does this need to be virtual ??
   {
    return getRecDateTimeCode (getStartField(), getEndField());
   }

  Lng32 getRecDateTimeCode(rec_datetime_field startField, rec_datetime_field endField) const;

 NABoolean checkValid(ComDiagsArea *diags)
  {
    if ((getFractionPrecision()) > MAX_FRACTION_PRECISION)
      {
	// ## Possible future work:
	// We COULD add an optional Diags parameter onto our validate() method
	// and call it now; and it would emit more precise diagnostics
	// for why the type is invalid.  It is a complicated type after all!
	// The more precise diags could explain valid ranges of values, etc.
	//
	// Here we just emit "3134 Invalid TimeStamp $int0."
	*diags << DgSqlCode(-3134) << DgInt0(getFractionPrecision());
	return FALSE;
      }
    return TRUE;
  }

  static NABoolean leapYear(ULng32 year) 
  {
    return ((year % 4 == 0) &&
            ((year % 100 != 0) ||
             (year % 400 == 0)));
  }

  static Lng32 gregorianDays(const ULng32 values[]);
  
  static Lng32 secondsInTime(const ULng32 values[]);
  
  // returns the juliantimestamp value (64 bit integer) based on the
  // input sql timestamp value.
  // Input format is the same as what is created in 'class DatetimeValue'
  // Input fractionPrec is the fractional seconds precision, needed to scale
  //                    the fractional seconds part of the timestamp to a
  //                    number of microseconds.
  static Int64 julianTimestampValue(const char * value, const short valueLen,
                                    UInt32 fractionPrec);

  // ---------------------------------------------------------------------
  // Constructors
  // ---------------------------------------------------------------------
  DatetimeType (NAMemory *h, const NAString & adtName,
                NABoolean allowSQLnull,
                rec_datetime_field startField,
                rec_datetime_field endField,
                UInt32 fractionPrecision = 0);

  // copy ctor
  DatetimeType (const DatetimeType & rhs, NAMemory * h=0) :
       DatetimeIntervalCommonType (rhs, h)
       , displayFormat_(rhs.displayFormat_, h)
  {}

  DatetimeType & operator= (const DatetimeType &) ; // not written 

  // ---------------------------------------------------------------------
  // Accessor functions
  // ---------------------------------------------------------------------
  Subtype getSubtype() const
  {
    return (validate(getStartField(), getEndField(), getFractionPrecision()));
  }

  virtual Lng32 getDisplayLength() const;

  virtual Lng32 getDisplayLength(Lng32 datatype,
 		        Lng32 length,
		        Lng32 precision,
		        Lng32 scale,
                        Lng32 heading_len) const;

  const NAString &getDisplayFormat() const { return displayFormat_; }

  // ---------------------------------------------------------------------
  // Mutator functions
  // ---------------------------------------------------------------------

  void setDisplayFormat(const char* format) { displayFormat_ = format; }
  void setDisplayFormat(const NAString& format) { displayFormat_ = format; }

  // ---------------------------------------------------------------------
  // Virtual functions that are given an implementation for this class.
  // ---------------------------------------------------------------------
  virtual void print(FILE* ofd = stdout, const char* indent = DEFAULT_INDENT) /*const*/;

  virtual short getFSDatatype() const;

  virtual NAString getSimpleTypeName() const;

  virtual NAString getTypeSQLname(NABoolean terse = FALSE) const;

  virtual const NAString getDatetimeQualifierAsString(NABoolean includeFractionalPrec) const;

  virtual NABoolean isCompatible(const NAType& other, UInt32 * flags = NULL) const;

#if defined( NA_LITTLE_ENDIAN )
  virtual NABoolean isEncodingNeeded() const;
#endif
  
  virtual NABoolean operator==(const NAType& other) const;

  // ---------------------------------------------------------------------
  // A virtual function for synthesizing the type of a binary operator.
  // ---------------------------------------------------------------------
  virtual const NAType* synthesizeType(enum NATypeSynthRuleEnum synthRule,
                                       const NAType& operand1,
                                       const NAType& operand2,
				       NAMemory* h,
				       UInt32 *flags = NULL) const;

  // ---------------------------------------------------------------------
  // A virtual function for synthesizing the type of a ternary operator.
  // ---------------------------------------------------------------------
  virtual const NAType* synthesizeTernary(enum NATypeSynthRuleEnum synthRule,
                                          const NAType& operand1,
                                          const NAType& operand2,
                                          const NAType& operand3,
					  NAMemory* h=0) const;

  virtual NAType::SynthesisPrecedence getSynthesisPrecedence() const;
  
  // ---------------------------------------------------------------------
  // Methods that return the binary form of the minimum and the maximum
  // representable values.
  // ---------------------------------------------------------------------
  virtual void minRepresentableValue(void* bufPtr, Lng32* bufLen, 
			     NAString** stringLiteral = NULL,
                                     NAMemory* h=0) const;
  virtual void maxRepresentableValue(void* bufPtr, Lng32* bufLen, 
			     NAString** stringLiteral = NULL,
                                     NAMemory* h=0) const;

  virtual NABoolean createSQLLiteral(const char * buf,       // in
                                     NAString *&sqlLiteral,  // out
                                     NABoolean &isNull,      // out
                                     CollHeap *h) const;     // in/out

  // ---------------------------------------------------------------------
  // Method that returns the encoded form for a given value to be
  // used by the optimizer for estimations.
  // ---------------------------------------------------------------------
  virtual double encode (void* bufPtr) const;

  // ---------------------------------------------------------------------
  // Leave this, inherited from NAType as a pure virtual function, 
  // *unimplemented*, so that DatetimeType, just like NAType, 
  // remains an abstract class:  only SQLDate, SQLTime, SQLTimestamp
  // can be instantiated.
  //
  //	virtual NAType *newCopy() const { return new DatetimeType(*this); }
  // ---------------------------------------------------------------------

  // ---------------------------------------------------------------------
  // Generic way for finding if a DatetimeType contains a particuar Datetime 
  // field.
  // ---------------------------------------------------------------------
virtual NABoolean containsField(rec_datetime_field theField) const;

  // ---------------------------------------------------------------------
  // Generic way for finding if two DatetimeTypes contain any common Datetime 
  // fields.
  // ---------------------------------------------------------------------

virtual NABoolean fieldsOverlap(const DatetimeType& other) const;

private:

  // Auxiliary methods
  void getRepresentableValue(const char* inValueString,
			     void* bufPtr, Lng32* bufLen,
			     NAString** stringLiteral,
			     NAMemory* h=0) const;

  NAString displayFormat_;
  
}; // class DatetimeType

// ***********************************************************************
//
//  SQLDate : SQL DATE
//
// ***********************************************************************
class SQLDate : public DatetimeType
{
public:
  // ---------------------------------------------------------------------
  // Constructor functions 
  // ---------------------------------------------------------------------
  SQLDate(NAMemory *h, NABoolean allowSQLnull = TRUE)
       : DatetimeType (h, LiteralDate,
                       allowSQLnull,
                       REC_DATE_YEAR,
                       REC_DATE_DAY,
                       0)
  {}

  // copy ctor
  SQLDate (const SQLDate & rhs, NAMemory * h=0)
       : DatetimeType (rhs, h) 
  {}
  
  // ---------------------------------------------------------------------
  // A virtual function to return a copy of the type.
  // ---------------------------------------------------------------------
  virtual NAType *newCopy(NAMemory* h=0) const 	
    { return new (h) SQLDate(*this, h); }

  // ---------------------------------------------------------------------
  // Method that returns the encoded form for a given value to be
  // used by the optimizer for estimations.
  // ---------------------------------------------------------------------
  virtual double encode (void* bufPtr) const;

  // Method that returns a SQL Date literal representing 
  // the value (as #seconds) in v.
  NAString* convertToString(double v, NAMemory* h) const;
   
  virtual Lng32 getPrecision() const { return SQLDTCODE_DATE; }

  // get min and max value 
  virtual double getMinValue() const; // the encode for '0001-01-01'
  virtual double getMaxValue() const; // the encode for '9999-12-31'

protected:
  double encodeSqlLiteral(char* literal) const;

private:
  
}; // class SQLDate

// ***********************************************************************
//
//  SQLTime : SQL TIME
//
// ***********************************************************************
class SQLTime : public DatetimeType
{
public:

  // ---------------------------------------------------------------------
  // Constructor functions
  // ---------------------------------------------------------------------
  SQLTime(NAMemory *h, NABoolean allowSQLnull = TRUE, 
	  UInt32 fractionPrecision = DEFAULT_FRACTION_PRECISION)
       : DatetimeType (h, LiteralTime,
                       allowSQLnull,
                       REC_DATE_HOUR,
                       REC_DATE_SECOND,
                       fractionPrecision)
  {}

  // copy ctor
  SQLTime (const SQLTime & rhs, NAMemory * h=0)
       : DatetimeType (rhs, h) 
  {}

  // ---------------------------------------------------------------------
  // A virtual function to return a copy of the type.
  // ---------------------------------------------------------------------
  virtual NAType *newCopy(NAMemory* h=0) const 	
    { return new (h) SQLTime(*this, h); }

  // ---------------------------------------------------------------------
  // Method that returns the encoded form for a given value to be
  // used by the optimizer for estimations.
  // ---------------------------------------------------------------------
  virtual double encode (void* bufPtr) const;

  // Method that returns a SQL Time literal representing 
  // the value (as #seconds with fractions) in v.
  NAString* convertToString(double v, NAMemory* h) const;

   
  virtual Lng32 getPrecision() const { return SQLDTCODE_TIME; }

  virtual Lng32 getScale() const { return getFractionPrecision(); }

  // get min and max value 
  virtual double getMinValue()  const; // the encode for '00:00:00'
  virtual double getMaxValue()  const; // the encode for '23:59:59.<x>'
                                       // where <x> is 99...9 with 
                                       // the number of digits '9'
                                       // specified by the fraction precision.

protected:
  double encodeSqlLiteral(char* literal) const;

private:
  
}; // class SQLTime

// ***********************************************************************
//
//  SQLTimestamp : SQL TIMESTAMP
//
// ***********************************************************************
class SQLTimestamp : public DatetimeType
{
public:

  enum { DEFAULT_FRACTION_PRECISION = 6 };	// See ANSI 6.1 SR 25: six

  // ---------------------------------------------------------------------
  // Constructor functions
  // ---------------------------------------------------------------------

  SQLTimestamp(NAMemory *h, NABoolean allowSQLnull = TRUE, 
               UInt32 fractionPrecision = DEFAULT_FRACTION_PRECISION)
       : DatetimeType (h, LiteralTimestamp,
                       allowSQLnull,
                       REC_DATE_YEAR,
                       REC_DATE_SECOND,
                       fractionPrecision)
  {}

  // copy ctor
  SQLTimestamp (const SQLTimestamp & rhs, NAMemory * h=0) :
       DatetimeType (rhs, h)
  {}

  SQLTimestamp & operator= (const SQLTimestamp &) ; // not written

  // ---------------------------------------------------------------------
  // A virtual function to return a copy of the type.
  // ---------------------------------------------------------------------
  virtual NAType *newCopy(NAMemory* h=0) const 	
    { return new (h) SQLTimestamp(*this, h); }

  // ---------------------------------------------------------------------
  // Method that returns the encoded form for a given value to be
  // used by the optimizer for estimations.
  // ---------------------------------------------------------------------
  virtual double encode (void* bufPtr) const;

  // Method that returns a SQL timestamp literal representing 
  // the value in v.
  NAString* convertToString(double v, NAMemory* h) const;

   virtual Lng32 getPrecision() const { return SQLDTCODE_TIMESTAMP; }

   virtual Lng32 getScale() const { return getFractionPrecision(); }
 
  // get the min value, the encode for '0001-01-01 00:00:00'
  virtual double getMinValue()  const; 

  // get the max value, the encode for '9999-12-31 23:59:59.<x>',
  // where <x> is 99...9 with the number of digits '9' specified
  // by fraction precision
  virtual double getMaxValue()  const; 

protected:
  double encodeSqlLiteral(char* literal) const;

private:
  
}; // class SQLTimestamp

// ***********************************************************************
//
//  SQLMPDatetime : A Datetype for non-ANSI SQL/MP Datetimes
//
// ***********************************************************************
class SQLMPDatetime : public DatetimeType
{
public:

    SQLMPDatetime(NAMemory *h, rec_datetime_field startField,
                  rec_datetime_field endField,
                  NABoolean allowSQLnull = TRUE, 
                  UInt32 fractionPrecision = DEFAULT_FRACTION_PRECISION)
  : DatetimeType (h, LiteralDateTime,
                  allowSQLnull,
                  startField,
                  endField,
                  ((endField >= REC_DATE_SECOND) ?
                     fractionPrecision : 
                                                  0))
  {}

        SQLMPDatetime (const SQLMPDatetime & rhs, NAMemory * h=0)
        : DatetimeType (rhs, h)
        {}

        virtual NAType *newCopy(NAMemory* h=0) const  
        { return new (h) SQLMPDatetime(*this, h); }

        virtual double encode (void* bufPtr) const;
 
        virtual Lng32 getPrecision() const { return SQLDTCODE_MPDATETIME; } 

        virtual Lng32 getScale() const { return getFractionPrecision(); }

        virtual NABoolean isCompatible(const NAType& other, UInt32 * flags = NULL) const;
  
        virtual const NAType* synthesizeType(enum NATypeSynthRuleEnum synthRule,     // in common\DateTime.cpp
                                            const NAType& operand1,
                                            const NAType& operand2,
                                            NAMemory* h,
                                            UInt32 *flags = NULL
                                            ) const;
        virtual NABoolean isSupportedType() const;

private:                                          
};
 
// ***********************************************************************
//
//  DatetimeValue : A datetime value
//
// ***********************************************************************
class DatetimeValue
{
public:

  // ---------------------------------------------------------------------
  // Datetime fields.
  // Note that DatetimeField::YEAR == 0, 
  // while rec_datetime_field::REC_DATE_YEAR == 1, and so forth.
  //
  // These are used to index some static arrays in the .C implementation.
  // ---------------------------------------------------------------------
  enum DatetimeField { YEAR = 0, MONTH, DAY, HOUR, MINUTE, SECOND, FRACTION };

  enum { N_DATETIME_FIELDS = FRACTION + 1 };

  // ---------------------------------------------------------------------
  // Constructor functions 
  // ---------------------------------------------------------------------
  DatetimeValue (const char* strValue,
                 rec_datetime_field startField,
                 rec_datetime_field endField,
                 UInt32& fractionPrecision /* OUT */,
                 NABoolean useOldConstructor);

  DatetimeValue (const char* value,
                 Lng32 storageSize);

  void oldConstructor(const char* strValue,
                      rec_datetime_field startField,
                      rec_datetime_field endField,
                      UInt32& fractionPrecision /* OUT */);

  // ---------------------------------------------------------------------
  // Destructor functions 
  // ---------------------------------------------------------------------
  ~DatetimeValue()
  {
    delete [] value_;
  }

  // ---------------------------------------------------------------------
  // Set the value.
  // ---------------------------------------------------------------------
  void setValue(rec_datetime_field startField,
                rec_datetime_field endField,
		UInt32 fractionPrecision,
                const ULng32 values[]);

  // ---------------------------------------------------------------------
  // Accessor functions
  // ---------------------------------------------------------------------
  const unsigned char* getValue() const	{ return value_; }

  unsigned short getValueLen() const 	{ return valueLen_; }

  NABoolean isValid() const 		{ return value_ != NULL; }

  NAString getValueAsString(const DatetimeType& dt) const;

  void print(const DatetimeType& dt, 
	     FILE* ofd = stdout, const char* indent = DEFAULT_INDENT) const;

  // ---------------------------------------------------------------------
  // Static function to get the datetime fields from a Julian timestamp into
  // an array suitable for input to setValue().
  // ---------------------------------------------------------------------
  static void decodeTimestamp(Int64 julianTimestamp,
                              UInt32 fracSec,
                              UInt32* dtvFields);

private:
  
  // ---------------------------------------------------------------------
  // Datetime formats.
  // ---------------------------------------------------------------------
  enum DatetimeFormat {
    FORMAT_DEFAULT,
    FORMAT_USA,
    FORMAT_EUROPEAN,
    FORMAT_ANY
  };

  // ---------------------------------------------------------------------
  // Scan the date.
  // ---------------------------------------------------------------------
  NABoolean scanDate(const char* &strValue,
                     DatetimeFormat &format,
                     ULng32 values[]) const;

  // ---------------------------------------------------------------------
  // Scan the given character.
  // ---------------------------------------------------------------------
  NABoolean scanChar(const char* &strValue, char c) const
  {
    if (*strValue == c) {
      strValue++;
      return TRUE;
    }
    return FALSE;
  }

  // ---------------------------------------------------------------------
  // Scan the time.
  // ---------------------------------------------------------------------
  NABoolean scanTime(const char* &strValue,
                     DatetimeFormat format,
                     ULng32 values[],
                     UInt32 &fractionPrecision) const;

  // ---------------------------------------------------------------------
  // Scan the given field.
  // ---------------------------------------------------------------------
  NABoolean scanField(const char* &strValue,
                      DatetimeField field,
                      ULng32 values[]) const;

  // ---------------------------------------------------------------------
  // Determine if the type contains the indicated field.
  // ---------------------------------------------------------------------
  NABoolean containsField(DatetimeField theField, 
                          rec_datetime_field startField, 
                          rec_datetime_field endField) const
   {
    if (theField+1 >= startField && theField+1 <= endField)
     {
      return TRUE;
     }
    else
     {
      return FALSE;
     } 
   }

  // ---------------------------------------------------------------------
  // Validate the date.
  // ---------------------------------------------------------------------
  NABoolean validateDate(const ULng32 values[]) const;

  // ---------------------------------------------------------------------
  // Datetime value.
  // ---------------------------------------------------------------------
  unsigned char* value_;

  // ---------------------------------------------------------------------
  // Length of value in bytes.
  // ---------------------------------------------------------------------
  unsigned short valueLen_;

  rec_datetime_field startField_;
  rec_datetime_field endField_;


}; // class DatetimeValue

#endif /* DATETIMETYPE_H */