Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
Derby - Class com.pivotal.gemfirexd.internal.client.am.DateTime
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.
*/
/*
* Changes for GemFireXD distributed data platform (some marked by "GemStone changes")
*
* Portions Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed 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. See accompanying
* LICENSE file.
*/
package com.pivotal.gemfirexd.internal.client.am;
import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import com.gemstone.gemfire.internal.shared.ClientSharedData;
import com.pivotal.gemfirexd.internal.client.net.Typdef;
import com.pivotal.gemfirexd.internal.shared.common.i18n.MessageUtil;
import com.pivotal.gemfirexd.internal.shared.common.reference.SQLState;
// GemStone changes BEGIN
/**
* High performance converters from date/time byte encodings to JDBC Date, Time and Timestamp objects.
*
* Using this class for direct date/time conversions from bytes offers superior performance over the alternative method
* of first constructing a Java String from the encoded bytes, and then using {@link java.sql.Date#valueOf
* java.sql.Date.valueOf()}, {@link java.sql.Time#valueOf java.sql.Time.valueOf()} or {@link java.sql.Timestamp#valueOf
* java.sql.Timestamp.valueOf()}.
*
*/
public class DateTime {
// Hide the default constructor
private DateTime() {
}
private static final int dateRepresentationLength = 10;
private static final int timeRepresentationLength = 8;
// GemStone changes BEGIN
private static final int timestampRepresentationLength = com.pivotal.gemfirexd.internal.shared.common.SharedUtils.TIMESTAMP_RLENGTH;
/* (original code)
private static final int timestampRepresentationLength = 26;
*/
// GemStone changes END
// *********************************************************
// ********** Output converters (byte[] -> class) **********
// *********************************************************
/**
* Expected character representation is DERBY string representation of a date,
* which is in JIS format: yyyy-mm-dd
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer data
* @return Date translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Date dateBytesToDate(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException {
int year, month, day;
String date = new String(buffer, offset,
DateTime.dateRepresentationLength,encoding);
int yearIndx, monthIndx, dayIndx;
if (date.charAt(4) == '-') {
// JIS format: yyyy-mm-dd.
yearIndx = 0;
monthIndx = 5;
dayIndx = 8;
} else {
throw new java.lang.IllegalArgumentException(
SqlException.getMessageUtil().getTextMessage(
SQLState.LANG_FORMAT_EXCEPTION));
}
int zeroBase = ((int) '0');
// Character arithmetic is used rather than
// the less efficient Integer.parseInt (date.substring()).
year =
1000 * (((int) date.charAt(yearIndx)) - zeroBase) +
100 * (((int) date.charAt(yearIndx + 1)) - zeroBase) +
10 * (((int) date.charAt(yearIndx + 2)) - zeroBase) +
(((int) date.charAt(yearIndx + 3)) - zeroBase);
month =
10 * (((int) date.charAt(monthIndx)) - zeroBase) +
(((int) date.charAt(monthIndx + 1)) - zeroBase) -
1;
day =
10 * (((int) date.charAt(dayIndx)) - zeroBase) +
(((int) date.charAt(dayIndx + 1)) - zeroBase);
Calendar cal = getCleanCalendar(recyclableCal);
cal.set(year, month, day);
return new java.sql.Date(cal.getTimeInMillis());
}
/**
* Expected character representation is DERBY string representation of time,
* which is in the format: hh.mm.ss
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return Time translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Time timeBytesToTime(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException {
int hour, minute, second;
String time = new String(buffer, offset,
DateTime.timeRepresentationLength, encoding);
int zeroBase = ((int) '0');
// compute hour.
hour =
10 * (((int) time.charAt(0)) - zeroBase) +
(((int) time.charAt(1)) - zeroBase);
// compute minute.
minute =
10 * (((int) time.charAt(3)) - zeroBase) +
(((int) time.charAt(4)) - zeroBase);
// compute second.
second =
10 * (((int) time.charAt(6)) - zeroBase) +
(((int) time.charAt(7)) - zeroBase);
Calendar cal = getCleanCalendar(recyclableCal);
cal.set(1970, Calendar.JANUARY, 1, hour, minute, second);
return new java.sql.Time(cal.getTimeInMillis());
}
/**
* Expected character representation is DERBY string representation of a timestamp:
* yyyy-mm-dd-hh.mm.ss.ffffff.
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return TimeStamp translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Timestamp timestampBytesToTimestamp(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException
{
int year, month, day, hour, minute, second, fraction;
String timestamp = new String(buffer, offset,
DateTime.timestampRepresentationLength,encoding);
Calendar cal = getCleanCalendar(recyclableCal);
/* java.sql.Timestamp has nanosecond precision, so we have to keep
* the parsed microseconds value and use that to set nanos.
*/
int micros = parseTimestampString(timestamp, cal);
java.sql.Timestamp ts = new java.sql.Timestamp(cal.getTimeInMillis());
ts.setNanos(micros * 1000);
return ts;
}
/**
* Parse a String of the form yyyy-mm-dd-hh.mm.ss.ffffff
* and store the various fields into the received Calendar object.
*
* @param timestamp Timestamp value to parse, as a String.
* @param cal Calendar into which to store the parsed fields. Should
* not be null.
*
* @return The microseconds field as parsed from the timestamp string.
* This cannot be set in the Calendar object but we still want to
* preserve the value, in case the caller needs it (for example, to
* create a java.sql.Timestamp with microsecond precision).
*/
private static int parseTimestampString(String timestamp,
Calendar cal)
{
// GemStone changes BEGIN
// now using the version in SharedUtils
return com.pivotal.gemfirexd.internal.shared.common.SharedUtils
.parseTimestampString(timestamp, cal);
/* (original code)
int zeroBase = ((int) '0');
cal.set(Calendar.YEAR,
1000 * (((int) timestamp.charAt(0)) - zeroBase) +
100 * (((int) timestamp.charAt(1)) - zeroBase) +
10 * (((int) timestamp.charAt(2)) - zeroBase) +
(((int) timestamp.charAt(3)) - zeroBase));
cal.set(Calendar.MONTH,
10 * (((int) timestamp.charAt(5)) - zeroBase) +
(((int) timestamp.charAt(6)) - zeroBase) - 1);
cal.set(Calendar.DAY_OF_MONTH,
10 * (((int) timestamp.charAt(8)) - zeroBase) +
(((int) timestamp.charAt(9)) - zeroBase));
cal.set(Calendar.HOUR,
10 * (((int) timestamp.charAt(11)) - zeroBase) +
(((int) timestamp.charAt(12)) - zeroBase));
cal.set(Calendar.MINUTE,
10 * (((int) timestamp.charAt(14)) - zeroBase) +
(((int) timestamp.charAt(15)) - zeroBase));
cal.set(Calendar.SECOND,
10 * (((int) timestamp.charAt(17)) - zeroBase) +
(((int) timestamp.charAt(18)) - zeroBase));
int micros =
100000 * (((int) timestamp.charAt(20)) - zeroBase) +
10000 * (((int) timestamp.charAt(21)) - zeroBase) +
1000 * (((int) timestamp.charAt(22)) - zeroBase) +
100 * (((int) timestamp.charAt(23)) - zeroBase) +
10 * (((int) timestamp.charAt(24)) - zeroBase) +
(((int) timestamp.charAt(25)) - zeroBase);
/* The "ffffff" that we parsed is microseconds. In order to
* capture that information inside of the MILLISECOND field
* we have to divide by 1000.
*
cal.set(Calendar.MILLISECOND, micros / 1000);
return micros;
*/
// GemStone changes END
}
// ********************************************************
// ********** Input converters (class -> byte[]) **********
// ********************************************************
/**
* Date is converted to a char representation in JDBC date format: yyyy-mm-dd date format
* and then converted to bytes using UTF8 encoding
* @param buffer bytes in UTF8 encoding of the date
* @param offset write into the buffer from this offset
* @param date date value
* @return DateTime.dateRepresentationLength. This is the fixed length in
* bytes taken to represent the date value
* @throws SqlException
* @throws UnsupportedEncodingException if UTF8 Encoding is not supported
*/
public static final int dateToDateBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Date date,
java.util.Calendar cal)
throws SqlException, UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(date);
int year = cal.get(Calendar.YEAR);
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
year, "9999");
}
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DAY_OF_MONTH);
/* (original code)
java.sql.Date date)
throws SqlException,UnsupportedEncodingException {
int year = date.getYear() + 1900;
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
new Integer(year), "9999");
}
int month = date.getMonth() + 1;
int day = date.getDate();
*/
// GemStone changes END
char[] dateChars = new char[DateTime.dateRepresentationLength];
int zeroBase = (int) '0';
dateChars[0] = (char) (year / 1000 + zeroBase);
dateChars[1] = (char) ((year % 1000) / 100 + zeroBase);
dateChars[2] = (char) ((year % 100) / 10 + zeroBase);
dateChars[3] = (char) (year % 10 + +zeroBase);
dateChars[4] = '-';
dateChars[5] = (char) (month / 10 + zeroBase);
dateChars[6] = (char) (month % 10 + zeroBase);
dateChars[7] = '-';
dateChars[8] = (char) (day / 10 + zeroBase);
dateChars[9] = (char) (day % 10 + zeroBase);
// Network server expects to read the date parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] dateBytes = (new String(dateChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(dateBytes, 0, buffer, offset, DateTime.dateRepresentationLength);
return DateTime.dateRepresentationLength;
}
/**
* java.sql.Time is converted to character representation which is in JDBC time escape
* format: hh:mm:ss, which is the same as JIS time format in DERBY string
* representation of a time. The char representation is converted to bytes using UTF8
* encoding.
* @param buffer bytes in UTF8 encoding of the time
* @param offset write into the buffer from this offset
* @param time java.sql.Time value
* @return DateTime.timeRepresentationLength. This is the fixed length in
* bytes taken to represent the time value
* @throws UnsupportedEncodingException
*/
public static final int timeToTimeBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Time time,
java.util.Calendar cal)
throws UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(time);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
/* (original code)
java.sql.Time time)
throws UnsupportedEncodingException {
int hour = time.getHours();
int minute = time.getMinutes();
int second = time.getSeconds();
*/
// GemStone changes END
char[] timeChars = new char[DateTime.timeRepresentationLength];
int zeroBase = (int) '0';
timeChars[0] = (char) (hour / 10 + zeroBase);
timeChars[1] = (char) (hour % 10 + +zeroBase);
timeChars[2] = ':';
timeChars[3] = (char) (minute / 10 + zeroBase);
timeChars[4] = (char) (minute % 10 + zeroBase);
timeChars[5] = ':';
timeChars[6] = (char) (second / 10 + zeroBase);
timeChars[7] = (char) (second % 10 + zeroBase);
// Network server expects to read the time parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] timeBytes = (new String(timeChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(timeBytes, 0, buffer, offset, DateTime.timeRepresentationLength);
return DateTime.timeRepresentationLength;
}
/**
* java.sql.Timestamp is converted to a character representation which is in DERBY string
* representation of a timestamp: yyyy-mm-dd-hh.mm.ss.ffffff.
* and then converted to bytes using UTF8 encoding
* @param buffer bytes in UTF8 encoding of the timestamp
* @param offset write into the buffer from this offset
* @param timestamp timestamp value
* @return DateTime.timestampRepresentationLength. This is the fixed
* length in bytes, taken to represent the timestamp value
* @throws SqlException
* @throws UnsupportedEncodingException
*/
public static final int timestampToTimestampBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Timestamp timestamp,
java.util.Calendar cal)
throws SqlException, UnsupportedEncodingException {
cal = getCleanCalendar(cal);
// now using the version in SharedUtils
int numBytes = com.pivotal.gemfirexd.internal.shared.common.SharedUtils
.timestampToTimestampChars(buffer, offset, timestamp, cal);
if (numBytes < 0) {
throw new SqlException(null, new ClientMessageId(SQLState
.YEAR_EXCEEDS_MAXIMUM), -numBytes, "9999");
}
return numBytes;
/* (original code)
java.sql.Timestamp timestamp)
throws SqlException,UnsupportedEncodingException {
int year = timestamp.getYear() + 1900;
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
new Integer(year), "9999");
}
int month = timestamp.getMonth() + 1;
int day = timestamp.getDate();
int hour = timestamp.getHours();
int minute = timestamp.getMinutes();
int second = timestamp.getSeconds();
int microsecond = timestamp.getNanos() / 1000;
char[] timestampChars = new char[DateTime.timestampRepresentationLength];
int zeroBase = (int) '0';
timestampChars[0] = (char) (year / 1000 + zeroBase);
timestampChars[1] = (char) ((year % 1000) / 100 + zeroBase);
timestampChars[2] = (char) ((year % 100) / 10 + zeroBase);
timestampChars[3] = (char) (year % 10 + +zeroBase);
timestampChars[4] = '-';
timestampChars[5] = (char) (month / 10 + zeroBase);
timestampChars[6] = (char) (month % 10 + zeroBase);
timestampChars[7] = '-';
timestampChars[8] = (char) (day / 10 + zeroBase);
timestampChars[9] = (char) (day % 10 + zeroBase);
timestampChars[10] = '-';
timestampChars[11] = (char) (hour / 10 + zeroBase);
timestampChars[12] = (char) (hour % 10 + zeroBase);
timestampChars[13] = '.';
timestampChars[14] = (char) (minute / 10 + zeroBase);
timestampChars[15] = (char) (minute % 10 + zeroBase);
timestampChars[16] = '.';
timestampChars[17] = (char) (second / 10 + zeroBase);
timestampChars[18] = (char) (second % 10 + zeroBase);
timestampChars[19] = '.';
timestampChars[20] = (char) (microsecond / 100000 + zeroBase);
timestampChars[21] = (char) ((microsecond % 100000) / 10000 + zeroBase);
timestampChars[22] = (char) ((microsecond % 10000) / 1000 + zeroBase);
timestampChars[23] = (char) ((microsecond % 1000) / 100 + zeroBase);
timestampChars[24] = (char) ((microsecond % 100) / 10 + zeroBase);
timestampChars[25] = (char) (microsecond % 10 + zeroBase);
// Network server expects to read the timestamp parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] timestampBytes = (new String(timestampChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(timestampBytes, 0, buffer, offset, DateTime.timestampRepresentationLength);
return DateTime.timestampRepresentationLength;
*/
// GemStone changes END
}
// *********************************************************
// ******* CROSS output converters (byte[] -> class) *******
// *********************************************************
/**
* Expected character representation is DERBY string representation of a date
* which is in JIS format: yyyy-mm-dd
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return Timestamp translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Timestamp dateBytesToTimestamp(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException {
int year, month, day;
String date = new String(buffer, offset, DateTime.dateRepresentationLength,
encoding);
int yearIndx, monthIndx, dayIndx;
yearIndx = 0;
monthIndx = 5;
dayIndx = 8;
int zeroBase = ((int) '0');
// Character arithmetic is used rather than
// the less efficient Integer.parseInt (date.substring()).
year =
1000 * (((int) date.charAt(yearIndx)) - zeroBase) +
100 * (((int) date.charAt(yearIndx + 1)) - zeroBase) +
10 * (((int) date.charAt(yearIndx + 2)) - zeroBase) +
(((int) date.charAt(yearIndx + 3)) - zeroBase);
month =
10 * (((int) date.charAt(monthIndx)) - zeroBase) +
(((int) date.charAt(monthIndx + 1)) - zeroBase) -
1;
day =
10 * (((int) date.charAt(dayIndx)) - zeroBase) +
(((int) date.charAt(dayIndx + 1)) - zeroBase);
Calendar cal = getCleanCalendar(recyclableCal);
cal.set(year, month, day, 0, 0, 0);
java.sql.Timestamp ts = new java.sql.Timestamp(cal.getTimeInMillis());
ts.setNanos(0);
return ts;
}
/**
* Expected character representation is DERBY string representation of time
* which is in the format: hh.mm.ss
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return Timestamp translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*
*/
public static final java.sql.Timestamp timeBytesToTimestamp(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException {
int hour, minute, second;
String time = new String(buffer, offset,
DateTime.timeRepresentationLength, encoding);
int zeroBase = ((int) '0');
// compute hour.
hour =
10 * (((int) time.charAt(0)) - zeroBase) +
(((int) time.charAt(1)) - zeroBase);
// compute minute.
minute =
10 * (((int) time.charAt(3)) - zeroBase) +
(((int) time.charAt(4)) - zeroBase);
// compute second JIS format: hh:mm:ss.
second =
10 * (((int) time.charAt(6)) - zeroBase) +
(((int) time.charAt(7)) - zeroBase);
// The SQL standard specifies that the date portion of the returned
// timestamp should be set to the current date. See DERBY-889 for
// more details.
Calendar cal = getCleanCalendar(recyclableCal);
cal.setTime(new java.util.Date());
// Now override the time fields with the values we parsed.
cal.set(Calendar.HOUR_OF_DAY, hour);
cal.set(Calendar.MINUTE, minute);
cal.set(Calendar.SECOND, second);
// Derby's resolution for the TIME type is only seconds.
cal.set(Calendar.MILLISECOND, 0);
return new java.sql.Timestamp(cal.getTimeInMillis());
}
/**
* Expected character representation is DERBY string representation of a timestamp:
* yyyy-mm-dd-hh.mm.ss.ffffff.
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return Date translated from buffer with specified encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Date timestampBytesToDate(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException
{
int year, month, day;
String timestamp = new String(buffer, offset,
DateTime.timestampRepresentationLength, encoding);
int zeroBase = ((int) '0');
year =
1000 * (((int) timestamp.charAt(0)) - zeroBase) +
100 * (((int) timestamp.charAt(1)) - zeroBase) +
10 * (((int) timestamp.charAt(2)) - zeroBase) +
(((int) timestamp.charAt(3)) - zeroBase);
month =
10 * (((int) timestamp.charAt(5)) - zeroBase) +
(((int) timestamp.charAt(6)) - zeroBase) -
1;
day =
10 * (((int) timestamp.charAt(8)) - zeroBase) +
(((int) timestamp.charAt(9)) - zeroBase);
Calendar cal = getCleanCalendar(recyclableCal);
cal.set(year, month, day);
return new java.sql.Date(cal.getTimeInMillis());
}
/**
* Expected character representation is DERBY string representation of a timestamp:
* yyyy-mm-dd-hh.mm.ss.ffffff.
*
* @param buffer
* @param offset
* @param recyclableCal
* @param encoding encoding of buffer
* @return Time translated from buffer with specified Encoding
* @throws UnsupportedEncodingException
*/
public static final java.sql.Time timestampBytesToTime(byte[] buffer,
int offset,
Calendar recyclableCal,
String encoding)
throws UnsupportedEncodingException
{
/* When getting a java.sql.Time object from a TIMESTAMP value we
* need to preserve the milliseconds from the timestamp.
*
* Note: a Derby SQL TIME value has by definition resolution of only
* a second so its millisecond value is always zero. However,
* java.sql.Time is not a direct mapping to the SQL Type; rather, it's
* a JDBC type, and the JDBC java.sql.Time class has a precision of
* milliseconds. So when converting from a SQL TIMESTAMP we should
* retain the millisecond precision. DERBY-1816.
*
* In order to accomplish this we parse *all* fields of the timestamp
* into a Calendar object, then create the java.sql.Time object from
* that Calendar. This allows us to preserve the sub-second resolution
* that is parsed from the timestamp.
*/
String timestamp = new String(buffer, offset,
DateTime.timestampRepresentationLength, encoding);
Calendar cal = getCleanCalendar(recyclableCal);
/* Note that "parseTimestampString()" returns microseconds but we
* ignore micros because java.sql.Time only has millisecond precision.
*/
parseTimestampString(timestamp, cal);
/* Java API indicates that the date components of a Time value
* must be set to January 1, 1970. So override those values now.
*/
cal.set(1970, Calendar.JANUARY, 1);
return new java.sql.Time(cal.getTimeInMillis());
}
/**
* Return a clean (i.e. all values cleared out) Calendar object
* that can be used for creating Time, Timestamp, and Date objects.
* If the received Calendar object is non-null, then just clear
* that and return it.
*
* @param recyclableCal Calendar object to use if non-null.
*/
private static Calendar getCleanCalendar(Calendar recyclableCal)
{
if (recyclableCal != null)
{
recyclableCal.clear();
return recyclableCal;
}
/* Default GregorianCalendar initializes to current time.
* Make sure we clear that out before returning, per the
* contract of this method.
*/
return ClientSharedData.getDefaultCleanCalendar();
}
// *********************************************************
// ******* CROSS input converters (class -> byte[]) ********
// *********************************************************
/**
* java.sql.Timestamp is converted to character representation that is in JDBC date escape
* format: yyyy-mm-dd, which is the same as JIS date format in DERBY string representation of a date.
* and then converted to bytes using UTF8 encoding.
* @param buffer
* @param offset write into the buffer from this offset
* @param timestamp timestamp value
* @return DateTime.dateRepresentationLength. This is the fixed length
* in bytes, that is taken to represent the timestamp value as a date.
* @throws SqlException
* @throws UnsupportedEncodingException
*/
public static final int timestampToDateBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Timestamp timestamp,
java.util.Calendar cal)
throws SqlException, UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(timestamp);
int year = cal.get(Calendar.YEAR);
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
year, "9999");
}
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DAY_OF_MONTH);
/* (original code)
java.sql.Timestamp timestamp)
throws SqlException,UnsupportedEncodingException {
int year = timestamp.getYear() + 1900;
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
new Integer(year), "9999");
}
int month = timestamp.getMonth() + 1;
int day = timestamp.getDate();
*/
// GemStone changes END
char[] dateChars = new char[DateTime.dateRepresentationLength];
int zeroBase = (int) '0';
dateChars[0] = (char) (year / 1000 + zeroBase);
dateChars[1] = (char) ((year % 1000) / 100 + zeroBase);
dateChars[2] = (char) ((year % 100) / 10 + zeroBase);
dateChars[3] = (char) (year % 10 + +zeroBase);
dateChars[4] = '-';
dateChars[5] = (char) (month / 10 + zeroBase);
dateChars[6] = (char) (month % 10 + zeroBase);
dateChars[7] = '-';
dateChars[8] = (char) (day / 10 + zeroBase);
dateChars[9] = (char) (day % 10 + zeroBase);
// Network server expects to read the date parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] dateBytes = (new String(dateChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(dateBytes, 0, buffer, offset, DateTime.dateRepresentationLength);
return DateTime.dateRepresentationLength;
}
/**
* java.sql.Timestamp is converted to character representation in JDBC time escape format:
* hh:mm:ss, which is the same as
* JIS time format in DERBY string representation of a time. The char representation is
* then converted to bytes using UTF8 encoding and written out into the buffer
* @param buffer
* @param offset write into the buffer from this offset
* @param timestamp timestamp value
* @return DateTime.timeRepresentationLength. This is the fixed length
* in bytes taken to represent the timestamp value as Time.
* @throws UnsupportedEncodingException
*/
public static final int timestampToTimeBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Timestamp timestamp,
java.util.Calendar cal)
throws UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(timestamp);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
/* (original code)
java.sql.Timestamp timestamp)
throws UnsupportedEncodingException {
int hour = timestamp.getHours();
int minute = timestamp.getMinutes();
int second = timestamp.getSeconds();
*/
// GemStone changes END
char[] timeChars = new char[DateTime.timeRepresentationLength];
int zeroBase = (int) '0';
timeChars[0] = (char) (hour / 10 + zeroBase);
timeChars[1] = (char) (hour % 10 + +zeroBase);
timeChars[2] = ':';
timeChars[3] = (char) (minute / 10 + zeroBase);
timeChars[4] = (char) (minute % 10 + zeroBase);
timeChars[5] = ':';
timeChars[6] = (char) (second / 10 + zeroBase);
timeChars[7] = (char) (second % 10 + zeroBase);
// Network server expects to read the time parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] timeBytes = (new String(timeChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(timeBytes, 0, buffer, offset, DateTime.timeRepresentationLength);
return DateTime.timeRepresentationLength;
}
/**
* java.sql.Date is converted to character representation that is in DERBY string
* representation of a timestamp:yyyy-mm-dd-hh.mm.ss.ffffff and then
* converted to bytes using UTF8 encoding and written out to the buffer
* @param buffer
* @param offset offset in buffer to start writing to
* @param date date value
* @return DateTime.timestampRepresentationLength. This is the fixed length
* in bytes, taken to represent the timestamp value.
* @throws SqlException
* @throws UnsupportedEncodingException
*/
public static final int dateToTimestampBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Date date,
java.util.Calendar cal)
throws SqlException, UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(date);
int year = cal.get(Calendar.YEAR);
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
new Integer(year), "9999");
}
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DAY_OF_MONTH);
/* (original code)
java.sql.Date date)
throws SqlException, UnsupportedEncodingException {
int year = date.getYear() + 1900;
if (year > 9999) {
throw new SqlException(null,
new ClientMessageId(SQLState.YEAR_EXCEEDS_MAXIMUM),
new Integer(year), "9999");
}
int month = date.getMonth() + 1;
int day = date.getDate();
*/
// GemStone changes END
char[] timestampChars = new char[DateTime.timestampRepresentationLength];
int zeroBase = (int) '0';
timestampChars[0] = (char) (year / 1000 + zeroBase);
timestampChars[1] = (char) ((year % 1000) / 100 + zeroBase);
timestampChars[2] = (char) ((year % 100) / 10 + zeroBase);
timestampChars[3] = (char) (year % 10 + +zeroBase);
timestampChars[4] = '-';
timestampChars[5] = (char) (month / 10 + zeroBase);
timestampChars[6] = (char) (month % 10 + zeroBase);
timestampChars[7] = '-';
timestampChars[8] = (char) (day / 10 + zeroBase);
timestampChars[9] = (char) (day % 10 + zeroBase);
timestampChars[10] = '-';
timestampChars[11] = '0';
timestampChars[12] = '0';
timestampChars[13] = '.';
timestampChars[14] = '0';
timestampChars[15] = '0';
timestampChars[16] = '.';
timestampChars[17] = '0';
timestampChars[18] = '0';
timestampChars[19] = '.';
timestampChars[20] = '0';
timestampChars[21] = '0';
timestampChars[22] = '0';
timestampChars[23] = '0';
timestampChars[24] = '0';
timestampChars[25] = '0';
// Network server expects to read the timestamp parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams
byte[] timestampBytes = (new String(timestampChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(timestampBytes, 0, buffer, offset, DateTime.timestampRepresentationLength);
return DateTime.timestampRepresentationLength;
}
/**
* java.sql.Time is converted to a character representation that is in DERBY string representation of a timestamp:
* yyyy-mm-dd-hh.mm.ss.ffffff and converted to bytes using UTF8 encoding
* @param buffer
* @param offset offset in buffer to start writing to
* @param time time value
* @return DateTime.timestampRepresentationLength which is the fixed length
* taken up by the conversion of time to timestamp in bytes
* @throws UnsupportedEncodingException
*/
public static final int timeToTimestampBytes(byte[] buffer,
int offset,
// GemStone changes BEGIN
java.sql.Time time,
java.util.Calendar cal)
throws UnsupportedEncodingException {
cal = getCleanCalendar(cal);
cal.setTime(time);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
/* (original code)
java.sql.Time time)
throws UnsupportedEncodingException {
int hour = time.getHours();
int minute = time.getMinutes();
int second = time.getSeconds();
*/
// GemStone changes END
char[] timestampChars = new char[DateTime.timestampRepresentationLength];
int zeroBase = (int) '0';
timestampChars[0] = '1';
timestampChars[1] = '9';
timestampChars[2] = '0';
timestampChars[3] = '0';
timestampChars[4] = '-';
timestampChars[5] = '0';
timestampChars[6] = '1';
timestampChars[7] = '-';
timestampChars[8] = '0';
timestampChars[9] = '1';
timestampChars[10] = '-';
timestampChars[11] = (char) (hour / 10 + zeroBase);
timestampChars[12] = (char) (hour % 10 + zeroBase);
timestampChars[13] = '.';
timestampChars[14] = (char) (minute / 10 + zeroBase);
timestampChars[15] = (char) (minute % 10 + zeroBase);
timestampChars[16] = '.';
timestampChars[17] = (char) (second / 10 + zeroBase);
timestampChars[18] = (char) (second % 10 + zeroBase);
timestampChars[19] = '.';
timestampChars[20] = '0';
timestampChars[21] = '0';
timestampChars[22] = '0';
timestampChars[23] = '0';
timestampChars[24] = '0';
timestampChars[25] = '0';
// Network server expects to read the timestamp parameter value bytes with
// UTF-8 encoding. Reference - DERBY-1127
// see DRDAConnThread.readAndSetParams for TIMESTAMP
byte[] timestampBytes = (new String(timestampChars)).getBytes(Typdef.UTF8ENCODING);
System.arraycopy(timestampBytes, 0, buffer, offset, DateTime.timestampRepresentationLength);
return DateTime.timestampRepresentationLength;
}
}
