| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| /* |
| * $Id: PgType.java 3481 2010-02-26 18:05:06Z fredt $ |
| */ |
| |
| package org.hsqldb.server; |
| |
| import org.hsqldb.types.Type; |
| import org.hsqldb.types.Types; |
| import org.hsqldb.types.NumberType; |
| import org.hsqldb.types.BooleanType; |
| import org.hsqldb.types.CharacterType; |
| import org.hsqldb.types.DateTimeType; |
| import org.hsqldb.Session; |
| import org.hsqldb.types.Types; |
| import java.sql.SQLException; |
| import java.io.Serializable; |
| import org.hsqldb.types.JavaObjectData; |
| import org.hsqldb.HsqlException; |
| import org.hsqldb.types.BinaryData; |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.jdbc.Util; |
| |
| public class PgType { |
| private int oid; |
| private int typeWidth = -1; |
| private int lpConstraint = -1; // Length or Precision |
| private Type hType; |
| |
| public int getOid() { |
| return oid; |
| } |
| public int getTypeWidth() { |
| return typeWidth; |
| } |
| public int getLPConstraint() { |
| return lpConstraint; |
| } |
| |
| /** |
| * Convenience wrapper for PgType constructor, when there is no |
| * type width, length, or precision setting for the type. |
| * |
| * @see #PgType(Type, int, Integer, Integer) |
| */ |
| protected PgType(Type hType, int oid) { |
| this(hType, oid, null, null); |
| } |
| |
| /** |
| * Convenience wrapper for PgType constructor, when there is no |
| * length or precision setting for the type. |
| * |
| * @see #PgType(Type, int, Integer, Integer) |
| */ |
| protected PgType(Type hType, int oid, int typeWidth) { |
| this(hType, oid, new Integer(typeWidth), null); |
| } |
| |
| /** |
| * Convenience wrapper for PgType constructor, when there is no fixed |
| * width for the type. |
| * |
| * @param dummy Normally pass null. This is a dummy parameter just to make |
| * a unique method signature. If non-null, will be treated |
| * exactly the same as the typeWidthObject from the 3-param |
| * constructor. |
| * @see #PgType(Type, int, Integer, Integer) |
| */ |
| protected PgType(Type hType, int oid, Integer dummy, long lpConstraint) |
| throws RecoverableOdbcFailure { |
| this(hType, oid, dummy, new Integer((int) lpConstraint)); |
| if (lpConstraint < 0) { |
| throw new RecoverableOdbcFailure( |
| "Length/Precision value is below minimum value of 0"); |
| } |
| if (lpConstraint > Integer.MAX_VALUE) { |
| throw new RecoverableOdbcFailure( |
| "Length/Precision value is above maximum value of " |
| + Integer.MAX_VALUE); |
| } |
| } |
| |
| /** |
| * @param hType HyperSQL data type |
| * @param oid Numeric Object ID for the driver-side type. |
| * @param typeWidthObject Fixed width for the type |
| * @param lpConstraintObject Either length or Precision setting for this |
| * instance of the type. |
| * <b>IMPORTANT!</b> for all types with positive |
| * lpConstraint other than Timestamps and Times, |
| * add an extra 4 to satisy crazy driver protocol. |
| */ |
| protected PgType(Type hType, |
| int oid, Integer typeWidthObject, Integer lpConstraintObject) { |
| this.hType = hType; |
| this.oid = oid; |
| this.typeWidth = (typeWidthObject == null) |
| ? -1 : typeWidthObject.intValue(); |
| this.lpConstraint = (lpConstraintObject == null) |
| ? -1 : lpConstraintObject.intValue(); |
| } |
| |
| static public PgType getPgType(Type hType, boolean directColumn) |
| throws RecoverableOdbcFailure { |
| switch (hType.typeCode) { |
| case Types.TINYINT: |
| return tinyIntSingleton; |
| case Types.SQL_SMALLINT: |
| return int2singleton; |
| case Types.SQL_INTEGER: |
| return int4singleton; |
| case Types.SQL_BIGINT: |
| return int8singleton; |
| |
| case Types.SQL_NUMERIC: |
| case Types.SQL_DECIMAL: |
| return new PgType(hType, TYPE_NUMERIC, null, |
| (hType.precision << 16) + hType.scale + 4); |
| |
| case Types.SQL_FLOAT: |
| // TODO: |
| // Improve the driver to make use of the Float precision |
| // return new PgType(hType, TYPE_FLOAT8, null, hType.precision); |
| case Types.SQL_DOUBLE: |
| case Types.SQL_REAL: |
| return doubleSingleton; |
| |
| case Types.BOOLEAN: |
| return boolSingleton; |
| |
| case Types.SQL_CHAR: // = CHARACTER |
| if (directColumn) { |
| return new PgType(hType, |
| TYPE_BPCHAR, null, hType.precision + 4); |
| } |
| return unknownSingleton; // constant value |
| |
| case Types.SQL_VARCHAR: // = CHARACTER VARYING = LONGVARCHAR |
| case Types.VARCHAR_IGNORECASE: // Don't know if possible here |
| if (hType.precision < 0) { |
| throw new RecoverableOdbcFailure ( |
| "Length/Precision value is below minimum value of 0"); |
| } |
| if (hType.precision > Integer.MAX_VALUE) { |
| throw new RecoverableOdbcFailure ( |
| "Length/Precision value is above maximum value of " |
| + Integer.MAX_VALUE); |
| } |
| return (hType.precision != 0 && directColumn) |
| ? new PgType(hType, TYPE_VARCHAR, null, hType.precision + 4) |
| : textSingleton; |
| // Return TEXT type for both unlimited VARCHARs, and for |
| // Non-direct-table-col results. |
| case Types.SQL_CLOB: // = CHARACTER LARGE OBJECT |
| throw new RecoverableOdbcFailure ( |
| "Driver doesn't support type 'CLOB' yet"); |
| |
| case Types.SQL_BLOB: // = BINARY LARGE OBJECT |
| return new PgType(hType, TYPE_BLOB, null, hType.precision); |
| case Types.SQL_BINARY: |
| case Types.SQL_VARBINARY: // = BINARY VARYING |
| return new PgType(hType, TYPE_BYTEA, null, hType.precision); |
| // Note that we are returning SQL_BINARY data as if they were |
| // variable. I don't think the unnecessary variability will |
| // have any side-effects. |
| // No reason to differentiate here, since the client's |
| // atttypm parameter is where we would communicate the length |
| // in both cases. |
| |
| case Types.OTHER: |
| throw new RecoverableOdbcFailure ( |
| "Driver doesn't support type 'OTHER' yet"); |
| |
| case Types.SQL_BIT: |
| return bitSingleton; |
| case Types.SQL_BIT_VARYING: |
| return bitVaryingSingleton; |
| // I have no idea why length contstaint spec is not needed for |
| // BIT_VARYING. |
| |
| case Types.SQL_DATE: |
| return dateSingleton; |
| |
| // 4 bytes |
| case Types.SQL_TIME : |
| return new PgType(hType, TYPE_TIME, new Integer(8), |
| hType.precision); |
| |
| case Types.SQL_TIME_WITH_TIME_ZONE : |
| return new PgType(hType, TYPE_TIME_WITH_TMZONE, |
| new Integer(12), hType.precision); |
| |
| case Types.SQL_TIMESTAMP : |
| return new PgType(hType, TYPE_TIMESTAMP_NO_TMZONE, |
| new Integer(8), hType.precision); |
| |
| case Types.SQL_TIMESTAMP_WITH_TIME_ZONE : |
| return new PgType(hType, TYPE_TIMESTAMP, new Integer(8), |
| hType.precision); |
| |
| // Postgresql is returning type DATETIME for this case. |
| // It should return TYPE_TIMESTAMP, no? |
| /* ********************************************************* |
| * For INTERVALs, we get the more specific type here, not just |
| * SQL_INTERVAL. |
| case Types.SQL_INTERVAL: |
| * |
| * The reason no precisions are passed to the ODBC client is that I |
| * have so far been unsuccessful at figuring out exactly how the |
| * driver wants the atttypmod formatted. See doc/odbc.txt for |
| * notes about this. |
| */ |
| case Types.SQL_INTERVAL_YEAR: |
| case Types.SQL_INTERVAL_YEAR_TO_MONTH: |
| case Types.SQL_INTERVAL_MONTH: |
| // Need to test these, since the driver Interval type is |
| // intended for second-resolution only, not month resolution. |
| throw new RecoverableOdbcFailure ( |
| "Driver doesn't support month-resolution 'INTERVAL's yet"); |
| case Types.SQL_INTERVAL_DAY: |
| case Types.SQL_INTERVAL_DAY_TO_HOUR: |
| case Types.SQL_INTERVAL_DAY_TO_MINUTE: |
| case Types.SQL_INTERVAL_HOUR: |
| case Types.SQL_INTERVAL_HOUR_TO_MINUTE: |
| case Types.SQL_INTERVAL_MINUTE: |
| // Our server uses the type to distinguish the resolution here. |
| // The driver expects these types to be distinguished in the |
| // value itself, like "99 days". |
| // Therefore, these types are incompatible until driver is |
| // enhanced. |
| throw new RecoverableOdbcFailure ( |
| "Driver doesn't support non-second-resolution 'INTERVAL's " |
| + "yet"); |
| case Types.SQL_INTERVAL_DAY_TO_SECOND: |
| PgType.ignoredConstraintWarning(hType); |
| return daySecIntervalSingleton; |
| case Types.SQL_INTERVAL_HOUR_TO_SECOND: |
| PgType.ignoredConstraintWarning(hType); |
| return hourSecIntervalSingleton; |
| case Types.SQL_INTERVAL_MINUTE_TO_SECOND: |
| PgType.ignoredConstraintWarning(hType); |
| return minSecIntervalSingleton; |
| case Types.SQL_INTERVAL_SECOND: |
| PgType.ignoredConstraintWarning(hType); |
| return secIntervalSingleton; |
| |
| default: |
| throw new RecoverableOdbcFailure ( |
| "Unsupported type: " + hType.getNameString()); |
| } |
| } |
| |
| /** |
| * This method copied from JDBCPreparedStatement.java. |
| * |
| * The internal parameter value setter always converts the parameter to |
| * the Java type required for data transmission. |
| * <P> |
| * This method will not be called for binary types. Binary values are |
| * just loaded directly into the Object parameter array. |
| * </P> |
| * |
| * @throws SQLException if either argument is not acceptable. |
| */ |
| public Object getParameter(String inString, Session session) |
| throws SQLException, RecoverableOdbcFailure { |
| if (inString == null) { |
| return null; |
| } |
| Object o = inString; |
| |
| switch (hType.typeCode) { |
| case Types.SQL_BOOLEAN : |
| if (inString.length() == 1) switch (inString.charAt(0)) { |
| case 'T': |
| case 't': |
| case 'Y': |
| case 'y': |
| case '1': |
| return Boolean.TRUE; |
| default: |
| return Boolean.FALSE; |
| } |
| return Boolean.valueOf(inString); |
| |
| case Types.SQL_BINARY : |
| case Types.SQL_VARBINARY : |
| case Types.SQL_BLOB : |
| throw new RecoverableOdbcFailure( |
| "This data type should be transmitted to server in binary " |
| + "format: " + hType.getNameString()); |
| |
| case Types.OTHER : |
| case Types.SQL_CLOB : |
| throw new RecoverableOdbcFailure( |
| "Type not supported yet: " + hType.getNameString()); |
| /* |
| case Types.OTHER : |
| try { |
| if (o instanceof Serializable) { |
| o = new JavaObjectData((Serializable) o); |
| |
| break; |
| } |
| } catch (HsqlException e) { |
| PgType.throwError(e); |
| } |
| PgType.throwError(Error.error(ErrorCode.X_42565)); |
| |
| break; |
| case Types.SQL_BLOB : |
| //setBlobParameter(i, o); |
| |
| //break; |
| case Types.SQL_CLOB : |
| //setClobParameter(i, o); |
| |
| //break; |
| */ |
| case Types.SQL_DATE : |
| case Types.SQL_TIME_WITH_TIME_ZONE : |
| case Types.SQL_TIMESTAMP_WITH_TIME_ZONE : |
| case Types.SQL_TIME : |
| case Types.SQL_TIMESTAMP : { |
| try { |
| o = hType.convertToType(session, o, Type.SQL_VARCHAR); |
| } catch (HsqlException e) { |
| PgType.throwError(e); |
| } |
| break; |
| } |
| |
| 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 : |
| try { |
| o = hType.convertToType(session, o, Type.SQL_VARCHAR); |
| } catch (HsqlException e) { |
| PgType.throwError(e); |
| } |
| break; |
| default : |
| /* |
| throw new RecoverableOdbcFailure( |
| "Parameter value is of unexpected type: " |
| + hType.getNameString()); |
| */ |
| try { |
| o = hType.convertToDefaultType(session, o); |
| // Supposed to handle String -> SQL_BIT. Not working. |
| } catch (HsqlException e) { |
| PgType.throwError(e); |
| } |
| break; |
| } |
| return o; |
| } |
| |
| public String valueString(Object datum) { |
| String dataString = hType.convertToString(datum); |
| switch (hType.typeCode) { |
| case Types.SQL_BOOLEAN : |
| return String.valueOf(((Boolean) datum).booleanValue() |
| ? 't' : 'f'); |
| // Default would probably work fine, since the Driver looks at |
| // only the first byte, but this why send an extra 3 or 4 bytes |
| // with every data, plus there could be some dependency upon |
| // single-character in the driver code somewhere. |
| case Types.SQL_VARBINARY : |
| case Types.SQL_BINARY : |
| dataString = OdbcUtil.hexCharsToOctalOctets(dataString); |
| break; |
| } |
| return dataString; |
| } |
| |
| /* |
| * The followign settings are a Java port of pgtypes.h |
| */ |
| public static final int TYPE_BOOL = 16; |
| public static final int TYPE_BYTEA = 17; |
| public static final int TYPE_CHAR = 18; |
| public static final int TYPE_NAME = 19; |
| public static final int TYPE_INT8 = 20; |
| public static final int TYPE_INT2 = 21; |
| public static final int TYPE_INT2VECTOR = 22; |
| public static final int TYPE_INT4 = 23; |
| public static final int TYPE_REGPROC = 24; |
| public static final int TYPE_TEXT = 25; |
| public static final int TYPE_OID = 26; |
| public static final int TYPE_TID = 27; |
| public static final int TYPE_XID = 28; |
| public static final int TYPE_CID = 29; |
| public static final int TYPE_OIDVECTOR = 30; |
| public static final int TYPE_SET = 32; |
| public static final int TYPE_XML = 142; |
| public static final int TYPE_XMLARRAY = 143; |
| public static final int TYPE_CHAR2 = 409; |
| public static final int TYPE_CHAR4 = 410; |
| public static final int TYPE_CHAR8 = 411; |
| public static final int TYPE_POINT = 600; |
| public static final int TYPE_LSEG = 601; |
| public static final int TYPE_PATH = 602; |
| public static final int TYPE_BOX = 603; |
| public static final int TYPE_POLYGON = 604; |
| public static final int TYPE_FILENAME = 605; |
| public static final int TYPE_CIDR = 650; |
| public static final int TYPE_FLOAT4 = 700; |
| public static final int TYPE_FLOAT8 = 701; |
| public static final int TYPE_ABSTIME = 702; |
| public static final int TYPE_RELTIME = 703; |
| public static final int TYPE_TINTERVAL = 704; |
| public static final int TYPE_UNKNOWN = 705; |
| public static final int TYPE_MONEY = 790; |
| public static final int TYPE_OIDINT2 = 810; |
| public static final int TYPE_MACADDR = 829; |
| public static final int TYPE_INET = 869; |
| public static final int TYPE_OIDINT4 = 910; |
| public static final int TYPE_OIDNAME = 911; |
| public static final int TYPE_TEXTARRAY = 1009; |
| public static final int TYPE_BPCHARARRAY = 1014; |
| public static final int TYPE_VARCHARARRAY = 1015; |
| public static final int TYPE_BPCHAR = 1042; |
| public static final int TYPE_VARCHAR = 1043; |
| public static final int TYPE_DATE = 1082; |
| public static final int TYPE_TIME = 1083; |
| public static final int TYPE_TIMESTAMP_NO_TMZONE = 1114; /* since 7.2 */ |
| public static final int TYPE_DATETIME = 1184; |
| public static final int TYPE_TIME_WITH_TMZONE = 1266; /* since 7.1 */ |
| public static final int TYPE_TIMESTAMP = 1296; /* deprecated since 7.0 */ |
| public static final int TYPE_NUMERIC = 1700; |
| public static final int TYPE_RECORD = 2249; |
| public static final int TYPE_VOID = 2278; |
| public static final int TYPE_UUID = 2950; |
| |
| // Numbering new HyperSQL-only client-side types beginning with 9999 and |
| // getting lower, to reduce chance of conflict with future PostreSQL types. |
| public static final int TYPE_BLOB = 9998; |
| public static final int TYPE_TINYINT = 9999; |
| |
| // Apparenly new additions, from Postgresql server file pg_type.h: |
| public static final int TYPE_BIT = 1560; |
| // Also defined is _bit. No idea what that is about |
| public static final int TYPE_VARBIT = 1562; |
| // Also defined is _varbit. No idea what that is about |
| |
| /* Following stuff is to support code copied from |
| * JDBCPreparedStatement.java. */ |
| static final void throwError(HsqlException e) throws SQLException { |
| |
| //#ifdef JAVA6 |
| throw Util.sqlException(e.getMessage(), e.getSQLState(), |
| e.getErrorCode(), e); |
| |
| //#else |
| /* |
| throw new SQLException(e.getMessage(), e.getSQLState(), |
| e.getErrorCode()); |
| */ |
| |
| //#endif JAVA6 |
| } |
| |
| static protected final PgType tinyIntSingleton = |
| new PgType(Type.TINYINT, TYPE_TINYINT, 1); |
| static protected final PgType int2singleton = |
| new PgType(Type.SQL_SMALLINT, TYPE_INT2, 2); |
| static protected final PgType int4singleton = |
| new PgType(Type.SQL_INTEGER, TYPE_INT4, 4); |
| static protected final PgType int8singleton = |
| new PgType(Type.SQL_BIGINT, TYPE_INT8, 8); |
| static protected final PgType doubleSingleton = |
| new PgType(Type.SQL_DOUBLE, TYPE_FLOAT8, 8); |
| static protected final PgType boolSingleton = |
| new PgType(Type.SQL_BOOLEAN, TYPE_BOOL, 1); |
| static protected final PgType textSingleton = |
| new PgType(Type.SQL_VARCHAR, TYPE_TEXT); |
| static protected final PgType dateSingleton = |
| new PgType(Type.SQL_DATE, TYPE_DATE, 4); |
| static protected final PgType unknownSingleton = |
| new PgType(Type.SQL_CHAR_DEFAULT, TYPE_UNKNOWN, -2); |
| static protected final PgType bitSingleton = |
| new PgType(Type.SQL_BIT, TYPE_BIT); |
| static protected final PgType bitVaryingSingleton = |
| new PgType(Type.SQL_BIT_VARYING, TYPE_VARBIT); |
| static protected final PgType daySecIntervalSingleton = |
| new PgType(Type.SQL_INTERVAL_DAY_TO_SECOND, TYPE_TINTERVAL, 16); |
| static protected final PgType hourSecIntervalSingleton = |
| new PgType(Type.SQL_INTERVAL_HOUR_TO_SECOND, TYPE_TINTERVAL, 16); |
| static protected final PgType minSecIntervalSingleton = |
| new PgType(Type.SQL_INTERVAL_MINUTE_TO_SECOND, TYPE_TINTERVAL, 16); |
| static protected final PgType secIntervalSingleton = |
| new PgType(Type.SQL_INTERVAL_SECOND, TYPE_TINTERVAL, 16); |
| |
| static private void ignoredConstraintWarning(Type hsqldbType) { |
| if (hsqldbType.precision == 0 && hsqldbType.scale == 0) { |
| return; |
| } |
| // TODO: Use logging system! |
| /* |
| System.err.println( |
| "WARNING: Not passing INTERVAL precision setting " |
| + "or second precision setting to ODBC client"); |
| */ |
| } |
| } |
