//jTDS JDBC Driver for Microsoft SQL Server and Sybase
//Copyright (C) 2004 The jTDS Project
//
//This library is free software; you can redistribute it and/or
//modify it under the terms of the GNU Lesser General Public
//License as published by the Free Software Foundation; either
//version 2.1 of the License, or (at your option) any later version.
//
//This library is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//Lesser General Public License for more details.
//
//You should have received a copy of the GNU Lesser General Public
//License along with this library; if not, write to the Free Software
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
package net.sourceforge.jtds.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
/**
* Represents an SQL data type as required by <code>getTypeInfo()</code>.
* Provides a suitable natural ordering.
* <p/>
* This class probably shouldn't be public, but is required to be so by the
* tests.
*
* @author David Eaves
* @version $Id: TypeInfo.java,v 1.5 2005-07-27 11:02:34 alin_sinpalean Exp $
*/
public class TypeInfo implements Comparable {
static final int NUM_COLS = 18;
private final String typeName;
private final int dataType;
private final int precision;
private final String literalPrefix;
private final String literalSuffix;
private final String createParams;
private final short nullable;
private final boolean caseSensitive;
private final short searchable;
private final boolean unsigned;
private final boolean fixedPrecScale;
private final boolean autoIncrement;
private final String localTypeName;
private final short minimumScale;
private final short maximumScale;
private final int sqlDataType;
private final int sqlDatetimeSub;
private final int numPrecRadix;
private final int normalizedType;
private final int distanceFromJdbcType;
public TypeInfo(ResultSet rs, boolean useLOBs) throws SQLException {
typeName = rs.getString(1);
dataType = rs.getInt(2);
precision = rs.getInt(3);
literalPrefix = rs.getString(4);
literalSuffix = rs.getString(5);
createParams = rs.getString(6);
nullable = rs.getShort(7);
caseSensitive = rs.getBoolean(8);
searchable = rs.getShort(9);
unsigned = rs.getBoolean(10);
fixedPrecScale = rs.getBoolean(11);
autoIncrement = rs.getBoolean(12);
localTypeName = rs.getString(13);
if (rs.getMetaData().getColumnCount() >= 18) {
// Some servers provide more information
minimumScale = rs.getShort(14);
maximumScale = rs.getShort(15);
sqlDataType = rs.getInt(16);
sqlDatetimeSub = rs.getInt(17);
numPrecRadix = rs.getInt(18);
} else {
// Must initialize final fields
minimumScale = 0;
maximumScale = 0;
sqlDataType = 0;
sqlDatetimeSub = 0;
numPrecRadix = 0;
}
normalizedType = normalizeDataType(dataType, useLOBs);
distanceFromJdbcType = determineDistanceFromJdbcType();
}
/**
* For testing only. Create an instance with just the properties utilised
* in the <code>compareTo()</code> method (set name, type, and auto
* increment).
*/
public TypeInfo(String typeName, int dataType, boolean autoIncrement) {
this.typeName = typeName;
this.dataType = dataType;
this.autoIncrement = autoIncrement;
this.precision = 0;
this.literalPrefix = null;
this.literalSuffix = null;
this.createParams = null;
this.nullable = 0;
this.caseSensitive = false;
this.searchable = 0;
this.unsigned = false;
this.fixedPrecScale = false;
this.localTypeName = null;
this.minimumScale = 0;
this.maximumScale = 0;
this.sqlDataType = 0;
this.sqlDatetimeSub = 0;
this.numPrecRadix = 0;
normalizedType = normalizeDataType(dataType, true);
distanceFromJdbcType = determineDistanceFromJdbcType();
}
public boolean equals(Object o) {
if (o instanceof TypeInfo) {
return compareTo(o) == 0;
}
return false;
}
public int hashCode() {
return normalizedType * dataType * (autoIncrement ? 7 : 11);
}
public String toString() {
return typeName + " ("
+ (dataType != normalizedType ? dataType + "->" : "")
+ normalizedType + ')';
}
public void update(ResultSet rs) throws SQLException {
rs.updateString(1, typeName);
rs.updateInt(2, normalizedType);
rs.updateInt(3, precision);
rs.updateString(4, literalPrefix);
rs.updateString(5, literalSuffix);
rs.updateString(6, createParams);
rs.updateShort(7, nullable);
rs.updateBoolean(8, caseSensitive);
rs.updateShort(9, searchable);
rs.updateBoolean(10, unsigned);
rs.updateBoolean(11, fixedPrecScale);
rs.updateBoolean(12, autoIncrement);
rs.updateString(13, localTypeName);
if (rs.getMetaData().getColumnCount() >= 18) {
// Some servers provide more information
rs.updateShort(14, minimumScale);
rs.updateShort(15, maximumScale);
rs.updateInt(16, sqlDataType);
rs.updateInt(17, sqlDatetimeSub);
rs.updateInt(18, numPrecRadix);
}
}
/**
* Comparable implementation that orders by dataType, then by how closely
* the data type maps to the corresponding JDBC SQL type.
* <p/>
* The data type values for the non-standard SQL Server types tend to have
* negative numbers while the corresponding standard types have positive
* numbers so utilise that in the sorting.
*/
public int compareTo(Object o) {
TypeInfo other = ((TypeInfo) o);
// Order by normalised type, then proximity to standard JDBC type.
return compare(normalizedType, other.normalizedType) * 10 +
compare(distanceFromJdbcType, other.distanceFromJdbcType);
}
private int compare(int i1, int i2) {
return i1 < i2 ? -1 : (i1 == i2 ? 0 : 1);
}
/**
* Determine how close this type is to the corresponding JDBC type. Used in
* sorting to distinguish between types that have the same
* <code>normalizedType</code> value.
*
* @return positive integer indicating how far away the type is from the
* corresponding JDBC type, with zero being the nearest possible
* match and 9 being the least
*/
private int determineDistanceFromJdbcType() {
// TODO: Are these assumptions correct/complete?
switch (dataType) {
// Cases without an un-normalized alternative, so these are the
// best available
case 11: // Sybase DATETIME
case 10: // Sybase TIME
case 9: // Sybase DATE
case 6: // FLOAT
return 0;
case 12: // VARCHAR, SYSNAME and NVARCHAR all together with Sybase
if (typeName.equalsIgnoreCase("varchar")) {
return 0;
}
if (typeName.equalsIgnoreCase("nvarchar")) {
return 1;
}
return 2;
// Special case as the same data type value is used for SYSNAME and
// NVARCHAR (SYSNAME is essentially an alias for NVARCHAR). We
// don't want applications preferring SYSNAME.
case -9: // SYSNAME / NVARCHAR
return typeName.equalsIgnoreCase("sysname") ? 4 : 3;
// Particularly non-standard types
case -11: // UNIQUEIDENTIFIER
return 9;
case -150: // SQL_VARIANT
return 8;
// Default behaviour is to assume that if type has not been
// normalised it is the closest available match, unless it is an
// auto incrementing type
default:
return (dataType == normalizedType && !autoIncrement) ? 0 : 5;
}
}
/**
* Return a {@link java.sql.Types}-defined type for an SQL Server specific data type.
*
* @param serverDataType the data type, as returned by the server
* @param useLOBs whether LOB data types are used for large types
* @return the equivalent data type defined by <code>java.sql.Types</code>
*/
public static int normalizeDataType(int serverDataType, boolean useLOBs) {
switch (serverDataType) {
case 35: // Sybase UNIVARCHAR
return Types.VARCHAR;
case 11: // Sybase DATETIME
return Types.TIMESTAMP;
case 10: // Sybase TIME
return Types.TIME;
case 9: // Sybase DATE
return Types.DATE;
case 6: // FLOAT
return Types.DOUBLE;
case -1: // LONGVARCHAR
return useLOBs ? Types.CLOB : Types.LONGVARCHAR;
case -4: // LONGVARBINARY
return useLOBs ? Types.BLOB : Types.LONGVARBINARY;
case -8: // NCHAR
return Types.CHAR;
case -9: // SYSNAME / NVARCHAR
return Types.VARCHAR;
case -10: // NTEXT
return useLOBs ? Types.CLOB : Types.LONGVARCHAR;
case -11: // UNIQUEIDENTIFIER
return Types.CHAR;
case -150: // SQL_VARIANT
return Types.VARCHAR;
default:
return serverDataType;
}
}
}
