/**
* Retrieves whether values for the designated parameter can be signed numbers.
*
* @param param the first parameter is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @exception SQLException if a database access error occurs
* @since JDK 1.4, HSQLDB 1.7.2
*/
public boolean isSigned(int param) throws SQLException {
checkRange(param);
Type type = translateType(rmd.columnTypes[--param]);
return type.isNumberType();
}
/**
* Retrieves the designated parameter's SQL type.
*
* @param param the first parameter is 1, the second is 2, ...
* @return SQL type from <code>java.sql.Types</code>
* @exception SQLException if a database access error occurs
* @since JDK 1.4, HSQLDB 1.7.2
* @see java.sql.Types
*/
public int getParameterType(int param) throws SQLException {
checkRange(param);
Type type = translateType(rmd.columnTypes[--param]);
return type.getJDBCTypeCode();
}
/**
* Retrieves the fully-qualified name of the Java class whose instances should be passed to the
* method <code>PreparedStatement.setObject</code>.
*
* @param param the first parameter is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming language that would be
* used by the method <code>PreparedStatement.setObject</code> to set the value in the
* specified parameter. This is the class name used for custom mapping.
* @exception SQLException if a database access error occurs
* @since JDK 1.4, HSQLDB 1.7.2
*/
public String getParameterClassName(int param) throws SQLException {
checkRange(param);
Type type = translateType(rmd.columnTypes[--param]);
return type.getJDBCClassName();
}
/** Translates an INTERVAL type to VARCHAR. Removes time zone from datetime types. */
private Type translateType(Type type) {
if (this.translateTTIType) {
if (type.isIntervalType()) {
type = ((IntervalType) type).getCharacterType();
} else if (type.isDateTimeTypeWithZone()) {
type = ((DateTimeType) type).getDateTimeTypeWithoutZone();
}
}
return type;
}
public Constraint(
HsqlNameManager.HsqlName paramHsqlName, Table paramTable, Index paramIndex, int paramInt) {
this.name = paramHsqlName;
this.constType = paramInt;
this.core = new ConstraintCore();
this.core.mainTable = paramTable;
this.core.mainIndex = paramIndex;
this.core.mainCols = paramIndex.getColumns();
for (int i = 0; i < this.core.mainCols.length; i++) {
Type localType = paramTable.getColumn(this.core.mainCols[i]).getDataType();
if (localType.isLobType()) throw Error.error(5534);
}
}
public Type getAggregateType(Type other) throws HsqlException {
if (this == other) {
return this;
}
if (other.isCharacterType()) {
return other.getAggregateType(this);
}
switch (other.typeCode) {
case Types.SQL_ALL_TYPES:
return this;
case Types.SQL_REAL:
case Types.SQL_FLOAT:
case Types.SQL_DOUBLE:
case Types.SQL_NUMERIC:
case Types.SQL_DECIMAL:
case Types.TINYINT:
case Types.SQL_SMALLINT:
case Types.SQL_INTEGER:
case Types.SQL_BIGINT:
break;
default:
throw Error.error(ErrorCode.X_42562);
}
if (typeWidth == DOUBLE_WIDTH) {
return this;
}
if (((NumberType) other).typeWidth == DOUBLE_WIDTH) {
return other;
}
if (typeWidth <= BIGINT_WIDTH && ((NumberType) other).typeWidth <= BIGINT_WIDTH) {
return (typeWidth > ((NumberType) other).typeWidth) ? this : other;
}
int newScale = scale > other.scale ? scale : other.scale;
long newDigits =
precision - scale > other.precision - other.scale
? precision - scale
: other.precision - other.scale;
return getNumberType(Types.SQL_DECIMAL, newDigits + newScale, newScale);
}
@Override
public String getBaseTypeName() throws SQLException {
checkClosed();
return elementType.getNameString();
}
@Override
public int getBaseType() throws SQLException {
checkClosed();
return elementType.getJDBCTypeCode();
}
/**
* Convert type for JDBC reads. Same as convertToType, but supports non-standard SQL conversions
* supported by JDBC
*/
public Object convertToTypeJDBC(SessionInterface session, Object a, Type otherType) {
if (otherType.isLobType()) {
throw Error.error(ErrorCode.X_42561);
}
return convertToType(session, a, otherType);
}
Type readDataType(RowInputBinary in) throws IOException {
int typeCode = in.readType();
long size = in.readLong();
int scale = in.readInt();
return Type.getType(typeCode, 0, size, scale);
}
Object getValue(Session session, Type type) {
if (dataType == type || valueData == null) {
return valueData;
}
return type.convertToType(session, valueData, dataType);
}
/**
* Retrieves the designated parameter's specified column size.
*
* <p>The returned value represents the maximum column size for the given parameter. For numeric
* data, this is the maximum precision. For character data, this is the length in characters. For
* datetime datatypes, this is the length in characters of the String representation (assuming the
* maximum allowed precision of the fractional seconds component). For binary data, this is the
* length in bytes. For the ROWID datatype, this is the length in bytes. 0 is returned for data
* types where the column size is not applicable.
*
* @param param the first parameter is 1, the second is 2, ...
* @return precision
* @exception SQLException if a database access error occurs
* @since JDK 1.4, HSQLDB 1.7.2
*/
public int getPrecision(int param) throws SQLException {
checkRange(param);
Type type = translateType(rmd.columnTypes[--param]);
if (type.isDateTimeType()) {
return type.displaySize();
} else {
long size = type.precision;
if (size > Integer.MAX_VALUE) {
size = 0;
}
return (int) size;
}
}
/**
* Moves the data from an old store to new after changes to table The colindex argument is the
* index of the column that was added or removed. The adjust argument is {-1 | 0 | +1}
*/
public final void moveData(Session session, PersistentStore other, int colindex, int adjust) {
Object colvalue = null;
Type oldtype = null;
Type newtype = null;
if (adjust >= 0 && colindex != -1) {
ColumnSchema column = ((Table) table).getColumn(colindex);
colvalue = column.getDefaultValue(session);
if (adjust == 0) {
oldtype = ((Table) other.getTable()).getColumnTypes()[colindex];
newtype = ((Table) table).getColumnTypes()[colindex];
}
}
RowIterator it = other.rowIterator();
Table table = (Table) this.table;
try {
while (it.hasNext()) {
Row row = it.getNextRow();
Object[] o = row.getData();
Object[] data = table.getEmptyRowData();
if (adjust == 0 && colindex != -1) {
colvalue = newtype.convertToType(session, o[colindex], oldtype);
}
ArrayUtil.copyAdjustArray(o, data, colvalue, colindex, adjust);
table.systemSetIdentityColumn(session, data);
table.enforceTypeLimits(session, data);
table.enforceRowConstraints(session, data);
// get object without RowAction
Row newrow = (Row) getNewCachedObject(null, data);
indexRow(null, newrow);
}
} catch (java.lang.OutOfMemoryError e) {
throw Error.error(ErrorCode.OUT_OF_MEMORY);
}
}
public int precedenceDegree(Type other) {
if (other.isNumberType()) {
int otherWidth = ((NumberType) other).typeWidth;
return otherWidth - typeWidth;
}
return Integer.MIN_VALUE;
}
public boolean canConvertFrom(Type otherType) {
if (otherType.typeCode == Types.SQL_ALL_TYPES) {
return true;
}
if (otherType.isNumberType()) {
return true;
}
if (otherType.isIntervalType()) {
return true;
}
if (otherType.isCharacterType()) {
return true;
}
return false;
}
public static Type getAggregateType(Type add, Type existing) {
if (existing == null || existing.typeCode == Types.SQL_ALL_TYPES) {
return add;
}
if (add == null || add.typeCode == Types.SQL_ALL_TYPES) {
return existing;
}
return existing.getAggregateType(add);
}
public static Type getAggregatedType(Type add, Type existing) throws HsqlException {
if (existing == null || existing.type == Types.SQL_ALL_TYPES) {
return add;
}
if (add == null || add.type == Types.SQL_ALL_TYPES) {
return existing;
}
return existing.getAggregateType(add);
}
Object getValue(Session session, Type type, boolean isRasRoot) {
if (!rasType.isEmpty()) {
if (!isRasRoot) {
return valueData + rasType;
}
}
if (dataType == type || valueData == null) {
return valueData;
}
return type.convertToType(session, valueData, dataType);
}
void setColumnsIndexes(Table paramTable) {
int i;
Type localType;
if (this.constType == 0) {
if (this.mainColSet == null) {
this.core.mainCols = this.core.mainTable.getPrimaryKey();
if (this.core.mainCols == null) throw Error.error(5581);
} else if (this.core.mainCols == null) {
this.core.mainCols = this.core.mainTable.getColumnIndexes(this.mainColSet);
}
if (this.core.refCols == null)
this.core.refCols = paramTable.getColumnIndexes(this.refColSet);
for (i = 0; i < this.core.refCols.length; i++) {
localType = paramTable.getColumn(this.core.refCols[i]).getDataType();
if (localType.isLobType()) throw Error.error(5534);
}
} else if (this.mainColSet != null) {
this.core.mainCols = paramTable.getColumnIndexes(this.mainColSet);
for (i = 0; i < this.core.mainCols.length; i++) {
localType = paramTable.getColumn(this.core.mainCols[i]).getDataType();
if (localType.isLobType()) throw Error.error(5534);
}
}
}
public void resolveTypes(Session session, Expression parent) {
switch (opType) {
case OpTypes.DEFAULT:
if (parent != null && parent.opType != OpTypes.ROW) {
throw Error.error(ErrorCode.X_42544);
}
break;
case OpTypes.COALESCE:
{
Type type = null;
for (int i = 0; i < nodes.length; i++) {
type = Type.getAggregateType(nodes[i].dataType, type);
}
dataType = type;
break;
}
}
}
public Object convertToType(SessionInterface session, Object a, Type otherType)
throws HsqlException {
if (a == null) {
return a;
}
if (otherType.typeCode == typeCode) {
switch (typeCode) {
case Types.SQL_NUMERIC:
case Types.SQL_DECIMAL:
if (otherType.scale == scale && otherType.precision <= precision) {
return a;
}
break;
default:
return a;
}
}
if (otherType.isIntervalType()) {
int endType = ((IntervalType) otherType).endIntervalType;
switch (endType) {
case Types.SQL_INTERVAL_YEAR:
case Types.SQL_INTERVAL_MONTH:
case Types.SQL_INTERVAL_DAY:
case Types.SQL_INTERVAL_HOUR:
case Types.SQL_INTERVAL_MINUTE:
{
Long value = ValuePool.getLong(((IntervalType) otherType).convertToLong(a));
return convertToType(session, value, Type.SQL_BIGINT);
}
case Types.SQL_INTERVAL_SECOND:
{
long seconds = ((IntervalSecondData) a).units;
long nanos = ((IntervalSecondData) a).nanos;
BigDecimal value = ((DTIType) otherType).getSecondPart(seconds, nanos);
return value;
}
}
}
switch (otherType.typeCode) {
case Types.SQL_CLOB:
a = ((ClobData) a).getSubString(0L, (int) ((ClobData) a).length());
// fall through
case Types.SQL_CHAR:
case Types.SQL_VARCHAR:
case Types.VARCHAR_IGNORECASE:
{
a = session.getScanner().convertToNumber((String) a, this);
return convertToDefaultType(session, a);
}
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:
break;
default:
throw Error.error(ErrorCode.X_42561);
}
switch (this.typeCode) {
case Types.TINYINT:
case Types.SQL_SMALLINT:
case Types.SQL_INTEGER:
return convertToInt(a, this.typeCode);
case Types.SQL_BIGINT:
return convertToLong(a);
case Types.SQL_REAL:
case Types.SQL_FLOAT:
case Types.SQL_DOUBLE:
return convertToDouble(a);
case Types.SQL_NUMERIC:
case Types.SQL_DECIMAL:
BigDecimal value = convertToDecimal(a);
return convertToTypeLimits(value);
default:
throw Error.error(ErrorCode.X_42561);
}
}
/**
* Returns a SQL type "wide" enough to represent the result of the expression.<br>
* A type is "wider" than the other if it can represent all its numeric values.<br>
* Arithmetic operation terms are promoted to a type that can represent the resulting values and
* avoid incorrect results.
*
* <p>FLOAT/REAL/DOUBLE used in an operation results in the same type, regardless of the type of
* the other operand. When the result or the expression is converted to the type of the target
* column for storage, an exception is thrown if the resulting value cannot be stored in the
* column
*
* <p>Types narrower than INTEGER (int) are promoted to INTEGER. The order of promotion is as
* follows
*
* <p>INTEGER, BIGINT, NUMERIC/DECIMAL
*
* <p>TINYINT and SMALLINT in any combination return INTEGER<br>
* TINYINT/SMALLINT/INTEGER and INTEGER return BIGINT<br>
* TINYINT/SMALLINT/INTEGER and BIGINT return NUMERIC/DECIMAL<br>
* BIGINT and BIGINT return NUMERIC/DECIMAL<br>
* REAL/FLOAT/DOUBLE and any type return REAL/FLOAT/DOUBLE<br>
* NUMERIC/DECIMAL any type other than REAL/FLOAT/DOUBLE returns NUMERIC/DECIMAL<br>
* In the case of NUMERIC/DECIMAL returned, the result precision is always large enough to express
* any value result, while the scale depends on the operation:<br>
* For ADD/SUBTRACT/DIVIDE, the scale is the larger of the two<br>
* For MULTIPLY, the scale is the sum of the two scales<br>
*/
public Type getCombinedType(Type other, int operation) throws HsqlException {
if (other.typeCode == Types.SQL_ALL_TYPES) {
other = this;
}
switch (operation) {
case OpTypes.ADD:
break;
case OpTypes.MULTIPLY:
if (other.isIntervalType()) {
return other.getCombinedType(this, OpTypes.MULTIPLY);
}
break;
case OpTypes.DIVIDE:
case OpTypes.SUBTRACT:
default:
// all derivatives of equality ops or comparison ops
return getAggregateType(other);
}
// resolution for ADD and MULTIPLY only
if (!other.isNumberType()) {
throw Error.error(ErrorCode.X_42562);
}
if (typeWidth == DOUBLE_WIDTH || ((NumberType) other).typeWidth == DOUBLE_WIDTH) {
return Type.SQL_DOUBLE;
}
int sum = typeWidth + ((NumberType) other).typeWidth;
if (sum <= INTEGER_WIDTH) {
return Type.SQL_INTEGER;
}
if (sum <= BIGINT_WIDTH) {
return Type.SQL_BIGINT;
}
int newScale;
long newDigits;
switch (operation) {
// case OpCodes.DIVIDE :
// case OpCodes.SUBTRACT :
case OpTypes.ADD:
newScale = scale > other.scale ? scale : other.scale;
newDigits =
precision - scale > other.precision - other.scale
? precision - scale
: other.precision - other.scale;
newDigits++;
break;
case OpTypes.MULTIPLY:
newDigits = precision - scale + other.precision - other.scale;
newScale = scale + other.scale;
break;
default:
throw Error.runtimeError(ErrorCode.U_S0500, "NumberType");
}
return getNumberType(Types.SQL_DECIMAL, newScale + newDigits, newScale);
}
private void getFirstRow() {
if (currentJoinData == null
|| currentJoinData.length < conditions[condIndex].indexedColumnCount) {
currentJoinData = new Object[conditions[condIndex].indexedColumnCount];
}
for (int i = 0; i < conditions[condIndex].indexedColumnCount; i++) {
int range = 0;
int opType =
i == conditions[condIndex].indexedColumnCount - 1
? conditions[condIndex].opType
: conditions[condIndex].indexCond[i].getType();
if (opType == OpTypes.IS_NULL || opType == OpTypes.NOT || opType == OpTypes.MAX) {
currentJoinData[i] = null;
continue;
}
Type valueType = conditions[condIndex].indexCond[i].getRightNode().getDataType();
Object value = conditions[condIndex].indexCond[i].getRightNode().getValue(session);
Type targetType = conditions[condIndex].indexCond[i].getLeftNode().getDataType();
if (targetType != valueType) {
range = targetType.compareToTypeRange(value);
if (range == 0) {
if (targetType.typeComparisonGroup != valueType.typeComparisonGroup) {
value = targetType.convertToType(session, value, valueType);
}
}
}
if (i == 0) {
int exprType = conditions[condIndex].indexCond[0].getType();
if (range < 0) {
switch (exprType) {
case OpTypes.GREATER:
case OpTypes.GREATER_EQUAL:
case OpTypes.GREATER_EQUAL_PRE:
value = null;
break;
default:
it = conditions[condIndex].rangeIndex.emptyIterator();
return;
}
} else if (range > 0) {
switch (exprType) {
case OpTypes.NOT:
value = null;
break;
default:
it = conditions[condIndex].rangeIndex.emptyIterator();
return;
}
}
}
currentJoinData[i] = value;
}
it =
conditions[condIndex].rangeIndex.findFirstRow(
session,
store,
currentJoinData,
conditions[condIndex].indexedColumnCount,
rangeVar.indexDistinctCount,
conditions[condIndex].opType,
conditions[condIndex].reversed,
null);
}
public Object readData(Type type) throws IOException {
Object o = null;
if (readNull()) {
return null;
}
switch (type.typeCode) {
case Types.SQL_ALL_TYPES:
break;
case Types.SQL_CHAR:
case Types.SQL_VARCHAR:
case Types.VARCHAR_IGNORECASE:
o = readChar(type);
break;
case Types.TINYINT:
case Types.SQL_SMALLINT:
o = readSmallint();
break;
case Types.SQL_INTEGER:
o = readInteger();
break;
case Types.SQL_BIGINT:
o = readBigint();
break;
case Types.SQL_REAL:
case Types.SQL_FLOAT:
case Types.SQL_DOUBLE:
o = readReal();
break;
case Types.SQL_NUMERIC:
case Types.SQL_DECIMAL:
o = readDecimal(type);
break;
case Types.SQL_DATE:
o = readDate(type);
break;
case Types.SQL_TIME:
case Types.SQL_TIME_WITH_TIME_ZONE:
o = readTime(type);
break;
case Types.SQL_TIMESTAMP:
case Types.SQL_TIMESTAMP_WITH_TIME_ZONE:
o = readTimestamp(type);
break;
case Types.SQL_INTERVAL_YEAR:
case Types.SQL_INTERVAL_YEAR_TO_MONTH:
case Types.SQL_INTERVAL_MONTH:
o = readYearMonthInterval(type);
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:
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:
o = readDaySecondInterval(type);
break;
case Types.SQL_BOOLEAN:
o = readBoole();
break;
case Types.OTHER:
o = readOther();
break;
case Types.SQL_CLOB:
o = readClob();
break;
case Types.SQL_BLOB:
o = readBlob();
break;
case Types.SQL_ARRAY:
o = readArray(type);
break;
case Types.SQL_BINARY:
case Types.SQL_VARBINARY:
o = readBinary();
break;
case Types.SQL_BIT:
case Types.SQL_BIT_VARYING:
o = readBit();
break;
default:
throw Error.runtimeError(ErrorCode.U_S0500, "RowInputBase - " + type.getNameString());
}
return o;
}
ResultMetaData(RowInputBinary in) throws IOException {
type = in.readInt();
columnCount = in.readInt();
switch (type) {
case UPDATE_RESULT_METADATA:
case SIMPLE_RESULT_METADATA:
{
columnTypes = new Type[columnCount];
for (int i = 0; i < columnCount; i++) {
int type = in.readType();
columnTypes[i] = Type.getDefaultType(type);
}
return;
}
case GENERATED_INDEX_METADATA:
{
colIndexes = new int[columnCount];
for (int i = 0; i < columnCount; i++) {
colIndexes[i] = in.readInt();
}
return;
}
case GENERATED_NAME_METADATA:
{
columnLabels = new String[columnCount];
for (int i = 0; i < columnCount; i++) {
columnLabels[i] = in.readString();
}
return;
}
case PARAM_METADATA:
{
columnTypes = new Type[columnCount];
columnLabels = new String[columnCount];
paramModes = new byte[columnCount];
paramNullable = new byte[columnCount];
for (int i = 0; i < columnCount; i++) {
columnTypes[i] = readDataType(in);
columnLabels[i] = in.readString();
decodeParamColumnAttrs(in.readByte(), i);
}
return;
}
case RESULT_METADATA:
{
extendedColumnCount = in.readInt();
columnTypes = new Type[extendedColumnCount];
columnLabels = new String[columnCount];
columns = new ColumnBase[columnCount];
if (columnCount != extendedColumnCount) {
colIndexes = new int[columnCount];
}
for (int i = 0; i < extendedColumnCount; i++) {
Type type = readDataType(in);
columnTypes[i] = type;
}
for (int i = 0; i < columnCount; i++) {
columnLabels[i] = in.readString();
String catalog = in.readString();
String schema = in.readString();
String table = in.readString();
String name = in.readString();
ColumnBase column = new ColumnBase(catalog, schema, table, name);
column.setType(columnTypes[i]);
decodeTableColumnAttrs(in.readByte(), column);
columns[i] = column;
}
if (columnCount != extendedColumnCount) {
for (int i = 0; i < columnCount; i++) {
colIndexes[i] = in.readInt();
}
}
return;
}
default:
{
throw Error.runtimeError(ErrorCode.U_S0500, "ResultMetaData");
}
}
}