/*
* Copyright 2004-2023 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (https://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package org.h2.value;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.lang.ref.SoftReference;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.h2.api.ErrorCode;
import org.h2.api.IntervalQualifier;
import org.h2.engine.CastDataProvider;
import org.h2.engine.Mode.CharPadding;
import org.h2.engine.SysProperties;
import org.h2.message.DbException;
import org.h2.store.DataHandler;
import org.h2.util.Bits;
import org.h2.util.DateTimeUtils;
import org.h2.util.HasSQL;
import org.h2.util.IntervalUtils;
import org.h2.util.JdbcUtils;
import org.h2.util.MathUtils;
import org.h2.util.StringUtils;
import org.h2.util.geometry.GeoJsonUtils;
import org.h2.util.json.JsonConstructorUtils;
import org.h2.value.lob.LobData;
import org.h2.value.lob.LobDataDatabase;
import org.h2.value.lob.LobDataInMemory;
/**
* This is the base class for all value classes.
* It provides conversion and comparison methods.
*
* @author Thomas Mueller
* @author Noel Grandin
* @author Nicolas Fortin, Atelier SIG, IRSTV FR CNRS 24888
*/
public abstract class Value extends VersionedValue<Value> implements HasSQL, Typed {
/**
* The data type is unknown at this time.
*/
public static final int UNKNOWN = -1;
/**
* The value type for NULL.
*/
public static final int NULL = UNKNOWN + 1;
/**
* The value type for CHARACTER values.
*/
public static final int CHAR = NULL + 1;
/**
* The value type for CHARACTER VARYING values.
*/
public static final int VARCHAR = CHAR + 1;
/**
* The value type for CHARACTER LARGE OBJECT values.
*/
public static final int CLOB = VARCHAR + 1;
/**
* The value type for VARCHAR_IGNORECASE values.
*/
public static final int VARCHAR_IGNORECASE = CLOB + 1;
/**
* The value type for BINARY values.
*/
public static final int BINARY = VARCHAR_IGNORECASE + 1;
/**
* The value type for BINARY VARYING values.
*/
public static final int VARBINARY = BINARY + 1;
/**
* The value type for BINARY LARGE OBJECT values.
*/
public static final int BLOB = VARBINARY + 1;
/**
* The value type for BOOLEAN values.
*/
public static final int BOOLEAN = BLOB + 1;
/**
* The value type for TINYINT values.
*/
public static final int TINYINT = BOOLEAN + 1;
/**
* The value type for SMALLINT values.
*/
public static final int SMALLINT = TINYINT + 1;
/**
* The value type for INTEGER values.
*/
public static final int INTEGER = SMALLINT + 1;
/**
* The value type for BIGINT values.
*/
public static final int BIGINT = INTEGER + 1;
/**
* The value type for NUMERIC values.
*/
public static final int NUMERIC = BIGINT + 1;
/**
* The value type for REAL values.
*/
public static final int REAL = NUMERIC + 1;
/**
* The value type for DOUBLE PRECISION values.
*/
public static final int DOUBLE = REAL + 1;
/**
* The value type for DECFLOAT values.
*/
public static final int DECFLOAT = DOUBLE + 1;
/**
* The value type for DATE values.
*/
public static final int DATE = DECFLOAT + 1;
/**
* The value type for TIME values.
*/
public static final int TIME = DATE + 1;
/**
* The value type for TIME WITH TIME ZONE values.
*/
public static final int TIME_TZ = TIME + 1;
/**
* The value type for TIMESTAMP values.
*/
public static final int TIMESTAMP = TIME_TZ + 1;
/**
* The value type for TIMESTAMP WITH TIME ZONE values.
*/
public static final int TIMESTAMP_TZ = TIMESTAMP + 1;
/**
* The value type for {@code INTERVAL YEAR} values.
*/
public static final int INTERVAL_YEAR = TIMESTAMP_TZ + 1;
/**
* The value type for {@code INTERVAL MONTH} values.
*/
public static final int INTERVAL_MONTH = INTERVAL_YEAR + 1;
/**
* The value type for {@code INTERVAL DAY} values.
*/
public static final int INTERVAL_DAY = INTERVAL_MONTH + 1;
/**
* The value type for {@code INTERVAL HOUR} values.
*/
public static final int INTERVAL_HOUR = INTERVAL_DAY + 1;
/**
* The value type for {@code INTERVAL MINUTE} values.
*/
public static final int INTERVAL_MINUTE = INTERVAL_HOUR + 1;
/**
* The value type for {@code INTERVAL SECOND} values.
*/
public static final int INTERVAL_SECOND = INTERVAL_MINUTE + 1;
/**
* The value type for {@code INTERVAL YEAR TO MONTH} values.
*/
public static final int INTERVAL_YEAR_TO_MONTH = INTERVAL_SECOND + 1;
/**
* The value type for {@code INTERVAL DAY TO HOUR} values.
*/
public static final int INTERVAL_DAY_TO_HOUR = INTERVAL_YEAR_TO_MONTH + 1;
/**
* The value type for {@code INTERVAL DAY TO MINUTE} values.
*/
public static final int INTERVAL_DAY_TO_MINUTE = INTERVAL_DAY_TO_HOUR + 1;
/**
* The value type for {@code INTERVAL DAY TO SECOND} values.
*/
public static final int INTERVAL_DAY_TO_SECOND = INTERVAL_DAY_TO_MINUTE + 1;
/**
* The value type for {@code INTERVAL HOUR TO MINUTE} values.
*/
public static final int INTERVAL_HOUR_TO_MINUTE = INTERVAL_DAY_TO_SECOND + 1;
/**
* The value type for {@code INTERVAL HOUR TO SECOND} values.
*/
public static final int INTERVAL_HOUR_TO_SECOND = INTERVAL_HOUR_TO_MINUTE + 1;
/**
* The value type for {@code INTERVAL MINUTE TO SECOND} values.
*/
public static final int INTERVAL_MINUTE_TO_SECOND = INTERVAL_HOUR_TO_SECOND + 1;
/**
* The value type for JAVA_OBJECT values.
*/
public static final int JAVA_OBJECT = INTERVAL_MINUTE_TO_SECOND + 1;
/**
* The value type for ENUM values.
*/
public static final int ENUM = JAVA_OBJECT + 1;
/**
* The value type for string values with a fixed size.
*/
public static final int GEOMETRY = ENUM + 1;
/**
* The value type for JSON values.
*/
public static final int JSON = GEOMETRY + 1;
/**
* The value type for UUID values.
*/
public static final int UUID = JSON + 1;
/**
* The value type for ARRAY values.
*/
public static final int ARRAY = UUID + 1;
/**
* The value type for ROW values.
*/
public static final int ROW = ARRAY + 1;
/**
* The number of value types.
*/
public static final int TYPE_COUNT = ROW + 1;
/**
* Group for untyped NULL data type.
*/
static final int GROUP_NULL = 0;
/**
* Group for character string data types.
*/
static final int GROUP_CHARACTER_STRING = GROUP_NULL + 1;
/**
* Group for binary string data types.
*/
static final int GROUP_BINARY_STRING = GROUP_CHARACTER_STRING + 1;
/**
* Group for BINARY data type.
*/
static final int GROUP_BOOLEAN = GROUP_BINARY_STRING + 1;
/**
* Group for numeric data types.
*/
static final int GROUP_NUMERIC = GROUP_BOOLEAN + 1;
/**
* Group for datetime data types.
*/
static final int GROUP_DATETIME = GROUP_NUMERIC + 1;
/**
* Group for year-month interval data types.
*/
static final int GROUP_INTERVAL_YM = GROUP_DATETIME + 1;
/**
* Group for day-time interval data types.
*/
static final int GROUP_INTERVAL_DT = GROUP_INTERVAL_YM + 1;
/**
* Group for other data types (JAVA_OBJECT, UUID, GEOMETRY, ENUM, JSON).
*/
static final int GROUP_OTHER = GROUP_INTERVAL_DT + 1;
/**
* Group for collection data types (ARRAY, ROW).
*/
static final int GROUP_COLLECTION = GROUP_OTHER + 1;
static final byte GROUPS[] = {
// NULL
GROUP_NULL,
// CHAR, VARCHAR, CLOB, VARCHAR_IGNORECASE
GROUP_CHARACTER_STRING, GROUP_CHARACTER_STRING, GROUP_CHARACTER_STRING, GROUP_CHARACTER_STRING,
// BINARY, VARBINARY, BLOB
GROUP_BINARY_STRING, GROUP_BINARY_STRING, GROUP_BINARY_STRING,
// BOOLEAN
GROUP_BOOLEAN,
// TINYINT, SMALLINT, INTEGER, BIGINT, NUMERIC, REAL, DOUBLE, DECFLOAT
GROUP_NUMERIC, GROUP_NUMERIC, GROUP_NUMERIC, GROUP_NUMERIC, GROUP_NUMERIC, GROUP_NUMERIC, GROUP_NUMERIC,
GROUP_NUMERIC,
// DATE, TIME, TIME_TZ, TIMESTAMP, TIMESTAMP_TZ
GROUP_DATETIME, GROUP_DATETIME, GROUP_DATETIME, GROUP_DATETIME, GROUP_DATETIME,
// INTERVAL_YEAR, INTERVAL_MONTH
GROUP_INTERVAL_YM, GROUP_INTERVAL_YM,
// INTERVAL_DAY, INTERVAL_HOUR, INTERVAL_MINUTE, INTERVAL_SECOND
GROUP_INTERVAL_DT, GROUP_INTERVAL_DT, GROUP_INTERVAL_DT, GROUP_INTERVAL_DT,
// INTERVAL_YEAR_TO_MONTH
GROUP_INTERVAL_YM,
// INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
// INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR_TO_MINUTE,
// INTERVAL_HOUR_TO_SECOND, INTERVAL_MINUTE_TO_SECOND
GROUP_INTERVAL_DT, GROUP_INTERVAL_DT, GROUP_INTERVAL_DT, GROUP_INTERVAL_DT, GROUP_INTERVAL_DT,
GROUP_INTERVAL_DT,
// JAVA_OBJECT, ENUM, GEOMETRY, JSON, UUID
GROUP_OTHER, GROUP_OTHER, GROUP_OTHER, GROUP_OTHER, GROUP_OTHER,
// ARRAY, ROW
GROUP_COLLECTION, GROUP_COLLECTION,
//
};
private static final String NAMES[] = {
"UNKNOWN",
"NULL", //
"CHARACTER", "CHARACTER VARYING", "CHARACTER LARGE OBJECT", "VARCHAR_IGNORECASE", //
"BINARY", "BINARY VARYING", "BINARY LARGE OBJECT", //
"BOOLEAN", //
"TINYINT", "SMALLINT", "INTEGER", "BIGINT", //
"NUMERIC", "REAL", "DOUBLE PRECISION", "DECFLOAT", //
"DATE", "TIME", "TIME WITH TIME ZONE", "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", //
"INTERVAL YEAR", "INTERVAL MONTH", //
"INTERVAL DAY", "INTERVAL HOUR", "INTERVAL MINUTE", "INTERVAL SECOND", //
"INTERVAL YEAR TO MONTH", //
"INTERVAL DAY TO HOUR", "INTERVAL DAY TO MINUTE", "INTERVAL DAY TO SECOND", //
"INTERVAL HOUR TO MINUTE", "INTERVAL HOUR TO SECOND", "INTERVAL MINUTE TO SECOND", //
"JAVA_OBJECT", "ENUM", "GEOMETRY", "JSON", "UUID", //
"ARRAY", "ROW", //
};
/**
* Empty array of values.
*/
public static final Value[] EMPTY_VALUES = new Value[0];
private static SoftReference<Value[]> softCache;
static final BigDecimal MAX_LONG_DECIMAL = BigDecimal.valueOf(Long.MAX_VALUE);
/**
* The smallest Long value, as a BigDecimal.
*/
public static final BigDecimal MIN_LONG_DECIMAL = BigDecimal.valueOf(Long.MIN_VALUE);
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*/
static final int CONVERT_TO = 0;
/**
* Cast a value to the specified type. The scale is set if applicable. The
* value is truncated to a required precision.
*/
static final int CAST_TO = 1;
/**
* Cast a value to the specified type for assignment. The scale is set if
* applicable. If precision is too large an exception is thrown.
*/
static final int ASSIGN_TO = 2;
/**
* Returns name of the specified data type.
*
* @param valueType
* the value type
* @return the name
*/
public static String getTypeName(int valueType) {
return NAMES[valueType + 1];
}
/**
* Check the range of the parameters.
*
* @param zeroBasedOffset the offset (0 meaning no offset)
* @param length the length of the target
* @param dataSize the length of the source
*/
static void rangeCheck(long zeroBasedOffset, long length, long dataSize) {
if ((zeroBasedOffset | length) < 0 || length > dataSize - zeroBasedOffset) {
if (zeroBasedOffset < 0 || zeroBasedOffset > dataSize) {
throw DbException.getInvalidValueException("offset", zeroBasedOffset + 1);
}
throw DbException.getInvalidValueException("length", length);
}
}
@Override
public abstract TypeInfo getType();
/**
* Get the value type.
*
* @return the value type
*/
public abstract int getValueType();
/**
* Get the memory used by this object.
*
* @return the memory used in bytes
*/
public int getMemory() {
/*
* Java 11 with -XX:-UseCompressedOops for all values up to ValueBigint
* and ValueDouble.
*/
return 24;
}
@Override
public abstract int hashCode();
/**
* Check if the two values have the same hash code. No data conversion is
* made; this method returns false if the other object is not of the same
* class. For some values, compareTo may return 0 even if equals return
* false. Example: ValueDecimal 0.0 and 0.00.
*
* @param other the other value
* @return true if they are equal
*/
@Override
public abstract boolean equals(Object other);
/**
* Get the higher value order type of two value types. If values need to be
* converted to match the other operands value type, the value with the
* lower order is converted to the value with the higher order.
*
* @param t1 the first value type
* @param t2 the second value type
* @return the higher value type of the two
*/
public static int getHigherOrder(int t1, int t2) {
if (t1 == t2) {
if (t1 == UNKNOWN) {
throw DbException.get(ErrorCode.UNKNOWN_DATA_TYPE_1, "?, ?");
}
return t1;
}
if (t1 < t2) {
int t = t1;
t1 = t2;
t2 = t;
}
if (t1 == UNKNOWN) {
if (t2 == NULL) {
throw DbException.get(ErrorCode.UNKNOWN_DATA_TYPE_1, "?, NULL");
}
return t2;
} else if (t2 == UNKNOWN) {
if (t1 == NULL) {
throw DbException.get(ErrorCode.UNKNOWN_DATA_TYPE_1, "NULL, ?");
}
return t1;
}
if (t2 == NULL) {
return t1;
}
return getHigherOrderKnown(t1, t2);
}
private static int getHigherOrderNonNull(int t1, int t2) {
if (t1 == t2) {
return t1;
}
if (t1 < t2) {
int t = t1;
t1 = t2;
t2 = t;
}
return getHigherOrderKnown(t1, t2);
}
static int getHigherOrderKnown(int t1, int t2) {
int g1 = GROUPS[t1], g2 = GROUPS[t2];
switch (g1) {
case GROUP_BOOLEAN:
if (g2 == GROUP_BINARY_STRING) {
throw getDataTypeCombinationException(BOOLEAN, t2);
}
break;
case GROUP_NUMERIC:
return getHigherNumeric(t1, t2, g2);
case GROUP_DATETIME:
return getHigherDateTime(t1, t2, g2);
case GROUP_INTERVAL_YM:
return getHigherIntervalYearMonth(t1, t2, g2);
case GROUP_INTERVAL_DT:
return getHigherIntervalDayTime(t1, t2, g2);
case GROUP_OTHER:
return getHigherOther(t1, t2, g2);
}
return t1;
}
private static int getHigherNumeric(int t1, int t2, int g2) {
if (g2 == GROUP_NUMERIC) {
switch (t1) {
case REAL:
switch (t2) {
case INTEGER:
return DOUBLE;
case BIGINT:
case NUMERIC:
return DECFLOAT;
}
break;
case DOUBLE:
switch (t2) {
case BIGINT:
case NUMERIC:
return DECFLOAT;
}
break;
}
} else if (g2 == GROUP_BINARY_STRING) {
throw getDataTypeCombinationException(t1, t2);
}
return t1;
}
private static int getHigherDateTime(int t1, int t2, int g2) {
if (g2 == GROUP_CHARACTER_STRING) {
return t1;
}
if (g2 != GROUP_DATETIME) {
throw getDataTypeCombinationException(t1, t2);
}
switch (t1) {
case TIME:
if (t2 == DATE) {
return TIMESTAMP;
}
break;
case TIME_TZ:
if (t2 == DATE) {
return TIMESTAMP_TZ;
}
break;
case TIMESTAMP:
if (t2 == TIME_TZ) {
return TIMESTAMP_TZ;
}
}
return t1;
}
private static int getHigherIntervalYearMonth(int t1, int t2, int g2) {
switch (g2) {
case GROUP_INTERVAL_YM:
if (t1 == INTERVAL_MONTH && t2 == INTERVAL_YEAR) {
return INTERVAL_YEAR_TO_MONTH;
}
//$FALL-THROUGH$
case GROUP_CHARACTER_STRING:
case GROUP_NUMERIC:
return t1;
default:
throw getDataTypeCombinationException(t1, t2);
}
}
private static int getHigherIntervalDayTime(int t1, int t2, int g2) {
switch (g2) {
case GROUP_INTERVAL_DT:
break;
case GROUP_CHARACTER_STRING:
case GROUP_NUMERIC:
return t1;
default:
throw getDataTypeCombinationException(t1, t2);
}
switch (t1) {
case INTERVAL_HOUR:
return INTERVAL_DAY_TO_HOUR;
case INTERVAL_MINUTE:
if (t2 == INTERVAL_DAY) {
return INTERVAL_DAY_TO_MINUTE;
}
return INTERVAL_HOUR_TO_MINUTE;
case INTERVAL_SECOND:
if (t2 == INTERVAL_DAY) {
return INTERVAL_DAY_TO_SECOND;
}
if (t2 == INTERVAL_HOUR) {
return INTERVAL_HOUR_TO_SECOND;
}
return INTERVAL_MINUTE_TO_SECOND;
case INTERVAL_DAY_TO_HOUR:
if (t2 == INTERVAL_MINUTE) {
return INTERVAL_DAY_TO_MINUTE;
}
if (t2 == INTERVAL_SECOND) {
return INTERVAL_DAY_TO_SECOND;
}
break;
case INTERVAL_DAY_TO_MINUTE:
if (t2 == INTERVAL_SECOND) {
return INTERVAL_DAY_TO_SECOND;
}
break;
case INTERVAL_HOUR_TO_MINUTE:
switch (t2) {
case INTERVAL_DAY:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
return INTERVAL_DAY_TO_MINUTE;
case INTERVAL_SECOND:
return INTERVAL_HOUR_TO_SECOND;
case INTERVAL_DAY_TO_SECOND:
return INTERVAL_DAY_TO_SECOND;
}
break;
case INTERVAL_HOUR_TO_SECOND:
switch (t2) {
case INTERVAL_DAY:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
return INTERVAL_DAY_TO_SECOND;
}
break;
case INTERVAL_MINUTE_TO_SECOND:
switch (t2) {
case INTERVAL_DAY:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
return INTERVAL_DAY_TO_SECOND;
case INTERVAL_HOUR:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
return INTERVAL_HOUR_TO_SECOND;
}
}
return t1;
}
private static int getHigherOther(int t1, int t2, int g2) {
switch (t1) {
case JAVA_OBJECT:
if (g2 != GROUP_BINARY_STRING) {
throw getDataTypeCombinationException(t1, t2);
}
break;
case ENUM:
if (g2 != GROUP_CHARACTER_STRING && (g2 != GROUP_NUMERIC || t2 > INTEGER)) {
throw getDataTypeCombinationException(t1, t2);
}
break;
case GEOMETRY:
if (g2 != GROUP_CHARACTER_STRING && g2 != GROUP_BINARY_STRING) {
throw getDataTypeCombinationException(t1, t2);
}
break;
case JSON:
switch (g2) {
case GROUP_DATETIME:
case GROUP_INTERVAL_YM:
case GROUP_INTERVAL_DT:
case GROUP_OTHER:
throw getDataTypeCombinationException(t1, t2);
}
break;
case UUID:
switch (g2) {
case GROUP_CHARACTER_STRING:
case GROUP_BINARY_STRING:
break;
case GROUP_OTHER:
if (t2 == JAVA_OBJECT) {
break;
}
//$FALL-THROUGH$
default:
throw getDataTypeCombinationException(t1, t2);
}
}
return t1;
}
private static DbException getDataTypeCombinationException(int t1, int t2) {
return DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, getTypeName(t1) + ", " + getTypeName(t2));
}
/**
* Check if a value is in the cache that is equal to this value. If yes,
* this value should be used to save memory. If the value is not in the
* cache yet, it is added.
*
* @param v the value to look for
* @return the value in the cache or the value passed
*/
static Value cache(Value v) {
if (SysProperties.OBJECT_CACHE) {
int hash = v.hashCode();
Value[] cache;
if (softCache == null || (cache = softCache.get()) == null) {
cache = new Value[SysProperties.OBJECT_CACHE_SIZE];
softCache = new SoftReference<>(cache);
}
int index = hash & (SysProperties.OBJECT_CACHE_SIZE - 1);
Value cached = cache[index];
if (cached != null) {
if (cached.getValueType() == v.getValueType() && v.equals(cached)) {
// cacheHit++;
return cached;
}
}
// cacheMiss++;
// cache[cacheCleaner] = null;
// cacheCleaner = (cacheCleaner + 1) &
// (Constants.OBJECT_CACHE_SIZE - 1);
cache[index] = v;
}
return v;
}
/**
* Clear the value cache. Used for testing.
*/
public static void clearCache() {
softCache = null;
}
/**
* Get the value as a string.
*
* @return the string
*/
public abstract String getString();
public Reader getReader() {
return new StringReader(getString());
}
/**
* Get the reader
*
* @param oneBasedOffset the offset (1 means no offset)
* @param length the requested length
* @return the new reader
*/
public Reader getReader(long oneBasedOffset, long length) {
String string = getString();
long zeroBasedOffset = oneBasedOffset - 1;
rangeCheck(zeroBasedOffset, length, string.length());
int offset = (int) zeroBasedOffset;
return new StringReader(string.substring(offset, offset + (int) length));
}
public byte[] getBytes() {
throw getDataConversionError(VARBINARY);
}
public byte[] getBytesNoCopy() {
return getBytes();
}
public InputStream getInputStream() {
return new ByteArrayInputStream(getBytesNoCopy());
}
/**
* Get the input stream
*
* @param oneBasedOffset the offset (1 means no offset)
* @param length the requested length
* @return the new input stream
*/
public InputStream getInputStream(long oneBasedOffset, long length) {
byte[] bytes = getBytesNoCopy();
long zeroBasedOffset = oneBasedOffset - 1;
rangeCheck(zeroBasedOffset, length, bytes.length);
return new ByteArrayInputStream(bytes, (int) zeroBasedOffset, (int) length);
}
/**
* Returns this value as a Java {@code boolean} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code BOOLEAN}
* @return value
* @see #isTrue()
* @see #isFalse()
*/
public boolean getBoolean() {
return convertToBoolean().getBoolean();
}
/**
* Returns this value as a Java {@code byte} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code TINYINT}
* @return value
*/
public byte getByte() {
return convertToTinyint(null).getByte();
}
/**
* Returns this value as a Java {@code short} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code SMALLINT}
* @return value
*/
public short getShort() {
return convertToSmallint(null).getShort();
}
/**
* Returns this value as a Java {@code int} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code INTEGER}
* @return value
*/
public int getInt() {
return convertToInt(null).getInt();
}
/**
* Returns this value as a Java {@code long} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code BIGINT}
* @return value
*/
public long getLong() {
return convertToBigint(null).getLong();
}
public BigDecimal getBigDecimal() {
throw getDataConversionError(NUMERIC);
}
/**
* Returns this value as a Java {@code float} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code REAL}
* @return value
*/
public float getFloat() {
throw getDataConversionError(REAL);
}
/**
* Returns this value as a Java {@code double} value.
*
* @throws DbException
* if this value is {@code NULL} or cannot be casted to
* {@code DOUBLE PRECISION}
* @return value
*/
public double getDouble() {
throw getDataConversionError(DOUBLE);
}
/**
* Add a value and return the result.
*
* @param v the value to add
* @return the result
*/
public Value add(@SuppressWarnings("unused") Value v) {
throw getUnsupportedExceptionForOperation("+");
}
public int getSignum() {
throw getUnsupportedExceptionForOperation("SIGNUM");
}
/**
* Return -value if this value support arithmetic operations.
*
* @return the negative
*/
public Value negate() {
throw getUnsupportedExceptionForOperation("NEG");
}
/**
* Subtract a value and return the result.
*
* @param v the value to subtract
* @return the result
*/
public Value subtract(@SuppressWarnings("unused") Value v) {
throw getUnsupportedExceptionForOperation("-");
}
/**
* Divide by a value and return the result.
*
* @param v the divisor
* @param quotientType the type of quotient (used only to read precision and scale
* when applicable)
* @return the result
*/
public Value divide(@SuppressWarnings("unused") Value v, TypeInfo quotientType) {
throw getUnsupportedExceptionForOperation("/");
}
/**
* Multiply with a value and return the result.
*
* @param v the value to multiply with
* @return the result
*/
public Value multiply(@SuppressWarnings("unused") Value v) {
throw getUnsupportedExceptionForOperation("*");
}
/**
* Take the modulus with a value and return the result.
*
* @param v the value to take the modulus with
* @return the result
*/
public Value modulus(@SuppressWarnings("unused") Value v) {
throw getUnsupportedExceptionForOperation("%");
}
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*
* @param targetType the type of the returned value
* @return the converted value
*/
public final Value convertTo(int targetType) {
return convertTo(targetType, null);
}
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*
* @param targetType the type of the returned value
* @return the converted value
*/
public final Value convertTo(TypeInfo targetType) {
return convertTo(targetType, null, CONVERT_TO, null);
}
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*
* @param targetType the type of the returned value
* @param provider the cast information provider
* @return the converted value
*/
public final Value convertTo(int targetType, CastDataProvider provider) {
switch (targetType) {
case ARRAY:
return convertToAnyArray(provider);
case ROW:
return convertToAnyRow();
default:
return convertTo(TypeInfo.getTypeInfo(targetType), provider, CONVERT_TO, null);
}
}
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*
* @param targetType
* the type of the returned value
* @param provider
* the cast information provider
* @return the converted value
*/
public final Value convertTo(TypeInfo targetType, CastDataProvider provider) {
return convertTo(targetType, provider, CONVERT_TO, null);
}
/**
* Convert a value to the specified type without taking scale and precision
* into account.
*
* @param targetType
* the type of the returned value
* @param provider
* the cast information provider
* @param column
* the column, used to improve the error message if conversion
* fails
* @return the converted value
*/
public final Value convertTo(TypeInfo targetType, CastDataProvider provider, Object column) {
return convertTo(targetType, provider, CONVERT_TO, column);
}
/**
* Convert this value to JSON data type.
*
* @return a JSON value
*/
public final ValueJson convertToAnyJson() {
return this != ValueNull.INSTANCE ? convertToJson(TypeInfo.TYPE_JSON, CONVERT_TO, null) : ValueJson.NULL;
}
/**
* Convert this value to any ARRAY data type.
*
* @param provider
* the cast information provider
* @return a row value
*/
public final ValueArray convertToAnyArray(CastDataProvider provider) {
if (getValueType() == Value.ARRAY) {
return (ValueArray) this;
}
return ValueArray.get(this.getType(), new Value[] { this }, provider);
}
/**
* Convert this value to any ROW data type.
*
* @return a row value
*/
public final ValueRow convertToAnyRow() {
if (getValueType() == Value.ROW) {
return (ValueRow) this;
}
return ValueRow.get(new Value[] { this });
}
/**
* Cast a value to the specified type. The scale is set if applicable. The
* value is truncated to the required precision.
*
* @param targetType
* the type of the returned value
* @param provider
* the cast information provider
* @return the converted value
*/
public final Value castTo(TypeInfo targetType, CastDataProvider provider) {
return convertTo(targetType, provider, CAST_TO, null);
}
/**
* Cast a value to the specified type for assignment. The scale is set if
* applicable. If precision is too large an exception is thrown.
*
* @param targetType
* the type of the returned value
* @param provider
* the cast information provider
* @param column
* the column, used to improve the error message if conversion
* fails
* @return the converted value
*/
public final Value convertForAssignTo(TypeInfo targetType, CastDataProvider provider, Object column) {
return convertTo(targetType, provider, ASSIGN_TO, column);
}
/**
* Convert a value to the specified type.
*
* @param targetType the type of the returned value
* @param provider the cast information provider
* @param conversionMode conversion mode
* @param column the column (if any), used to improve the error message if conversion fails
* @return the converted value
*/
private Value convertTo(TypeInfo targetType, CastDataProvider provider, int conversionMode, Object column) {
int valueType = getValueType(), targetValueType;
if (valueType == NULL
|| valueType == (targetValueType = targetType.getValueType()) && conversionMode == CONVERT_TO
&& targetType.getExtTypeInfo() == null && valueType != CHAR) {
return this;
}
switch (targetValueType) {
case NULL:
return ValueNull.INSTANCE;
case CHAR:
return convertToChar(targetType, provider, conversionMode, column);
case VARCHAR:
return convertToVarchar(targetType, provider, conversionMode, column);
case CLOB:
return convertToClob(targetType, conversionMode, column);
case VARCHAR_IGNORECASE:
return convertToVarcharIgnoreCase(targetType, conversionMode, column);
case BINARY:
return convertToBinary(targetType, conversionMode, column);
case VARBINARY:
return convertToVarbinary(targetType, conversionMode, column);
case BLOB:
return convertToBlob(targetType, conversionMode, column);
case BOOLEAN:
return convertToBoolean();
case TINYINT:
return convertToTinyint(column);
case SMALLINT:
return convertToSmallint(column);
case INTEGER:
return convertToInt(column);
case BIGINT:
return convertToBigint(column);
case NUMERIC:
return convertToNumeric(targetType, provider, conversionMode, column);
case REAL:
return convertToReal();
case DOUBLE:
return convertToDouble();
case DECFLOAT:
return convertToDecfloat(targetType, conversionMode);
case DATE:
return convertToDate(provider);
case TIME:
return convertToTime(targetType, provider, conversionMode);
case TIME_TZ:
return convertToTimeTimeZone(targetType, provider, conversionMode);
case TIMESTAMP:
return convertToTimestamp(targetType, provider, conversionMode);
case TIMESTAMP_TZ:
return convertToTimestampTimeZone(targetType, provider, conversionMode);
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_YEAR_TO_MONTH:
return convertToIntervalYearMonth(targetType, conversionMode, column);
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
return convertToIntervalDayTime(targetType, conversionMode, column);
case JAVA_OBJECT:
return convertToJavaObject(targetType, conversionMode, column);
case ENUM:
return convertToEnum((ExtTypeInfoEnum) targetType.getExtTypeInfo(), provider);
case GEOMETRY:
return convertToGeometry((ExtTypeInfoGeometry) targetType.getExtTypeInfo());
case JSON:
return convertToJson(targetType, conversionMode, column);
case UUID:
return convertToUuid();
case ARRAY:
return convertToArray(targetType, provider, conversionMode, column);
case ROW:
return convertToRow(targetType, provider, conversionMode, column);
default:
throw getDataConversionError(targetValueType);
}
}
/**
* Converts this value to a CHAR value. May not be called on a NULL value.
*
* @return a CHAR value.
*/
public ValueChar convertToChar() {
return convertToChar(TypeInfo.getTypeInfo(CHAR), null, CONVERT_TO, null);
}
private ValueChar convertToChar(TypeInfo targetType, CastDataProvider provider, int conversionMode, //
Object column) {
int valueType = getValueType();
switch (valueType) {
case BLOB:
case JAVA_OBJECT:
throw getDataConversionError(targetType.getValueType());
}
String s = getString();
int length = s.length(), newLength = length;
if (conversionMode == CONVERT_TO) {
while (newLength > 0 && s.charAt(newLength - 1) == ' ') {
newLength--;
}
} else {
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (provider == null || provider.getMode().charPadding == CharPadding.ALWAYS) {
if (newLength != p) {
if (newLength < p) {
return ValueChar.get(StringUtils.pad(s, p, null, true));
} else if (conversionMode == CAST_TO) {
newLength = p;
} else {
do {
if (s.charAt(--newLength) != ' ') {
throw getValueTooLongException(targetType, column);
}
} while (newLength > p);
}
}
} else {
if (conversionMode == CAST_TO && newLength > p) {
newLength = p;
}
while (newLength > 0 && s.charAt(newLength - 1) == ' ') {
newLength--;
}
if (conversionMode == ASSIGN_TO && newLength > p) {
throw getValueTooLongException(targetType, column);
}
}
}
if (length != newLength) {
s = s.substring(0, newLength);
} else if (valueType == CHAR) {
return (ValueChar) this;
}
return ValueChar.get(s);
}
private Value convertToVarchar(TypeInfo targetType, CastDataProvider provider, int conversionMode, Object column) {
int valueType = getValueType();
switch (valueType) {
case BLOB:
case JAVA_OBJECT:
throw getDataConversionError(targetType.getValueType());
}
if (conversionMode != CONVERT_TO) {
String s = getString();
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (s.length() > p) {
if (conversionMode != CAST_TO) {
throw getValueTooLongException(targetType, column);
}
return ValueVarchar.get(s.substring(0, p), provider);
}
}
return valueType == Value.VARCHAR ? this : ValueVarchar.get(getString(), provider);
}
private ValueClob convertToClob(TypeInfo targetType, int conversionMode, Object column) {
ValueClob v;
switch (getValueType()) {
case CLOB:
v = (ValueClob) this;
break;
case JAVA_OBJECT:
throw getDataConversionError(targetType.getValueType());
case BLOB: {
LobData data = ((ValueBlob) this).lobData;
// Try to reuse the array, if possible
if (data instanceof LobDataInMemory) {
byte[] small = ((LobDataInMemory) data).getSmall();
byte[] bytes = new String(small, StandardCharsets.UTF_8).getBytes(StandardCharsets.UTF_8);
if (Arrays.equals(bytes, small)) {
bytes = small;
}
v = ValueClob.createSmall(bytes);
break;
} else if (data instanceof LobDataDatabase) {
v = data.getDataHandler().getLobStorage().createClob(getReader(), -1);
break;
}
}
//$FALL-THROUGH$
default:
v = ValueClob.createSmall(getString());
}
if (conversionMode != CONVERT_TO) {
if (conversionMode == CAST_TO) {
v = v.convertPrecision(targetType.getPrecision());
} else if (v.charLength() > targetType.getPrecision()) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
private Value convertToVarcharIgnoreCase(TypeInfo targetType, int conversionMode, Object column) {
int valueType = getValueType();
switch (valueType) {
case BLOB:
case JAVA_OBJECT:
throw getDataConversionError(targetType.getValueType());
}
if (conversionMode != CONVERT_TO) {
String s = getString();
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (s.length() > p) {
if (conversionMode != CAST_TO) {
throw getValueTooLongException(targetType, column);
}
return ValueVarcharIgnoreCase.get(s.substring(0, p));
}
}
return valueType == Value.VARCHAR_IGNORECASE ? this : ValueVarcharIgnoreCase.get(getString());
}
private ValueBinary convertToBinary(TypeInfo targetType, int conversionMode, Object column) {
ValueBinary v;
if (getValueType() == BINARY) {
v = (ValueBinary) this;
} else {
try {
v = ValueBinary.getNoCopy(getBytesNoCopy());
} catch (DbException e) {
if (e.getErrorCode() == ErrorCode.DATA_CONVERSION_ERROR_1) {
throw getDataConversionError(BINARY);
}
throw e;
}
}
if (conversionMode != CONVERT_TO) {
byte[] value = v.getBytesNoCopy();
int length = value.length;
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (length != p) {
if (conversionMode == ASSIGN_TO && length > p) {
throw v.getValueTooLongException(targetType, column);
}
v = ValueBinary.getNoCopy(Arrays.copyOf(value, p));
}
}
return v;
}
private ValueVarbinary convertToVarbinary(TypeInfo targetType, int conversionMode, Object column) {
ValueVarbinary v;
if (getValueType() == VARBINARY) {
v = (ValueVarbinary) this;
} else {
v = ValueVarbinary.getNoCopy(getBytesNoCopy());
}
if (conversionMode != CONVERT_TO) {
byte[] value = v.getBytesNoCopy();
int length = value.length;
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (conversionMode == CAST_TO) {
if (length > p) {
v = ValueVarbinary.getNoCopy(Arrays.copyOf(value, p));
}
} else if (length > p) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
private ValueBlob convertToBlob(TypeInfo targetType, int conversionMode, Object column) {
ValueBlob v;
switch (getValueType()) {
case BLOB:
v = (ValueBlob) this;
break;
case CLOB:
DataHandler handler = ((ValueLob) this).lobData.getDataHandler();
if (handler != null) {
v = handler.getLobStorage().createBlob(getInputStream(), -1);
break;
}
//$FALL-THROUGH$
default:
try {
v = ValueBlob.createSmall(getBytesNoCopy());
} catch (DbException e) {
if (e.getErrorCode() == ErrorCode.DATA_CONVERSION_ERROR_1) {
throw getDataConversionError(BLOB);
}
throw e;
}
break;
}
if (conversionMode != CONVERT_TO) {
if (conversionMode == CAST_TO) {
v = v.convertPrecision(targetType.getPrecision());
} else if (v.octetLength() > targetType.getPrecision()) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
/**
* Converts this value to a BOOLEAN value. May not be called on a NULL
* value.
*
* @return the BOOLEAN value
*/
public final ValueBoolean convertToBoolean() {
switch (getValueType()) {
case BOOLEAN:
return (ValueBoolean) this;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
return ValueBoolean.get(getBoolean());
case TINYINT:
case SMALLINT:
case INTEGER:
case BIGINT:
case NUMERIC:
case DOUBLE:
case REAL:
case DECFLOAT:
return ValueBoolean.get(getSignum() != 0);
default:
throw getDataConversionError(BOOLEAN);
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a TINYINT value. May not be called on a NULL
* value.
*
* @param column
* the column, used for to improve the error message if
* conversion fails
* @return the TINYINT value
*/
public final ValueTinyint convertToTinyint(Object column) {
switch (getValueType()) {
case TINYINT:
return (ValueTinyint) this;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
case BOOLEAN:
return ValueTinyint.get(getByte());
case SMALLINT:
case ENUM:
case INTEGER:
return ValueTinyint.get(convertToByte(getInt(), column));
case BIGINT:
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_YEAR_TO_MONTH:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
return ValueTinyint.get(convertToByte(getLong(), column));
case NUMERIC:
case DECFLOAT:
return ValueTinyint.get(convertToByte(convertToLong(getBigDecimal(), column), column));
case REAL:
case DOUBLE:
return ValueTinyint.get(convertToByte(convertToLong(getDouble(), column), column));
case BINARY:
case VARBINARY: {
byte[] bytes = getBytesNoCopy();
if (bytes.length == 1) {
return ValueTinyint.get(bytes[0]);
}
}
//$FALL-THROUGH$
default:
throw getDataConversionError(TINYINT);
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a SMALLINT value. May not be called on a NULL value.
*
* @param column
* the column, used for to improve the error message if
* conversion fails
* @return the SMALLINT value
*/
public final ValueSmallint convertToSmallint(Object column) {
switch (getValueType()) {
case SMALLINT:
return (ValueSmallint) this;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
case BOOLEAN:
case TINYINT:
return ValueSmallint.get(getShort());
case ENUM:
case INTEGER:
return ValueSmallint.get(convertToShort(getInt(), column));
case BIGINT:
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_YEAR_TO_MONTH:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
return ValueSmallint.get(convertToShort(getLong(), column));
case NUMERIC:
case DECFLOAT:
return ValueSmallint.get(convertToShort(convertToLong(getBigDecimal(), column), column));
case REAL:
case DOUBLE:
return ValueSmallint.get(convertToShort(convertToLong(getDouble(), column), column));
case BINARY:
case VARBINARY: {
byte[] bytes = getBytesNoCopy();
if (bytes.length == 2) {
return ValueSmallint.get((short) ((bytes[0] << 8) + (bytes[1] & 0xff)));
}
}
//$FALL-THROUGH$
default:
throw getDataConversionError(SMALLINT);
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a INT value. May not be called on a NULL value.
*
* @param column
* the column, used for to improve the error message if
* conversion fails
* @return the INT value
*/
public final ValueInteger convertToInt(Object column) {
switch (getValueType()) {
case INTEGER:
return (ValueInteger) this;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
case BOOLEAN:
case TINYINT:
case ENUM:
case SMALLINT:
return ValueInteger.get(getInt());
case BIGINT:
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_YEAR_TO_MONTH:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
return ValueInteger.get(convertToInt(getLong(), column));
case NUMERIC:
case DECFLOAT:
return ValueInteger.get(convertToInt(convertToLong(getBigDecimal(), column), column));
case REAL:
case DOUBLE:
return ValueInteger.get(convertToInt(convertToLong(getDouble(), column), column));
case BINARY:
case VARBINARY: {
byte[] bytes = getBytesNoCopy();
if (bytes.length == 4) {
return ValueInteger.get(Bits.readInt(bytes, 0));
}
}
//$FALL-THROUGH$
default:
throw getDataConversionError(INTEGER);
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a BIGINT value. May not be called on a NULL value.
*
* @param column
* the column, used for to improve the error message if
* conversion fails
* @return the BIGINT value
*/
public final ValueBigint convertToBigint(Object column) {
switch (getValueType()) {
case BIGINT:
return (ValueBigint) this;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
case BOOLEAN:
case TINYINT:
case SMALLINT:
case INTEGER:
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_YEAR_TO_MONTH:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
case ENUM:
return ValueBigint.get(getLong());
case NUMERIC:
case DECFLOAT:
return ValueBigint.get(convertToLong(getBigDecimal(), column));
case REAL:
case DOUBLE:
return ValueBigint.get(convertToLong(getDouble(), column));
case BINARY:
case VARBINARY: {
byte[] bytes = getBytesNoCopy();
if (bytes.length == 8) {
return ValueBigint.get(Bits.readLong(bytes, 0));
}
}
//$FALL-THROUGH$
default:
throw getDataConversionError(BIGINT);
case NULL:
throw DbException.getInternalError();
}
}
private ValueNumeric convertToNumeric(TypeInfo targetType, CastDataProvider provider, int conversionMode,
Object column) {
ValueNumeric v;
switch (getValueType()) {
case NUMERIC:
v = (ValueNumeric) this;
break;
case BOOLEAN:
v = getBoolean() ? ValueNumeric.ONE : ValueNumeric.ZERO;
break;
default: {
BigDecimal value = getBigDecimal();
int targetScale = targetType.getScale();
int scale = value.scale();
if (scale < 0 || scale > ValueNumeric.MAXIMUM_SCALE || conversionMode != CONVERT_TO && scale != targetScale
&& (scale >= targetScale || !provider.getMode().convertOnlyToSmallerScale)) {
value = ValueNumeric.setScale(value, targetScale);
}
if (conversionMode != CONVERT_TO
&& value.precision() > targetType.getPrecision() - targetScale + value.scale()) {
throw getValueTooLongException(targetType, column);
}
return ValueNumeric.get(value);
}
case NULL:
throw DbException.getInternalError();
}
if (conversionMode != CONVERT_TO) {
int targetScale = targetType.getScale();
BigDecimal value = v.getBigDecimal();
int scale = value.scale();
if (scale != targetScale && (scale >= targetScale || !provider.getMode().convertOnlyToSmallerScale)) {
v = ValueNumeric.get(ValueNumeric.setScale(value, targetScale));
}
BigDecimal bd = v.getBigDecimal();
if (bd.precision() > targetType.getPrecision() - targetScale + bd.scale()) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
/**
* Converts this value to a REAL value. May not be called on a NULL value.
*
* @return the REAL value
*/
public final ValueReal convertToReal() {
switch (getValueType()) {
case REAL:
return (ValueReal) this;
case BOOLEAN:
return getBoolean() ? ValueReal.ONE : ValueReal.ZERO;
default:
return ValueReal.get(getFloat());
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a DOUBLE value. May not be called on a NULL value.
*
* @return the DOUBLE value
*/
public final ValueDouble convertToDouble() {
switch (getValueType()) {
case DOUBLE:
return (ValueDouble) this;
case BOOLEAN:
return getBoolean() ? ValueDouble.ONE : ValueDouble.ZERO;
default:
return ValueDouble.get(getDouble());
case NULL:
throw DbException.getInternalError();
}
}
private ValueDecfloat convertToDecfloat(TypeInfo targetType, int conversionMode) {
ValueDecfloat v;
switch (getValueType()) {
case DECFLOAT:
v = (ValueDecfloat) this;
if (v.value == null) {
return v;
}
break;
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE: {
String s = getString().trim();
try {
v = ValueDecfloat.get(new BigDecimal(s));
} catch (NumberFormatException e) {
switch (s) {
case "-Infinity":
return ValueDecfloat.NEGATIVE_INFINITY;
case "Infinity":
case "+Infinity":
return ValueDecfloat.POSITIVE_INFINITY;
case "NaN":
case "-NaN":
case "+NaN":
return ValueDecfloat.NAN;
default:
throw getDataConversionError(DECFLOAT);
}
}
break;
}
case BOOLEAN:
v = getBoolean() ? ValueDecfloat.ONE : ValueDecfloat.ZERO;
break;
case REAL: {
float value = getFloat();
if (Float.isFinite(value)) {
v = ValueDecfloat.get(new BigDecimal(Float.toString(value)));
} else if (value == Float.POSITIVE_INFINITY) {
return ValueDecfloat.POSITIVE_INFINITY;
} else if (value == Float.NEGATIVE_INFINITY) {
return ValueDecfloat.NEGATIVE_INFINITY;
} else {
return ValueDecfloat.NAN;
}
break;
}
case DOUBLE: {
double value = getDouble();
if (Double.isFinite(value)) {
v = ValueDecfloat.get(new BigDecimal(Double.toString(value)));
} else if (value == Double.POSITIVE_INFINITY) {
return ValueDecfloat.POSITIVE_INFINITY;
} else if (value == Double.NEGATIVE_INFINITY) {
return ValueDecfloat.NEGATIVE_INFINITY;
} else {
return ValueDecfloat.NAN;
}
break;
}
default:
try {
v = ValueDecfloat.get(getBigDecimal());
} catch (DbException e) {
if (e.getErrorCode() == ErrorCode.DATA_CONVERSION_ERROR_1) {
throw getDataConversionError(DECFLOAT);
}
throw e;
}
break;
case NULL:
throw DbException.getInternalError();
}
if (conversionMode != CONVERT_TO) {
BigDecimal bd = v.value;
int precision = bd.precision(), targetPrecision = (int) targetType.getPrecision();
if (precision > targetPrecision) {
v = ValueDecfloat.get(bd.setScale(bd.scale() - precision + targetPrecision, RoundingMode.HALF_UP));
}
}
return v;
}
/**
* Converts this value to a DATE value. May not be called on a NULL value.
*
* @param provider
* the cast information provider
* @return the DATE value
*/
public final ValueDate convertToDate(CastDataProvider provider) {
switch (getValueType()) {
case DATE:
return (ValueDate) this;
case TIMESTAMP:
return ValueDate.fromDateValue(((ValueTimestamp) this).getDateValue());
case TIMESTAMP_TZ: {
ValueTimestampTimeZone ts = (ValueTimestampTimeZone) this;
long timeNanos = ts.getTimeNanos();
long epochSeconds = DateTimeUtils.getEpochSeconds(ts.getDateValue(), timeNanos,
ts.getTimeZoneOffsetSeconds());
return ValueDate.fromDateValue(DateTimeUtils
.dateValueFromLocalSeconds(epochSeconds
+ provider.currentTimeZone().getTimeZoneOffsetUTC(epochSeconds)));
}
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
return ValueDate.parse(getString().trim());
default:
throw getDataConversionError(DATE);
case NULL:
throw DbException.getInternalError();
}
}
private ValueTime convertToTime(TypeInfo targetType, CastDataProvider provider, int conversionMode) {
ValueTime v;
switch (getValueType()) {
case TIME:
v = (ValueTime) this;
break;
case TIME_TZ:
v = ValueTime.fromNanos(getLocalTimeNanos(provider));
break;
case TIMESTAMP:
v = ValueTime.fromNanos(((ValueTimestamp) this).getTimeNanos());
break;
case TIMESTAMP_TZ: {
ValueTimestampTimeZone ts = (ValueTimestampTimeZone) this;
long timeNanos = ts.getTimeNanos();
long epochSeconds = DateTimeUtils.getEpochSeconds(ts.getDateValue(), timeNanos,
ts.getTimeZoneOffsetSeconds());
v = ValueTime.fromNanos(
DateTimeUtils.nanosFromLocalSeconds(epochSeconds
+ provider.currentTimeZone().getTimeZoneOffsetUTC(epochSeconds))
+ timeNanos % DateTimeUtils.NANOS_PER_SECOND);
break;
}
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
v = ValueTime.parse(getString().trim(), provider);
break;
default:
throw getDataConversionError(TIME);
}
if (conversionMode != CONVERT_TO) {
int targetScale = targetType.getScale();
if (targetScale < ValueTime.MAXIMUM_SCALE) {
long n = v.getNanos();
long n2 = DateTimeUtils.convertScale(n, targetScale, DateTimeUtils.NANOS_PER_DAY);
if (n2 != n) {
v = ValueTime.fromNanos(n2);
}
}
}
return v;
}
private ValueTimeTimeZone convertToTimeTimeZone(TypeInfo targetType, CastDataProvider provider,
int conversionMode) {
ValueTimeTimeZone v;
switch (getValueType()) {
case TIME_TZ:
v = (ValueTimeTimeZone) this;
break;
case TIME:
v = ValueTimeTimeZone.fromNanos(((ValueTime) this).getNanos(),
provider.currentTimestamp().getTimeZoneOffsetSeconds());
break;
case TIMESTAMP: {
ValueTimestamp ts = (ValueTimestamp) this;
long timeNanos = ts.getTimeNanos();
v = ValueTimeTimeZone.fromNanos(timeNanos,
provider.currentTimeZone().getTimeZoneOffsetLocal(ts.getDateValue(), timeNanos));
break;
}
case TIMESTAMP_TZ: {
ValueTimestampTimeZone ts = (ValueTimestampTimeZone) this;
v = ValueTimeTimeZone.fromNanos(ts.getTimeNanos(), ts.getTimeZoneOffsetSeconds());
break;
}
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
v = ValueTimeTimeZone.parse(getString().trim(), provider);
break;
default:
throw getDataConversionError(TIME_TZ);
}
if (conversionMode != CONVERT_TO) {
int targetScale = targetType.getScale();
if (targetScale < ValueTime.MAXIMUM_SCALE) {
long n = v.getNanos();
long n2 = DateTimeUtils.convertScale(n, targetScale, DateTimeUtils.NANOS_PER_DAY);
if (n2 != n) {
v = ValueTimeTimeZone.fromNanos(n2, v.getTimeZoneOffsetSeconds());
}
}
}
return v;
}
private ValueTimestamp convertToTimestamp(TypeInfo targetType, CastDataProvider provider, int conversionMode) {
ValueTimestamp v;
switch (getValueType()) {
case TIMESTAMP:
v = (ValueTimestamp) this;
break;
case TIME:
v = ValueTimestamp.fromDateValueAndNanos(provider.currentTimestamp().getDateValue(),
((ValueTime) this).getNanos());
break;
case TIME_TZ:
v = ValueTimestamp.fromDateValueAndNanos(provider.currentTimestamp().getDateValue(),
getLocalTimeNanos(provider));
break;
case DATE:
// Scale is always 0
return ValueTimestamp.fromDateValueAndNanos(((ValueDate) this).getDateValue(), 0);
case TIMESTAMP_TZ: {
ValueTimestampTimeZone ts = (ValueTimestampTimeZone) this;
long timeNanos = ts.getTimeNanos();
long epochSeconds = DateTimeUtils.getEpochSeconds(ts.getDateValue(), timeNanos,
ts.getTimeZoneOffsetSeconds());
epochSeconds += provider.currentTimeZone().getTimeZoneOffsetUTC(epochSeconds);
v = ValueTimestamp.fromDateValueAndNanos(DateTimeUtils.dateValueFromLocalSeconds(epochSeconds),
DateTimeUtils.nanosFromLocalSeconds(epochSeconds) + timeNanos % DateTimeUtils.NANOS_PER_SECOND);
break;
}
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
v = ValueTimestamp.parse(getString().trim(), provider);
break;
default:
throw getDataConversionError(TIMESTAMP);
}
if (conversionMode != CONVERT_TO) {
int targetScale = targetType.getScale();
if (targetScale < ValueTimestamp.MAXIMUM_SCALE) {
long dv = v.getDateValue(), n = v.getTimeNanos();
long n2 = DateTimeUtils.convertScale(n, targetScale,
dv == DateTimeUtils.MAX_DATE_VALUE ? DateTimeUtils.NANOS_PER_DAY : Long.MAX_VALUE);
if (n2 != n) {
if (n2 >= DateTimeUtils.NANOS_PER_DAY) {
n2 -= DateTimeUtils.NANOS_PER_DAY;
dv = DateTimeUtils.incrementDateValue(dv);
}
v = ValueTimestamp.fromDateValueAndNanos(dv, n2);
}
}
}
return v;
}
private long getLocalTimeNanos(CastDataProvider provider) {
ValueTimeTimeZone ts = (ValueTimeTimeZone) this;
int localOffset = provider.currentTimestamp().getTimeZoneOffsetSeconds();
return DateTimeUtils.normalizeNanosOfDay(ts.getNanos() +
(localOffset - ts.getTimeZoneOffsetSeconds()) * DateTimeUtils.NANOS_PER_SECOND);
}
private ValueTimestampTimeZone convertToTimestampTimeZone(TypeInfo targetType, CastDataProvider provider,
int conversionMode) {
ValueTimestampTimeZone v;
switch (getValueType()) {
case TIMESTAMP_TZ:
v = (ValueTimestampTimeZone) this;
break;
case TIME: {
long dateValue = provider.currentTimestamp().getDateValue();
long timeNanos = ((ValueTime) this).getNanos();
v = ValueTimestampTimeZone.fromDateValueAndNanos(dateValue, timeNanos,
provider.currentTimeZone().getTimeZoneOffsetLocal(dateValue, timeNanos));
break;
}
case TIME_TZ: {
ValueTimeTimeZone t = (ValueTimeTimeZone) this;
v = ValueTimestampTimeZone.fromDateValueAndNanos(provider.currentTimestamp().getDateValue(),
t.getNanos(), t.getTimeZoneOffsetSeconds());
break;
}
case DATE: {
long dateValue = ((ValueDate) this).getDateValue();
// Scale is always 0
return ValueTimestampTimeZone.fromDateValueAndNanos(dateValue, 0L,
provider.currentTimeZone().getTimeZoneOffsetLocal(dateValue, 0L));
}
case TIMESTAMP: {
ValueTimestamp ts = (ValueTimestamp) this;
long dateValue = ts.getDateValue();
long timeNanos = ts.getTimeNanos();
v = ValueTimestampTimeZone.fromDateValueAndNanos(dateValue, timeNanos,
provider.currentTimeZone().getTimeZoneOffsetLocal(dateValue, timeNanos));
break;
}
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
v = ValueTimestampTimeZone.parse(getString().trim(), provider);
break;
default:
throw getDataConversionError(TIMESTAMP_TZ);
}
if (conversionMode != CONVERT_TO) {
int targetScale = targetType.getScale();
if (targetScale < ValueTimestamp.MAXIMUM_SCALE) {
long dv = v.getDateValue();
long n = v.getTimeNanos();
long n2 = DateTimeUtils.convertScale(n, targetScale,
dv == DateTimeUtils.MAX_DATE_VALUE ? DateTimeUtils.NANOS_PER_DAY : Long.MAX_VALUE);
if (n2 != n) {
if (n2 >= DateTimeUtils.NANOS_PER_DAY) {
n2 -= DateTimeUtils.NANOS_PER_DAY;
dv = DateTimeUtils.incrementDateValue(dv);
}
v = ValueTimestampTimeZone.fromDateValueAndNanos(dv, n2, v.getTimeZoneOffsetSeconds());
}
}
}
return v;
}
private ValueInterval convertToIntervalYearMonth(TypeInfo targetType, int conversionMode, Object column) {
ValueInterval v = convertToIntervalYearMonth(targetType.getValueType(), column);
if (conversionMode != CONVERT_TO) {
if (!v.checkPrecision(targetType.getPrecision())) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
private ValueInterval convertToIntervalYearMonth(int targetType, Object column) {
long leading;
switch (getValueType()) {
case TINYINT:
case SMALLINT:
case INTEGER:
leading = getInt();
break;
case BIGINT:
leading = getLong();
break;
case REAL:
case DOUBLE:
if (targetType == INTERVAL_YEAR_TO_MONTH) {
return IntervalUtils.intervalFromAbsolute(IntervalQualifier.YEAR_TO_MONTH, getBigDecimal()
.multiply(BigDecimal.valueOf(12)).setScale(0, RoundingMode.HALF_UP).toBigInteger());
}
leading = convertToLong(getDouble(), column);
break;
case NUMERIC:
case DECFLOAT:
if (targetType == INTERVAL_YEAR_TO_MONTH) {
return IntervalUtils.intervalFromAbsolute(IntervalQualifier.YEAR_TO_MONTH, getBigDecimal()
.multiply(BigDecimal.valueOf(12)).setScale(0, RoundingMode.HALF_UP).toBigInteger());
}
leading = convertToLong(getBigDecimal(), column);
break;
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR: {
String s = getString();
try {
return (ValueInterval) IntervalUtils
.parseFormattedInterval(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR), s)
.convertTo(targetType);
} catch (Exception e) {
throw DbException.get(ErrorCode.INVALID_DATETIME_CONSTANT_2, e, "INTERVAL", s);
}
}
case INTERVAL_YEAR:
case INTERVAL_MONTH:
case INTERVAL_YEAR_TO_MONTH:
return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR),
IntervalUtils.intervalToAbsolute((ValueInterval) this));
default:
throw getDataConversionError(targetType);
}
boolean negative = false;
if (leading < 0) {
negative = true;
leading = -leading;
}
return ValueInterval.from(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR), negative, leading,
0L);
}
private ValueInterval convertToIntervalDayTime(TypeInfo targetType, int conversionMode, Object column) {
ValueInterval v = convertToIntervalDayTime(targetType.getValueType(), column);
if (conversionMode != CONVERT_TO) {
v = v.setPrecisionAndScale(targetType, column);
}
return v;
}
private ValueInterval convertToIntervalDayTime(int targetType, Object column) {
long leading;
switch (getValueType()) {
case TINYINT:
case SMALLINT:
case INTEGER:
leading = getInt();
break;
case BIGINT:
leading = getLong();
break;
case REAL:
case DOUBLE:
if (targetType > INTERVAL_MINUTE) {
return convertToIntervalDayTime(getBigDecimal(), targetType);
}
leading = convertToLong(getDouble(), column);
break;
case NUMERIC:
case DECFLOAT:
if (targetType > INTERVAL_MINUTE) {
return convertToIntervalDayTime(getBigDecimal(), targetType);
}
leading = convertToLong(getBigDecimal(), column);
break;
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR: {
String s = getString();
try {
return (ValueInterval) IntervalUtils
.parseFormattedInterval(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR), s)
.convertTo(targetType);
} catch (Exception e) {
throw DbException.get(ErrorCode.INVALID_DATETIME_CONSTANT_2, e, "INTERVAL", s);
}
}
case INTERVAL_DAY:
case INTERVAL_HOUR:
case INTERVAL_MINUTE:
case INTERVAL_SECOND:
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
case INTERVAL_MINUTE_TO_SECOND:
return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR),
IntervalUtils.intervalToAbsolute((ValueInterval) this));
default:
throw getDataConversionError(targetType);
}
boolean negative = false;
if (leading < 0) {
negative = true;
leading = -leading;
}
return ValueInterval.from(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR), negative, leading,
0L);
}
private ValueInterval convertToIntervalDayTime(BigDecimal bigDecimal, int targetType) {
long multiplier;
switch (targetType) {
case INTERVAL_SECOND:
multiplier = DateTimeUtils.NANOS_PER_SECOND;
break;
case INTERVAL_DAY_TO_HOUR:
case INTERVAL_DAY_TO_MINUTE:
case INTERVAL_DAY_TO_SECOND:
multiplier = DateTimeUtils.NANOS_PER_DAY;
break;
case INTERVAL_HOUR_TO_MINUTE:
case INTERVAL_HOUR_TO_SECOND:
multiplier = DateTimeUtils.NANOS_PER_HOUR;
break;
case INTERVAL_MINUTE_TO_SECOND:
multiplier = DateTimeUtils.NANOS_PER_MINUTE;
break;
default:
throw getDataConversionError(targetType);
}
return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - INTERVAL_YEAR),
bigDecimal.multiply(BigDecimal.valueOf(multiplier)).setScale(0, RoundingMode.HALF_UP).toBigInteger());
}
/**
* Converts this value to a JAVA_OBJECT value. May not be called on a NULL
* value.
*
* @param targetType
* the type of the returned value
* @param conversionMode
* conversion mode
* @param column
* the column (if any), used to improve the error message if
* conversion fails
* @return the JAVA_OBJECT value
*/
public final ValueJavaObject convertToJavaObject(TypeInfo targetType, int conversionMode, Object column) {
ValueJavaObject v;
switch (getValueType()) {
case JAVA_OBJECT:
v = (ValueJavaObject) this;
break;
case BINARY:
case VARBINARY:
case BLOB:
v = ValueJavaObject.getNoCopy(getBytesNoCopy());
break;
default:
throw getDataConversionError(JAVA_OBJECT);
case NULL:
throw DbException.getInternalError();
}
if (conversionMode != CONVERT_TO && v.getBytesNoCopy().length > targetType.getPrecision()) {
throw v.getValueTooLongException(targetType, column);
}
return v;
}
/**
* Converts this value to an ENUM value. May not be called on a NULL value.
*
* @param extTypeInfo
* the extended data type information
* @param provider
* the cast information provider
* @return the ENUM value
*/
public final ValueEnum convertToEnum(ExtTypeInfoEnum extTypeInfo, CastDataProvider provider) {
switch (getValueType()) {
case ENUM: {
ValueEnum v = (ValueEnum) this;
if (extTypeInfo.equals(v.getEnumerators())) {
return v;
}
return extTypeInfo.getValue(v.getString(), provider);
}
case TINYINT:
case SMALLINT:
case INTEGER:
case BIGINT:
case NUMERIC:
case DECFLOAT:
return extTypeInfo.getValue(getInt(), provider);
case VARCHAR:
case VARCHAR_IGNORECASE:
case CHAR:
return extTypeInfo.getValue(getString(), provider);
default:
throw getDataConversionError(ENUM);
case NULL:
throw DbException.getInternalError();
}
}
/**
* Converts this value to a GEOMETRY value. May not be called on a NULL
* value.
*
* @param extTypeInfo
* the extended data type information, or null
* @return the GEOMETRY value
*/
public final ValueGeometry convertToGeometry(ExtTypeInfoGeometry extTypeInfo) {
ValueGeometry result;
switch (getValueType()) {
case GEOMETRY:
result = (ValueGeometry) this;
break;
case BINARY:
case VARBINARY:
case BLOB:
result = ValueGeometry.getFromEWKB(getBytesNoCopy());
break;
case JSON: {
int srid = 0;
if (extTypeInfo != null) {
Integer s = extTypeInfo.getSrid();
if (s != null) {
srid = s;
}
}
try {
result = ValueGeometry.get(GeoJsonUtils.geoJsonToEwkb(getBytesNoCopy(), srid));
} catch (RuntimeException ex) {
throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, getTraceSQL());
}
break;
}
case CHAR:
case VARCHAR:
case CLOB:
case VARCHAR_IGNORECASE:
result = ValueGeometry.get(getString());
break;
default:
throw getDataConversionError(GEOMETRY);
case NULL:
throw DbException.getInternalError();
}
if (extTypeInfo != null) {
int type = extTypeInfo.getType();
Integer srid = extTypeInfo.getSrid();
if (type != 0 && result.getTypeAndDimensionSystem() != type || srid != null && result.getSRID() != srid) {
StringBuilder builder = ExtTypeInfoGeometry
.toSQL(new StringBuilder(), result.getTypeAndDimensionSystem(), result.getSRID())
.append(" -> ");
extTypeInfo.getSQL(builder, TRACE_SQL_FLAGS);
throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, builder.toString());
}
}
return result;
}
private ValueJson convertToJson(TypeInfo targetType, int conversionMode, Object column) {
ValueJson v;
switch (getValueType()) {
case JSON:
v = (ValueJson) this;
break;
case BOOLEAN:
v = ValueJson.get(getBoolean());
break;
case TINYINT:
case SMALLINT:
case INTEGER:
v = ValueJson.get(getInt());
break;
case BIGINT:
v = ValueJson.get(getLong());
break;
case REAL:
case DOUBLE:
case NUMERIC:
case DECFLOAT:
v = ValueJson.get(getBigDecimal());
break;
case BINARY:
case VARBINARY:
case BLOB:
v = ValueJson.fromJson(getBytesNoCopy());
break;
case CHAR:
case VARCHAR:
case CLOB:
case VARCHAR_IGNORECASE:
case DATE:
case TIME:
case TIME_TZ:
case ENUM:
case UUID:
v = ValueJson.get(getString());
break;
case TIMESTAMP:
v = ValueJson.get(((ValueTimestamp) this).getISOString());
break;
case TIMESTAMP_TZ:
v = ValueJson.get(((ValueTimestampTimeZone) this).getISOString());
break;
case GEOMETRY: {
ValueGeometry vg = (ValueGeometry) this;
v = ValueJson.getInternal(GeoJsonUtils.ewkbToGeoJson(vg.getBytesNoCopy(), vg.getDimensionSystem()));
break;
}
case ARRAY: {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write('[');
for (Value e : ((ValueArray) this).getList()) {
JsonConstructorUtils.jsonArrayAppend(baos, e, 0);
}
baos.write(']');
v = ValueJson.getInternal(baos.toByteArray());
break;
}
default:
throw getDataConversionError(JSON);
}
if (conversionMode != CONVERT_TO && v.getBytesNoCopy().length > targetType.getPrecision()) {
throw v.getValueTooLongException(targetType, column);
}
return v;
}
/**
* Converts this value to a UUID value. May not be called on a NULL value.
*
* @return the UUID value
*/
public final ValueUuid convertToUuid() {
switch (getValueType()) {
case UUID:
return (ValueUuid) this;
case BINARY:
case VARBINARY:
return ValueUuid.get(getBytesNoCopy());
case JAVA_OBJECT:
return JdbcUtils.deserializeUuid(getBytesNoCopy());
case CHAR:
case VARCHAR:
case VARCHAR_IGNORECASE:
return ValueUuid.get(getString());
default:
throw getDataConversionError(UUID);
case NULL:
throw DbException.getInternalError();
}
}
private ValueArray convertToArray(TypeInfo targetType, CastDataProvider provider, int conversionMode,
Object column) {
TypeInfo componentType = (TypeInfo) targetType.getExtTypeInfo();
int valueType = getValueType();
ValueArray v;
if (valueType == ARRAY) {
v = (ValueArray) this;
} else {
Value[] a;
switch (valueType) {
case BLOB:
a = new Value[] { ValueVarbinary.get(getBytesNoCopy()) };
break;
case CLOB:
a = new Value[] { ValueVarchar.get(getString()) };
break;
default:
a = new Value[] { this };
}
v = ValueArray.get(a, provider);
}
if (componentType != null) {
Value[] values = v.getList();
int length = values.length;
loop: for (int i = 0; i < length; i++) {
Value v1 = values[i];
Value v2 = v1.convertTo(componentType, provider, conversionMode, column);
if (v1 != v2) {
Value[] newValues = new Value[length];
System.arraycopy(values, 0, newValues, 0, i);
newValues[i] = v2;
while (++i < length) {
newValues[i] = values[i].convertTo(componentType, provider, conversionMode, column);
}
v = ValueArray.get(componentType, newValues, provider);
break loop;
}
}
}
if (conversionMode != CONVERT_TO) {
Value[] values = v.getList();
int cardinality = values.length;
if (conversionMode == CAST_TO) {
int p = MathUtils.convertLongToInt(targetType.getPrecision());
if (cardinality > p) {
v = ValueArray.get(v.getComponentType(), Arrays.copyOf(values, p), provider);
}
} else if (cardinality > targetType.getPrecision()) {
throw v.getValueTooLongException(targetType, column);
}
}
return v;
}
private Value convertToRow(TypeInfo targetType, CastDataProvider provider, int conversionMode,
Object column) {
ValueRow v;
if (getValueType() == ROW) {
v = (ValueRow) this;
} else {
v = ValueRow.get(new Value[] { this });
}
ExtTypeInfoRow ext = (ExtTypeInfoRow) targetType.getExtTypeInfo();
if (ext != null) {
Value[] values = v.getList();
int length = values.length;
Set<Map.Entry<String, TypeInfo>> fields = ext.getFields();
if (length != fields.size()) {
throw getDataConversionError(targetType);
}
Iterator<Map.Entry<String, TypeInfo>> iter = fields.iterator();
loop: for (int i = 0; i < length; i++) {
Value v1 = values[i];
TypeInfo componentType = iter.next().getValue();
Value v2 = v1.convertTo(componentType, provider, conversionMode, column);
if (v1 != v2) {
Value[] newValues = new Value[length];
System.arraycopy(values, 0, newValues, 0, i);
newValues[i] = v2;
while (++i < length) {
newValues[i] = values[i].convertTo(componentType, provider, conversionMode, column);
}
v = ValueRow.get(targetType, newValues);
break loop;
}
}
}
return v;
}
/**
* Creates new instance of the DbException for data conversion error.
*
* @param targetType Target data type.
* @return instance of the DbException.
*/
final DbException getDataConversionError(int targetType) {
throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, getTypeName(getValueType()) + " to "
+ getTypeName(targetType));
}
/**
* Creates new instance of the DbException for data conversion error.
*
* @param targetType target data type.
* @return instance of the DbException.
*/
final DbException getDataConversionError(TypeInfo targetType) {
throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, getTypeName(getValueType()) + " to "
+ targetType.getTraceSQL());
}
final DbException getValueTooLongException(TypeInfo targetType, Object column) {
StringBuilder builder = new StringBuilder();
if (column != null) {
builder.append(column).append(' ');
}
targetType.getSQL(builder, TRACE_SQL_FLAGS);
return DbException.getValueTooLongException(builder.toString(), getTraceSQL(), getType().getPrecision());
}
/**
* Compare this value against another value given that the values are of the
* same data type.
*
* @param v the other value
* @param mode the compare mode
* @param provider the cast information provider
* @return 0 if both values are equal, -1 if the other value is smaller, and
* 1 otherwise
*/
public abstract int compareTypeSafe(Value v, CompareMode mode, CastDataProvider provider);
/**
* Compare this value against another value using the specified compare
* mode.
*
* @param v the other value
* @param provider the cast information provider
* @param compareMode the compare mode
* @return 0 if both values are equal, -1 if this value is smaller, and
* 1 otherwise
*/
public final int compareTo(Value v, CastDataProvider provider, CompareMode compareMode) {
if (this == v) {
return 0;
}
if (this == ValueNull.INSTANCE) {
return -1;
} else if (v == ValueNull.INSTANCE) {
return 1;
}
return compareToNotNullable(this, v, provider, compareMode);
}
private static int compareToNotNullable(Value l, Value r, CastDataProvider provider, CompareMode compareMode) {
int leftType = l.getValueType();
int rightType = r.getValueType();
if (leftType != rightType || leftType == ENUM) {
int dataType = getHigherOrderNonNull(leftType, rightType);
if (DataType.isNumericType(dataType)) {
return compareNumeric(l, r, leftType, rightType, dataType);
}
if (dataType == ENUM) {
ExtTypeInfoEnum enumerators = ExtTypeInfoEnum.getEnumeratorsForBinaryOperation(l, r);
return Integer.compare(l.convertToEnum(enumerators, provider).getInt(),
r.convertToEnum(enumerators, provider).getInt());
} else {
if (dataType <= BLOB) {
if (dataType <= CLOB) {
if (leftType == CHAR || rightType == CHAR) {
dataType = CHAR;
}
} else if (dataType >= BINARY && (leftType == BINARY || rightType == BINARY)) {
dataType = BINARY;
}
}
l = l.convertTo(dataType, provider);
r = r.convertTo(dataType, provider);
}
}
return l.compareTypeSafe(r, compareMode, provider);
}
private static int compareNumeric(Value l, Value r, int leftType, int rightType, int dataType) {
if (DataType.isNumericType(leftType) && DataType.isNumericType(rightType)) {
switch (dataType) {
case TINYINT:
case SMALLINT:
case INTEGER:
return Integer.compare(l.getInt(), r.getInt());
case BIGINT:
return Long.compare(l.getLong(), r.getLong());
case NUMERIC:
return l.getBigDecimal().compareTo(r.getBigDecimal());
case REAL:
return Float.compare(l.getFloat(), r.getFloat());
case DOUBLE:
return Double.compare(l.getDouble(), r.getDouble());
}
}
return l.convertToDecfloat(null, CONVERT_TO).compareTypeSafe( //
r.convertToDecfloat(null, CONVERT_TO), null, null);
}
/**
* Compare this value against another value using the specified compare
* mode.
*
* @param v the other value
* @param forEquality perform only check for equality
* @param provider the cast information provider
* @param compareMode the compare mode
* @return 0 if both values are equal, -1 if this value is smaller, 1
* if other value is larger, {@link Integer#MIN_VALUE} if order is
* not defined due to NULL comparison
*/
public int compareWithNull(Value v, boolean forEquality, CastDataProvider provider,
CompareMode compareMode) {
if (this == ValueNull.INSTANCE || v == ValueNull.INSTANCE) {
return Integer.MIN_VALUE;
}
return compareToNotNullable(this, v, provider, compareMode);
}
/**
* Returns true if this value is NULL or contains NULL value.
*
* @return true if this value is NULL or contains NULL value
*/
public boolean containsNull() {
return false;
}
private static byte convertToByte(long x, Object column) {
if (x > Byte.MAX_VALUE || x < Byte.MIN_VALUE) {
throw DbException.get(
ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
}
return (byte) x;
}
private static short convertToShort(long x, Object column) {
if (x > Short.MAX_VALUE || x < Short.MIN_VALUE) {
throw DbException.get(
ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
}
return (short) x;
}
/**
* Convert to integer, throwing exception if out of range.
*
* @param x integer value.
* @param column Column info.
* @return x
*/
public static int convertToInt(long x, Object column) {
if (x > Integer.MAX_VALUE || x < Integer.MIN_VALUE) {
throw DbException.get(
ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
}
return (int) x;
}
private static long convertToLong(double x, Object column) {
if (x > Long.MAX_VALUE || x < Long.MIN_VALUE) {
// TODO document that +Infinity, -Infinity throw an exception and
// NaN returns 0
throw DbException.get(
ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Double.toString(x), getColumnName(column));
}
return Math.round(x);
}
private static long convertToLong(BigDecimal x, Object column) {
if (x.compareTo(MAX_LONG_DECIMAL) > 0 ||
x.compareTo(MIN_LONG_DECIMAL) < 0) {
throw DbException.get(
ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, x.toString(), getColumnName(column));
}
return x.setScale(0, RoundingMode.HALF_UP).longValue();
}
private static String getColumnName(Object column) {
return column == null ? "" : column.toString();
}
@Override
public String toString() {
return getTraceSQL();
}
/**
* Create an exception meaning the specified operation is not supported for
* this data type.
*
* @param op the operation
* @return the exception
*/
protected final DbException getUnsupportedExceptionForOperation(String op) {
return DbException.getUnsupportedException(getTypeName(getValueType()) + ' ' + op);
}
/**
* Returns length of this value in characters.
*
* @return length of this value in characters
* @throws NullPointerException if this value is {@code NULL}
*/
public long charLength() {
return getString().length();
}
/**
* Returns length of this value in bytes.
*
* @return length of this value in bytes
* @throws NullPointerException if this value is {@code NULL}
*/
public long octetLength() {
return getBytesNoCopy().length;
}
/**
* Returns whether this value {@code IS TRUE}.
*
* @return {@code true} if it is. For {@code BOOLEAN} values returns
* {@code true} for {@code TRUE} and {@code false} for {@code FALSE}
* and {@code UNKNOWN} ({@code NULL}).
* @see #getBoolean()
* @see #isFalse()
*/
public final boolean isTrue() {
return this != ValueNull.INSTANCE ? getBoolean() : false;
}
/**
* Returns whether this value {@code IS FALSE}.
*
* @return {@code true} if it is. For {@code BOOLEAN} values returns
* {@code true} for {@code FALSE} and {@code false} for {@code TRUE}
* and {@code UNKNOWN} ({@code NULL}).
* @see #getBoolean()
* @see #isTrue()
*/
public final boolean isFalse() {
return this != ValueNull.INSTANCE && !getBoolean();
}
}