/* Copyright (c) 2001-2010, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hsqldb.types;
import java.math.BigDecimal;
import org.hsqldb.OpTypes;
import org.hsqldb.Session;
import org.hsqldb.SessionInterface;
import org.hsqldb.Tokens;
import org.hsqldb.error.Error;
import org.hsqldb.error.ErrorCode;
/**
* Type subclass for various typs of INTERVAL.<p>
*
* @author Fred Toussi (fredt@users dot sourceforge.net)
* @version 1.9.0
* @since 1.9.0
*/
public final class IntervalType extends DTIType {
public final boolean defaultPrecision;
public final boolean isYearMonth;
private IntervalType(int typeGroup, int type, long precision, int scale,
int startIntervalType, int endIntervalType,
boolean defaultPrecision) {
super(typeGroup, type, precision, scale, startIntervalType,
endIntervalType);
switch (startIntervalType) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_MONTH :
isYearMonth = true;
break;
default :
isYearMonth = false;
break;
}
this.defaultPrecision = defaultPrecision;
}
public int displaySize() {
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
return (int) precision + 1;
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
return (int) precision + 4;
case Types.SQL_INTERVAL_MONTH :
return (int) precision + 1;
case Types.SQL_INTERVAL_DAY :
return (int) precision + 1;
case Types.SQL_INTERVAL_DAY_TO_HOUR :
return (int) precision + 4;
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
return (int) precision + 7;
case Types.SQL_INTERVAL_DAY_TO_SECOND :
return (int) precision + 10 + (scale == 0 ? 0
: scale + 1);
case Types.SQL_INTERVAL_HOUR :
return (int) precision + 1;
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
return (int) precision + 4;
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
return (int) precision + 7 + (scale == 0 ? 0
: scale + 1);
case Types.SQL_INTERVAL_MINUTE :
return (int) precision + 1;
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
return (int) precision + 4 + (scale == 0 ? 0
: scale + 1);
case Types.SQL_INTERVAL_SECOND :
return (int) precision + 1 + (scale == 0 ? 0
: scale + 1);
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public int getJDBCTypeCode() {
// no JDBC number is available
return typeCode;
}
public Class getJDBCClass() {
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
return IntervalMonthData.class;
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
return org.hsqldb.types.IntervalSecondData.class;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public String getJDBCClassName() {
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
return IntervalMonthData.class.getName();
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
return org.hsqldb.types.IntervalSecondData.class.getName();
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public int getJDBCPrecision() {
return this.displaySize();
}
public int getSQLGenericTypeCode() {
return Types.SQL_INTERVAL;
}
public String getNameString() {
return "INTERVAL " + getQualifier(typeCode);
}
public static String getQualifier(int type) {
switch (type) {
case Types.SQL_INTERVAL_YEAR :
return "YEAR";
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
return "YEAR TO MONTH";
case Types.SQL_INTERVAL_MONTH :
return "MONTH";
case Types.SQL_INTERVAL_DAY :
return "DAY";
case Types.SQL_INTERVAL_DAY_TO_HOUR :
return "DAY TO HOUR";
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
return "DAY TO MINUTE";
case Types.SQL_INTERVAL_DAY_TO_SECOND :
return "DAY TO SECOND";
case Types.SQL_INTERVAL_HOUR :
return "HOUR";
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
return "HOUR TO MINUTE";
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
return "HOUR TO SECOND";
case Types.SQL_INTERVAL_MINUTE :
return "MINUTE";
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
return "MINUTE TO SECOND";
case Types.SQL_INTERVAL_SECOND :
return "SECOND";
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public String getDefinition() {
if (precision == defaultIntervalPrecision
&& (endIntervalType != Types.SQL_INTERVAL_SECOND
|| scale == defaultIntervalFractionPrecision)) {
return getNameString();
}
StringBuffer sb = new StringBuffer(32);
sb.append(Tokens.T_INTERVAL).append(' ');
sb.append(getQualifier(startIntervalType));
if (typeCode == Types.SQL_INTERVAL_SECOND) {
sb.append('(');
sb.append(precision);
if (scale != defaultIntervalFractionPrecision) {
sb.append(',');
sb.append(scale);
}
sb.append(')');
return sb.toString();
}
if (precision != defaultIntervalPrecision) {
sb.append('(');
sb.append(precision);
sb.append(')');
}
if (startIntervalType != endIntervalType) {
sb.append(' ');
sb.append(Tokens.T_TO);
sb.append(' ');
sb.append(Tokens.SQL_INTERVAL_FIELD_NAMES[endPartIndex]);
if (endIntervalType == Types.SQL_INTERVAL_SECOND
&& scale != defaultIntervalFractionPrecision) {
sb.append('(');
sb.append(scale);
sb.append(')');
}
}
return sb.toString();
}
public boolean isIntervalType() {
return true;
}
public boolean isYearMonthIntervalType() {
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
return true;
default :
return false;
}
}
public boolean isDaySecondIntervalType() {
switch (typeCode) {
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
return true;
default :
return false;
}
}
public boolean acceptsPrecision() {
return true;
}
public boolean acceptsFractionalPrecision() {
return endIntervalType == Types.SQL_INTERVAL_SECOND;
}
public Type getAggregateType(Type other) {
if (typeCode == other.typeCode) {
if (precision >= other.precision && scale >= other.scale) {
return this;
} else if (precision <= other.precision && scale <= other.scale) {
return other;
}
}
if (other == SQL_ALL_TYPES) {
return this;
}
if (other.isCharacterType()) {
return other.getAggregateType(this);
}
if (!other.isIntervalType()) {
throw Error.error(ErrorCode.X_42562);
}
int startType = ((IntervalType) other).startIntervalType
> startIntervalType ? startIntervalType
: ((IntervalType) other)
.startIntervalType;
int endType = ((IntervalType) other).endIntervalType > endIntervalType
? ((IntervalType) other).endIntervalType
: endIntervalType;
int newType = getCombinedIntervalType(startType, endType);
long newPrecision = precision > other.precision ? precision
: other.precision;
int newScale = scale > other.scale ? scale
: other.scale;
try {
return getIntervalType(newType, startType, endType, newPrecision,
newScale, false);
} catch (RuntimeException e) {
throw Error.error(ErrorCode.X_42562);
}
}
public Type getCombinedType(Type other, int operation) {
switch (operation) {
case OpTypes.MULTIPLY :
if (other.isNumberType()) {
return getIntervalType(this, maxIntervalPrecision, scale);
}
break;
case OpTypes.DIVIDE :
if (other.isNumberType()) {
return this;
}
break;
case OpTypes.ADD :
if (other.isDateTimeType()) {
return other.getCombinedType(this, operation);
} else if (other.isIntervalType()) {
IntervalType newType =
(IntervalType) getAggregateType(other);
return getIntervalType(newType, maxIntervalPrecision, 0);
}
break;
case OpTypes.SUBTRACT :
default :
return getAggregateType(other);
}
throw Error.error(ErrorCode.X_42562);
}
public int compare(Session session, Object a, Object b) {
if (a == b) {
return 0;
}
if (a == null) {
return -1;
}
if (b == null) {
return 1;
}
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
return ((IntervalMonthData) a).compareTo(
(IntervalMonthData) b);
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
return ((IntervalSecondData) a).compareTo(
(IntervalSecondData) b);
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public Object convertToTypeLimits(SessionInterface session, Object a) {
if (a == null) {
return null;
}
if (a instanceof IntervalMonthData) {
IntervalMonthData im = (IntervalMonthData) a;
if (im.units > getIntervalValueLimit()) {
throw Error.error(ErrorCode.X_22015);
}
} else if (a instanceof IntervalSecondData) {
IntervalSecondData is = (IntervalSecondData) a;
if (is.units > getIntervalValueLimit()) {
throw Error.error(ErrorCode.X_22015);
}
// int divisor = nanoScaleFactors[scale];
// is.nanos = (is.nanos / divisor) * divisor;
}
return a;
}
public Object convertToType(SessionInterface session, Object a,
Type otherType) {
if (a == null) {
return null;
}
switch (otherType.typeCode) {
case Types.SQL_CLOB :
a = a.toString();
// fall through
case Types.SQL_CHAR :
case Types.SQL_VARCHAR :
case Types.VARCHAR_IGNORECASE : {
return session.getScanner().convertToDatetimeInterval(session,
(String) a, this);
}
case Types.TINYINT :
case Types.SQL_SMALLINT :
case Types.SQL_INTEGER :
case Types.SQL_BIGINT :
case Types.SQL_REAL :
case Types.SQL_FLOAT :
case Types.SQL_DOUBLE :
case Types.SQL_NUMERIC :
case Types.SQL_DECIMAL : {
if (a instanceof BigDecimal) {
if (!NumberType.isInLongLimits((BigDecimal) a)) {
throw Error.error(ErrorCode.X_22015);
}
}
long value = ((Number) a).longValue();
switch (this.endIntervalType) {
case Types.SQL_INTERVAL_YEAR :
return IntervalMonthData.newIntervalYear(value, this);
case Types.SQL_INTERVAL_MONTH :
return IntervalMonthData.newIntervalMonth(value, this);
case Types.SQL_INTERVAL_DAY :
return IntervalSecondData.newIntervalDay(value, this);
case Types.SQL_INTERVAL_HOUR :
return IntervalSecondData.newIntervalHour(value, this);
case Types.SQL_INTERVAL_MINUTE :
return IntervalSecondData.newIntervalMinute(value,
this);
case Types.SQL_INTERVAL_SECOND : {
int nanos = 0;
if (scale > 0 && a instanceof BigDecimal) {
nanos = (int) NumberType.scaledDecimal(
a, DTIType.maxFractionPrecision);
}
return new IntervalSecondData(value, nanos, this);
}
default :
throw Error.error(ErrorCode.X_42561);
}
}
case Types.SQL_INTERVAL_YEAR : {
long months = (((IntervalMonthData) a).units / 12) * 12;
return new IntervalMonthData(months, this);
}
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH : {
long months = ((IntervalMonthData) a).units;
return new IntervalMonthData(months, this);
}
case Types.SQL_INTERVAL_DAY : {
long seconds = ((IntervalSecondData) a).units;
seconds = (seconds / DTIType.yearToSecondFactors[2])
* DTIType.yearToSecondFactors[2];
return new IntervalSecondData(seconds, 0, this);
}
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_MINUTE : {
long seconds = ((IntervalSecondData) a).units;
seconds = (seconds / DTIType.yearToSecondFactors[endPartIndex])
* DTIType.yearToSecondFactors[endPartIndex];
return new IntervalSecondData(seconds, 0, this);
}
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND : {
long seconds = ((IntervalSecondData) a).units;
int nanos = ((IntervalSecondData) a).nanos;
if (scale == 0) {
nanos = 0;
} else {
nanos = (nanos / (DTIType.nanoScaleFactors[scale]))
* (DTIType.nanoScaleFactors[scale]);
}
return new IntervalSecondData(seconds, nanos, this);
}
default :
throw Error.error(ErrorCode.X_42561);
}
}
public Object convertToDefaultType(SessionInterface session, Object a) {
if (a == null) {
return null;
}
if (a instanceof String) {
return convertToType(null, a, Type.SQL_VARCHAR);
} else {
throw Error.error(ErrorCode.X_42561);
}
}
public String convertToString(Object a) {
if (a == null) {
return null;
}
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
return intervalMonthToString(a);
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
return intervalSecondToString(a);
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public String convertToSQLString(Object a) {
if (a == null) {
return Tokens.T_NULL;
}
StringBuffer sb = new StringBuffer(32);
sb.append(Tokens.T_INTERVAL).append(' ');
sb.append('\'').append(convertToString(a)).append('\'').append(' ');
sb.append(Tokens.SQL_INTERVAL_FIELD_NAMES[startPartIndex]);
sb.append(' ');
sb.append(Tokens.T_TO);
sb.append(' ');
sb.append(Tokens.SQL_INTERVAL_FIELD_NAMES[endPartIndex]);
return sb.toString();
}
public boolean canConvertFrom(Type otherType) {
if (otherType.typeCode == Types.SQL_ALL_TYPES) {
return true;
}
if (otherType.isCharacterType()) {
return true;
}
if (otherType.isNumberType()) {
return true;
}
if (!otherType.isIntervalType()) {
return false;
}
return !(isYearMonthIntervalType()
^ ((IntervalType) otherType).isYearMonthIntervalType());
}
public int compareToTypeRange(Object o) {
long max = precisionLimits[(int) precision];
long units;
if (o instanceof IntervalMonthData) {
units = ((IntervalMonthData) o).units;
} else if (o instanceof IntervalSecondData) {
units = ((IntervalSecondData) o).units;
} else {
return 0;
}
if (units >= max) {
return 1;
}
if (units < 0) {
if (-units >= max) {
return -1;
}
}
return 0;
}
public Object absolute(Object a) {
if (a == null) {
return null;
}
if (a instanceof IntervalMonthData) {
if (((IntervalMonthData) a).units < 0) {
return negate(a);
}
} else {
if (((IntervalSecondData) a).units < 0
|| ((IntervalSecondData) a).nanos < 0) {
return negate(a);
}
}
return a;
}
public Object negate(Object a) {
if (a == null) {
return null;
}
if (a instanceof IntervalMonthData) {
long units = ((IntervalMonthData) a).units;
return new IntervalMonthData(-units, this);
} else {
long units = ((IntervalSecondData) a).units;
int nanos = ((IntervalSecondData) a).nanos;
return new IntervalSecondData(-units, -nanos, this, true);
}
}
public Object add(Object a, Object b, Type otherType) {
if (a == null || b == null) {
return null;
}
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
long months = ((IntervalMonthData) a).units
+ ((IntervalMonthData) b).units;
return new IntervalMonthData(months, this);
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
long seconds = ((IntervalSecondData) a).units
+ ((IntervalSecondData) b).units;
long nanos = ((IntervalSecondData) a).nanos
+ ((IntervalSecondData) b).nanos;
return new IntervalSecondData(seconds, nanos, this, true);
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public Object subtract(Object a, Object b, Type otherType) {
if (a == null || b == null) {
return null;
}
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
case Types.SQL_INTERVAL_MONTH :
if (a instanceof IntervalMonthData
&& b instanceof IntervalMonthData) {
long months = ((IntervalMonthData) a).units
- ((IntervalMonthData) b).units;
return new IntervalMonthData(months, this);
} else if (a instanceof TimestampData
&& b instanceof TimestampData) {
boolean isYear = typeCode == Types.SQL_INTERVAL_YEAR;
long months =
DateTimeType.subtractMonths((TimestampData) a,
(TimestampData) b, isYear);
return new IntervalMonthData(months, this);
}
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
case Types.SQL_INTERVAL_SECOND :
if (a instanceof IntervalSecondData
&& b instanceof IntervalSecondData) {
long seconds = ((IntervalSecondData) a).units
- ((IntervalSecondData) b).units;
long nanos = ((IntervalSecondData) a).nanos
- ((IntervalSecondData) b).nanos;
return new IntervalSecondData(seconds, nanos, this, true);
} else if (a instanceof TimeData && b instanceof TimeData) {
long seconds = ((TimeData) a).getSeconds()
- ((TimeData) b).getSeconds();
long nanos = ((TimeData) a).getNanos()
- ((TimeData) b).getNanos();
return new IntervalSecondData(seconds, nanos, this, true);
} else if (a instanceof TimestampData
&& b instanceof TimestampData) {
long seconds = (((TimestampData) a).getSeconds()
- ((TimestampData) b).getSeconds());
long nanos = ((TimestampData) a).getNanos()
- ((TimestampData) b).getNanos();
return new IntervalSecondData(seconds, nanos, this, true);
}
// fall through
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public Object multiply(Object a, Object b) {
return multiplyOrDivide(a, b, false);
}
public Object divide(Object a, Object b) {
return multiplyOrDivide(a, b, true);
}
private Object multiplyOrDivide(Object a, Object b, boolean divide) {
if (a == null || b == null) {
return null;
}
if (a instanceof Number) {
Object temp = a;
a = b;
b = temp;
}
if (divide && NumberType.isZero(b)) {
throw Error.error(ErrorCode.X_22012);
}
NumberType factorType = NumberType.getNumberType(Types.SQL_DECIMAL,
40, maxFractionPrecision);
BigDecimal factor = (BigDecimal) factorType.convertToDefaultType(null,
b);
BigDecimal units;
if (isYearMonth) {
units = BigDecimal.valueOf(((IntervalMonthData) a).units);
} else {
long value =
((IntervalSecondData) a).units * DTIType.nanoScaleFactors[0]
+ ((IntervalSecondData) a).nanos;
units = BigDecimal.valueOf(value, 9);
}
BigDecimal result = divide
? (BigDecimal) factorType.divide(units, factor)
: (BigDecimal) factorType.multiply(units, factor);
if (!NumberType.isInLongLimits(result)) {
throw Error.error(ErrorCode.X_22015);
}
if (isYearMonth) {
return new IntervalMonthData(result.longValue(), this);
}
int nanos = (int) NumberType.scaledDecimal(result,
DTIType.maxFractionPrecision);
return new IntervalSecondData(result.longValue(), nanos, this, true);
}
String intervalMonthToString(Object a) {
StringBuffer sb = new StringBuffer(8);
long months = ((IntervalMonthData) a).units;
if (months < 0) {
months = -months;
sb.append('-');
}
for (int i = startPartIndex; i <= endPartIndex; i++) {
int factor = DTIType.yearToSecondFactors[i];
long part = months / factor;
if (i == startPartIndex) {
int zeros = (int) precision - getPrecisionExponent(part);
/*
for (int j = 0; j < zeros; j++) {
buffer.append('0');
}
*/
} else if (part < 10) {
sb.append('0');
}
sb.append(part);
months %= factor;
if (i < endPartIndex) {
sb.append((char) DTIType.yearToSecondSeparators[i]);
}
}
return sb.toString();
}
String intervalSecondToString(Object a) {
long seconds = ((IntervalSecondData) a).units;
int nanos = ((IntervalSecondData) a).nanos;
return intervalSecondToString(seconds, nanos, false);
}
public int precedenceDegree(Type other) {
if (other.isIntervalType()) {
int otherIndex = ((IntervalType) other).endPartIndex;
return otherIndex - endPartIndex;
}
return Integer.MIN_VALUE;
}
public int getStartIntervalType() {
return startIntervalType;
}
public int getEndIntervalType() {
return endIntervalType;
}
public static IntervalType newIntervalType(int type, long precision,
int fractionPrecision) {
int startType = getStartIntervalType(type);
int endType = getEndIntervalType(type);
int group = startType > Types.SQL_INTERVAL_MONTH
? Types.SQL_INTERVAL_SECOND
: Types.SQL_INTERVAL_MONTH;
return new IntervalType(group, type, precision, fractionPrecision,
startType, endType, false);
}
public static IntervalType getIntervalType(IntervalType type,
long precision, int fractionalPrecision) {
if (type.precision >= precision && type.scale >= fractionalPrecision) {
return type;
}
return getIntervalType(type.typeCode, precision, fractionalPrecision);
}
public static IntervalType getIntervalType(int type, long precision,
int fractionPrecision) {
int startType = getStartIntervalType(type);
int endType = getEndIntervalType(type);
return getIntervalType(type, startType, endType, precision,
fractionPrecision, false);
}
public static IntervalType getIntervalType(int startIndex, int endIndex,
long precision, int fractionPrecision) {
boolean defaultPrecision = precision == -1;
if (startIndex == -1 || endIndex == -1) {
throw Error.error(ErrorCode.X_22006);
}
if (startIndex > endIndex) {
throw Error.error(ErrorCode.X_22006);
}
if (startIndex <= DTIType.INTERVAL_MONTH_INDEX
&& endIndex > DTIType.INTERVAL_MONTH_INDEX) {
throw Error.error(ErrorCode.X_22006);
}
int startType = DTIType.intervalParts[startIndex];
int endType = DTIType.intervalParts[endIndex];
int type = DTIType.intervalTypes[startIndex][endIndex];
if (precision == 0 || precision > DTIType.maxIntervalPrecision
|| fractionPrecision > DTIType.maxFractionPrecision) {
throw Error.error(ErrorCode.X_42592);
}
if (precision == -1) {
precision = DTIType.defaultIntervalPrecision;
}
if (fractionPrecision == -1) {
fractionPrecision = endType == Types.SQL_INTERVAL_SECOND
? DTIType.defaultIntervalFractionPrecision
: 0;
}
return getIntervalType(type, startType, endType, precision,
fractionPrecision, defaultPrecision);
}
public static IntervalType getIntervalType(int type, int startType,
int endType, long precision, int fractionPrecision,
boolean defaultPrecision) {
int group = startType > Types.SQL_INTERVAL_MONTH
? Types.SQL_INTERVAL_SECOND
: Types.SQL_INTERVAL_MONTH;
if (defaultPrecision) {
return new IntervalType(group, type, precision, fractionPrecision,
startType, endType, defaultPrecision);
}
switch (type) {
case Types.SQL_INTERVAL_YEAR :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_YEAR;
}
break;
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_YEAR_TO_MONTH;
}
break;
case Types.SQL_INTERVAL_MONTH :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_MONTH;
}
break;
case Types.SQL_INTERVAL_DAY :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_DAY;
}
break;
case Types.SQL_INTERVAL_DAY_TO_HOUR :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_DAY_TO_HOUR;
}
break;
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_DAY_TO_MINUTE;
}
break;
case Types.SQL_INTERVAL_DAY_TO_SECOND :
if (precision == DTIType.defaultIntervalPrecision
&& fractionPrecision
== DTIType.defaultIntervalFractionPrecision) {
return SQL_INTERVAL_DAY_TO_SECOND;
}
break;
case Types.SQL_INTERVAL_HOUR :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_HOUR;
}
break;
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_HOUR_TO_MINUTE;
}
break;
case Types.SQL_INTERVAL_MINUTE :
if (precision == DTIType.defaultIntervalPrecision) {
return SQL_INTERVAL_MINUTE;
}
break;
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
if (precision == DTIType.defaultIntervalPrecision
&& fractionPrecision
== DTIType.defaultIntervalFractionPrecision) {
return SQL_INTERVAL_HOUR_TO_SECOND;
}
break;
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
if (precision == DTIType.defaultIntervalPrecision
&& fractionPrecision
== DTIType.defaultIntervalFractionPrecision) {
return SQL_INTERVAL_MINUTE_TO_SECOND;
}
break;
case Types.SQL_INTERVAL_SECOND :
if (precision == DTIType.defaultIntervalPrecision
&& fractionPrecision
== DTIType.defaultIntervalFractionPrecision) {
return SQL_INTERVAL_SECOND;
}
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
return new IntervalType(group, type, precision, fractionPrecision,
startType, endType, defaultPrecision);
}
public static int getStartIntervalType(int type) {
int startType;
switch (type) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
startType = Types.SQL_INTERVAL_YEAR;
break;
case Types.SQL_INTERVAL_MONTH :
startType = Types.SQL_INTERVAL_MONTH;
break;
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_DAY_TO_HOUR :
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
case Types.SQL_INTERVAL_DAY_TO_SECOND :
startType = Types.SQL_INTERVAL_DAY;
break;
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
startType = Types.SQL_INTERVAL_HOUR;
break;
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
startType = Types.SQL_INTERVAL_MINUTE;
break;
case Types.SQL_INTERVAL_SECOND :
startType = Types.SQL_INTERVAL_SECOND;
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
return startType;
}
public static int getEndIntervalType(int type) {
int endType;
switch (type) {
case Types.SQL_INTERVAL_YEAR :
endType = Types.SQL_INTERVAL_YEAR;
break;
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
endType = Types.SQL_INTERVAL_MONTH;
break;
case Types.SQL_INTERVAL_MONTH :
endType = Types.SQL_INTERVAL_MONTH;
break;
case Types.SQL_INTERVAL_DAY :
endType = Types.SQL_INTERVAL_DAY;
break;
case Types.SQL_INTERVAL_DAY_TO_HOUR :
endType = Types.SQL_INTERVAL_HOUR;
break;
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
endType = Types.SQL_INTERVAL_MINUTE;
break;
case Types.SQL_INTERVAL_DAY_TO_SECOND :
endType = Types.SQL_INTERVAL_SECOND;
break;
case Types.SQL_INTERVAL_HOUR :
endType = Types.SQL_INTERVAL_HOUR;
break;
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
endType = Types.SQL_INTERVAL_MINUTE;
break;
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
endType = Types.SQL_INTERVAL_SECOND;
break;
case Types.SQL_INTERVAL_MINUTE :
endType = Types.SQL_INTERVAL_MINUTE;
break;
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
endType = Types.SQL_INTERVAL_SECOND;
break;
case Types.SQL_INTERVAL_SECOND :
endType = Types.SQL_INTERVAL_SECOND;
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
return endType;
}
public static Type getCombinedIntervalType(IntervalType type1,
IntervalType type2) {
int startType = type2.startIntervalType > type1.startIntervalType
? type1.startIntervalType
: type2.startIntervalType;
int endType = type2.endIntervalType > type1.endIntervalType
? type2.endIntervalType
: type1.endIntervalType;
int type = getCombinedIntervalType(startType, endType);
long precision = type1.precision > type2.precision ? type1.precision
: type2.precision;
int fractionPrecision = type1.scale > type2.scale ? type1.scale
: type2.scale;
return getIntervalType(type, startType, endType, precision,
fractionPrecision, false);
}
public static int getCombinedIntervalType(int startType, int endType) {
if (startType == endType) {
return startType;
}
switch (startType) {
case Types.SQL_INTERVAL_YEAR :
if (endType == Types.SQL_INTERVAL_MONTH) {
return Types.SQL_INTERVAL_YEAR_TO_MONTH;
}
break;
case Types.SQL_INTERVAL_DAY :
switch (endType) {
case Types.SQL_INTERVAL_HOUR :
return Types.SQL_INTERVAL_DAY_TO_HOUR;
case Types.SQL_INTERVAL_MINUTE :
return Types.SQL_INTERVAL_DAY_TO_MINUTE;
case Types.SQL_INTERVAL_SECOND :
return Types.SQL_INTERVAL_DAY_TO_SECOND;
}
break;
case Types.SQL_INTERVAL_HOUR :
switch (endType) {
case Types.SQL_INTERVAL_MINUTE :
return Types.SQL_INTERVAL_HOUR_TO_MINUTE;
case Types.SQL_INTERVAL_SECOND :
return Types.SQL_INTERVAL_HOUR_TO_SECOND;
}
break;
case Types.SQL_INTERVAL_MINUTE :
if (endType == Types.SQL_INTERVAL_SECOND) {
return Types.SQL_INTERVAL_MINUTE_TO_SECOND;
}
break;
default :
}
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
long getIntervalValueLimit() {
long limit;
switch (typeCode) {
case Types.SQL_INTERVAL_YEAR :
limit = DTIType.precisionLimits[(int) precision] * 12;
break;
case Types.SQL_INTERVAL_YEAR_TO_MONTH :
limit = DTIType.precisionLimits[(int) precision] * 12;
limit += 12;
break;
case Types.SQL_INTERVAL_MONTH :
limit = DTIType.precisionLimits[(int) precision];
break;
case Types.SQL_INTERVAL_DAY :
limit = DTIType.precisionLimits[(int) precision] * 24 * 60
* 60;
break;
case Types.SQL_INTERVAL_DAY_TO_HOUR :
limit = DTIType.precisionLimits[(int) precision] * 24 * 60
* 60;
break;
case Types.SQL_INTERVAL_DAY_TO_MINUTE :
limit = DTIType.precisionLimits[(int) precision] * 24 * 60
* 60;
break;
case Types.SQL_INTERVAL_DAY_TO_SECOND :
limit = DTIType.precisionLimits[(int) precision] * 24 * 60
* 60;
break;
case Types.SQL_INTERVAL_HOUR :
limit = DTIType.precisionLimits[(int) precision] * 60 * 60;
break;
case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
limit = DTIType.precisionLimits[(int) precision] * 60 * 60;
break;
case Types.SQL_INTERVAL_HOUR_TO_SECOND :
limit = DTIType.precisionLimits[(int) precision] * 60 * 60;
break;
case Types.SQL_INTERVAL_MINUTE :
limit = DTIType.precisionLimits[(int) precision] * 60;
break;
case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
limit = DTIType.precisionLimits[(int) precision] * 60;
break;
case Types.SQL_INTERVAL_SECOND :
limit = DTIType.precisionLimits[(int) precision];
break;
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
return limit;
}
public int getPart(Session session, Object interval, int part) {
long units;
switch (part) {
case Types.SQL_INTERVAL_YEAR :
return (int) (((IntervalMonthData) interval).units / 12);
case Types.SQL_INTERVAL_MONTH :
units = ((IntervalMonthData) interval).units;
return part == startIntervalType ? (int) units
: (int) (units % 12);
case Types.SQL_INTERVAL_DAY :
return (int) (((IntervalSecondData) interval).units
/ (24 * 60 * 60));
case Types.SQL_INTERVAL_HOUR : {
units = ((IntervalSecondData) interval).units / (60 * 60);
return part == startIntervalType ? (int) units
: (int) (units % 24);
}
case Types.SQL_INTERVAL_MINUTE : {
units = ((IntervalSecondData) interval).units / 60;
return part == startIntervalType ? (int) units
: (int) (units % 60);
}
case Types.SQL_INTERVAL_SECOND : {
units = ((IntervalSecondData) interval).units;
return part == startIntervalType ? (int) units
: (int) (units % 60);
}
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
public long getSeconds(Object interval) {
return ((IntervalSecondData) interval).units;
}
public BigDecimal getSecondPart(Object interval) {
long seconds = ((IntervalSecondData) interval).units;
if (typeCode != Types.SQL_INTERVAL_SECOND) {
seconds %= 60;
}
int nanos = ((IntervalSecondData) interval).nanos;
return getSecondPart(seconds, nanos);
}
public long convertToLong(Object interval) {
switch (endIntervalType) {
case Types.SQL_INTERVAL_YEAR :
case Types.SQL_INTERVAL_MONTH :
long months = ((IntervalMonthData) interval).units;
return (months / DTIType.yearToSecondFactors[endPartIndex]);
case Types.SQL_INTERVAL_DAY :
case Types.SQL_INTERVAL_HOUR :
case Types.SQL_INTERVAL_MINUTE :
case Types.SQL_INTERVAL_SECOND : {
long seconds = ((IntervalSecondData) interval).units;
return (seconds / DTIType.yearToSecondFactors[endPartIndex]);
}
default :
throw Error.runtimeError(ErrorCode.U_S0500, "IntervalType");
}
}
}