getString()
{
/*
** Do conversion to check for valid format.
*/
return(SqlDates.formatDate(get(null), false));
} // getString
getDate(TimeZone tz)
{
String str = getString().Trim();
return((tz == null) ? SqlDates.parseDate(str, false)
: SqlDates.parseDate(str, tz));
} // getDate
getTime(TimeZone tz)
{
/*
** Strip date component by re-formatting as time value.
*/
return(SqlDates.parseTime(SqlDates.formatTime(get(tz), false), false));
} // getTime
getTimestamp(TimeZone tz)
{
String str = getString().Trim();
return((tz == null) ? SqlDates.parseTimestamp(str, false)
: SqlDates.parseTimestamp(str, tz));
}
getTime(TimeZone tz)
{
/*
** Ingres dates are overloaded with 'empty' date,
** date only, timestamp and interval values. The
** first three types are handled explicitly below.
** Intervals will either cause an exception while
** attempting to parse the value or as the default
** action for an unrecognized format.
*/
try
{
if (value.Length == 0 || // Empty date
value.Length == SqlDates.D_FMT.Length) // Date only
{
/*
** There is no time component, so create a time EPOCH value.
** If no timezone is provided, we can return the local epoch
** constant. Otherwise, the epoch value for the requested
** timezone must be generated.
*/
return((tz == null) ? SqlDates.getEpochTime()
: SqlDates.parseTime(SqlDates.T_EPOCH, tz));
}
else if (value.Length == SqlDates.TS_FMT.Length) // Timestamp
{
/*
** Remove the date component but retain correct time:
**
** 1. Convert to GMT timestamp using TZ for current connection.
** 2. Re-format as time only using local TZ to get local time.
** 3. Generate Time value using requested/local TZ.
*/
DateTime ts = SqlDates.parseTimestamp(value, use_gmt);
String str = SqlDates.formatTime(ts, false);
return((osql_dates && tz != null)
? SqlDates.parseTime(str, tz)
: SqlDates.parseTime(str, false));
}
else // Interval
{
/*
** Can't support intervals with Time objects.
*/
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
}
}
catch (SqlEx ex)
{
/*
** Any parsing error is assumed to be caused by an interval.
*/
interval = true;
throw ex;
}
} // getTime
get(TimeZone tz)
{
/*
** Dates should be independent of TZ, but JDBC date values
** are stored in UTC. Use the TZ provided to ensure the
** resulting UTC value represents the date in the desired
** TZ. Otherwise, the local default TZ is used.
*/
return((tz != null) ? SqlDates.parseDate(value, tz)
: SqlDates.parseDate(value, false));
} // get
set(DateTime value, TimeZone tz)
{
// DateTime does not have a null
//if (value == null)
//{
// setNull();
// return;
//}
setNotNull();
nanos = 0;
if (value.Kind == DateTimeKind.Utc) // if UTC, normalize to LOCAL
{
value = value.ToLocalTime();
}
switch (dbms_type)
{
case DBMS_TYPE_TIME:
/*
** DAS parses local time using GMT.
*/
this.value = SqlDates.formatTime(value, true);
break;
case DBMS_TYPE_TMWO:
/*
** Format as local time using requested or default timezone.
*/
this.value = (tz != null) ? SqlDates.formatTime(value, tz)
: SqlDates.formatTime(value, false);
break;
case DBMS_TYPE_TMTZ:
/*
** Format as local time using requested or default timezone.
*/
this.value = (tz != null) ? SqlDates.formatTime(value, tz)
: SqlDates.formatTime(value, false);
/*
** Java applies TZ and DST of 'epoch' date: 1970-01-01.
** Ingres applies TZ and DST of todays date, so use
** current date to determine explicit TZ offset.
*/
long millis = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
timezone = (tz != null) ? SqlDates.formatTZ(tz, millis)
: SqlDates.formatTZ(millis);
break;
}
return;
} // set
set(DateTime value, TimeZone tz)
{
//DateTime does not have a null state
//if (value == null)
//{
// setNull();
// return;
//}
setNotNull();
nanos = 0;
if (value.Kind == DateTimeKind.Utc) // if UTC, normalize to LOCAL
{
value = value.ToLocalTime();
}
switch (dbms_type)
{
case DBMS_TYPE_TS:
/*
** DAS parses local time using GMT.
*/
this.value = SqlDates.formatTimestamp(value, true);
break;
case DBMS_TYPE_TSWO:
/*
** Format as local time using requested or default timezone.
*/
this.value = (tz != null) ? SqlDates.formatTimestamp(value, tz)
: SqlDates.formatTimestamp(value, false);
break;
case DBMS_TYPE_TSTZ:
/*
** Format as local time using requested or default timezone.
*/
this.value = (tz != null) ? SqlDates.formatTimestamp(value, tz)
: SqlDates.formatTimestamp(value, false);
/*
** Get the TZ offset of the target value in the requested
** or default timezone.
*/
timezone = (tz != null) ? SqlDates.formatTZ(tz, value)
: SqlDates.formatTZ(value);
break;
}
return;
} // set
setTime(DateTime value, TimeZone tz)
{
// DateTime is never null
//if ( value == null )
//setNull();
//else
{
/*
** The time is stored in GMT. Timezones are not applied to
** Ingres times since they are also stored in GMT. OpenSQL
** times are assumed to be in the client TZ, so timezones
** can be applied to store values for specific timezones.
*/
if (osql_dates && tz != null)
{
/*
** First retrieve the time in the desired TZ.
*/
String str = SqlDates.formatTime(value, tz);
/*
** The local TZ will be applied, either by the driver or
** the gateway, during subsequent processing. We use the
** local TZ to save the desired value so as to cancel the
** future application of the local TZ.
*/
value = SqlDates.parseTime(str, false);
}
/*
** Produce the correct time value for the current connection.
**
** Ingres only partially supports time only values and adds
** the current date to such values. JDBC specifies that the
** date portion for time values should be set to the date
** epoch 1970-01-01. When the current date has a different
** daylight savings offset than the epoch, a one hour offset
** can occur because of the different GMT offsets applied by
** Java and Ingres. Due to these problems, format the time
** as a timestamp to ensure consistent processing. Note that
** formatTimestamp() takes a java.util.Date parameter of which
** java.sql.Time is a sub-class.
*/
setNotNull();
this.value = SqlDates.formatTimestamp(value, use_gmt);
interval = false;
}
return;
} // setTime
getString()
{
/*
** Format using local default TZ for local time.
** Nano-seconds must be manually formatted.
*/
String str = SqlDates.formatTime(get(null), false);
if (nanos > 0)
{
str += SqlDates.formatFrac(nanos);
}
return(str);
} // getString
get()
{
String value = this.value;
if (nanos > 0)
{
value += SqlDates.formatFrac(nanos);
}
if (dbms_type == DBMS_TYPE_TMTZ)
{
value += timezone;
}
return(value);
} // get
setTimestamp(DateTime value, TimeZone tz)
{
// DateTime is never null
//if (value == null)
// setNull();
//else
if (tz != null)
{
setString(SqlDates.formatTimestamp(value, tz));
}
else
{
setString(SqlDates.formatTimestamp(value, false));
}
return;
} // setTimestamp
set(DateTime value, TimeZone tz)
{
// DateTime structure can never be null
//if (value == null)
//{
// setNull();
// return;
//}
/*
** Dates should be independent of TZ, but JDBC date values
** are stored in UTC. Use the TZ provided to ensure the
** formatted value represents the date in the desired TZ.
** Otherwise, the local default TZ is used.
*/
setNotNull();
this.value = (tz != null) ? SqlDates.formatDate(value, tz)
: SqlDates.formatDate(value, false);
return;
} // set
get(TimeZone tz)
{
DateTime time;
switch (dbms_type)
{
case DBMS_TYPE_TIME:
time = SqlDates.parseTime(value, true);
time = time.ToLocalTime();
break;
case DBMS_TYPE_TMWO:
/*
** Interpret as local time using requested or default timezone.
*/
time = (tz != null) ? SqlDates.parseTime(value, tz)
: SqlDates.parseTime(value, false);
break;
case DBMS_TYPE_TMTZ:
/*
** TIME WITH TIMEZONE values are local with
** explicit timezone offset.
*/
time = SqlDates.parseTime(value, SqlDates.getTZ(timezone));
time = time.ToLocalTime();
break;
default: // should never happen since constructor checked
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
} // end switch
if (nanos > 0)
{
TimeSpan span = new TimeSpan(nanos / 100L); // one tick = 100 nanos
time += span; // add the nanos back in
}
return(time);
} // get
set(String value)
{
if (value == null)
{
setNull();
}
else
{
/*
** Separate explicit timezone.
*/
if (dbms_type == DBMS_TYPE_TMTZ)
{
if (value.Length <
(SqlDates.T_FMT.Length + SqlDates.TZ_FMT.Length))
{
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
}
int offset = value.Length - SqlDates.TZ_FMT.Length;
timezone = value.Substring(offset);
value = value.Substring(0, offset);
}
/*
** Separate fractional seconds.
*/
if (value.Length > SqlDates.T_FMT.Length)
{
nanos = SqlDates.parseFrac(
value.Substring(SqlDates.T_FMT.Length));
value = value.Substring(0, SqlDates.T_FMT.Length);
}
setNotNull();
this.value = value;
}
return;
} // set
get(TimeZone tz)
{
DateTime ts;
switch (dbms_type)
{
case DBMS_TYPE_TS:
/*
** DAS formats local time using GMT.
*/
ts = SqlDates.parseTimestamp(value, true);
break;
case DBMS_TYPE_TSWO:
/*
** Interpret as local time in requested or default timezone.
*/
ts = (tz != null) ? SqlDates.parseTimestamp(value, tz)
: SqlDates.parseTimestamp(value, false);
break;
case DBMS_TYPE_TSTZ:
/*
** Apply explicit timezone.
*/
ts = SqlDates.parseTimestamp(value, SqlDates.getTZ(timezone));
break;
default: // should never happen since constructor checked
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
}
// ts.setNanos(nanos);
if (nanos > 0)
{
TimeSpan span = new TimeSpan(nanos / 100L); // one tick = 100 nanos
ts += span; // add the nanos back in
}
return(ts);
} // get
setDate(DateTime value, TimeZone tz)
{
// DateTime is never null
// if ( value == null )
// setNull();
// else
{
/*
** The date is stored in GMT such as to have a 0 time for
** the local TZ. Ingres dates are not associated with a
** TZ. Gateways add a 0 time to dates which is assumed to
** be in the client TZ. Timezones can be applied in both
** cases to get the actual date in the desired TZ. Other-
** wise, the date in the local TZ is used.
*/
setNotNull();
interval = false;
this.value = (tz != null) ? SqlDates.formatDate(value, tz)
: SqlDates.formatDate(value, false);
}
return;
} // setDate
setTimestamp(DateTime value, TimeZone tz)
{
// DateTime is never null
//if ( value == null )
//setNull();
//else
{
/*
** The timestamp is stored in GMT. Timezones are not applied to
** Ingres timestamps since they are also stored in GMT. OpenSQL
** timestamps are assumed to be in the client TZ, so timezones
** can be applied to store values for specific timezones.
*/
if (osql_dates && tz != null)
{
/*
** First retrieve the timestamp for the desired TZ.
*/
String str = SqlDates.formatTimestamp(value, tz);
/*
** The local TZ will be applied, either by the driver or
** the gateway, during subsequent processing. We use the
** local TZ to save the desired value to cancel the future
** application.
*/
value = SqlDates.parseTimestamp(str, false);
}
setNotNull();
this.value = SqlDates.formatTimestamp(value, use_gmt);
interval = false;
}
return;
} // setTimestamp
setTimestamp(DateTime ts, TimeZone tz)
{
set(ts, tz);
nanos = SqlDates.getNanos(ts);
return;
} // setTimestamp
getTimestamp(TimeZone tz)
{
return((tz == null) ? SqlDates.parseTimestamp(value.Trim(), false)
: SqlDates.parseTimestamp(value.Trim(), tz));
}
getTimestamp(TimeZone tz)
{
/*
** Ingres dates are overloaded with 'empty' date,
** date only, timestamp and interval values. The
** first three types are handled explicitly below.
** Intervals will either cause an exception while
** attempting to parse the value or as the default
** action for an unrecognized format.
*/
try
{
if (value.Length == 0) // Empty date
{
/*
** Create a timstamp EPOCH value. If no timezone is
** provided, we can return the local epoch constant.
** Otherwise, the epoch value for the requested
** timezone must be generated.
*/
return((tz == null) ? SqlDates.getEpochTimestamp()
: SqlDates.parseTimestamp(SqlDates.TS_EPOCH, tz));
}
else if (value.Length == SqlDates.D_FMT.Length) // Date only
{
/*
** There is no time component, so convert to timestamp with
** a 0 time component for the requested/local timezone.
*/
DateTime date = (tz == null)
? SqlDates.parseDate(value, false)
: SqlDates.parseDate(value, tz);
return(date);
}
else if (value.Length == SqlDates.TS_FMT.Length) // Timestamp
{
/*
** Convert to GMT timestamp using TZ for current connection.
*/
DateTime ts = SqlDates.parseTimestamp(value, use_gmt);
if (osql_dates && tz != null)
{
/*
** Effectively, we need to apply time difference
** between local and requested timezones. First,
** apply local TZ to get local timestamp. Then
** apply requested TZ to get desired GMT value.
*/
String str = SqlDates.formatTimestamp(ts, false);
ts = SqlDates.parseTimestamp(str, tz);
}
return(ts);
}
else // Interval
{
/*
** Can't support intervals with Timestamp objects.
*/
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
}
}
catch (SqlEx ex)
{
/*
** Any parsing error is assumed to be caused by an interval.
*/
interval = true;
throw ex;
}
} // getTimestamp
getDate(TimeZone tz)
{
return((tz == null) ? SqlDates.parseDate(value.Trim(), false)
: SqlDates.parseDate(value.Trim(), tz));
} // getDate
getDate(TimeZone tz)
{
/*
** Ingres dates are overloaded with 'empty' date,
** date only, timestamp and interval values. The
** first three types are handled explicitly below.
** Intervals will either cause an exception while
** attempting to parse the value or as the default
** action for an unrecognized format.
*/
try
{
if (value.Length == 0) // Empty date
{
/*
** Ingres permits zero length date literals or 'empty'
** dates. Since does not have any corresponding
** date/time concept, we use the date epoch. If
** no timezone is provided, we can return the local
** epoch constant. Otherwise, the epoch value for the
** requested timezone must be generated.
*/
return((tz == null) ? SqlDates.getEpochDate()
: SqlDates.parseDate(SqlDates.D_EPOCH, tz));
}
else if (value.Length == SqlDates.D_FMT.Length) // Date only
{
/*
** The date is stored in GMT such as to have a 0 time for
** the target TZ (requested/local).
*/
return((tz == null) ? SqlDates.parseDate(value, false)
: SqlDates.parseDate(value, tz));
}
else if (value.Length == SqlDates.TS_FMT.Length) // Timestamp
{
/*
** Remove the time component but retain correct date:
**
** 1. Convert to GMT Timestamp using TZ for current connection.
** 2. Format as date only using local TZ to get local date.
** 3. Generate Date value using requested/local timezone.
*/
DateTime date = SqlDates.parseTimestamp(value, use_gmt);
String str = SqlDates.formatDate(date, false);
return((osql_dates && tz != null)
? SqlDates.parseDate(str, tz)
: SqlDates.parseDate(str, false));
}
else // Interval
{
/*
** Can't support intervals with Date objects.
*/
throw SqlEx.get(ERR_GC401B_INVALID_DATE);
}
}
catch (SqlEx ex)
{
/*
** Any parsing error is assumed to be caused by an interval.
*/
interval = true;
throw ex;
}
} // getDate
getString()
{
String str;
/*
** Ingres dates are overloaded with 'empty' date,
** date only, timestamp and interval values. The
** raw data string is returned for empty dates and
** intervals. Date only values and timestamps are
** parsed/formatted to validate and set timezone.
** Intervals will cause an exception if an attempt
** is made to parse the value or will be detected
** by a mis-match in expected string lengths.
*/
try
{
if (value.Length == 0) // Empty date
{
/*
** Return the empty date string.
*/
str = value;
}
else if (value.Length == SqlDates.D_FMT.Length) // Date only
{
/*
** Do conversion to check for valid format (in
** case this is an interval). Ingres dates are
** indepedent of timezone, so use local TZ.
*/
DateTime dt = SqlDates.parseDate(value, false);
str = SqlDates.formatDate(dt, false);
}
else if (value.Length == SqlDates.TS_FMT.Length) // Timestamp
{
/*
** Convert to GMT using TZ for current connection
** and then to local time using local TZ.
*/
DateTime ts = SqlDates.parseTimestamp(value, use_gmt);
str = SqlDates.formatTimestamp(ts, false);
}
else // Interval
{
/*
** Return the interval string and produce a warning.
*/
interval = true;
str = value;
}
}
catch (SqlEx)
{
/*
** Any parsing error is assumed to be caused by an interval.
*/
interval = true;
str = value;
}
return(str);
} // getString
