github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[#456] Add runtime support for PRECISION, SCALE, and LENGTH attributes

Browse Source 
- Renamed AbstractDataType to DefaultDataType, made it non-abstract
- Removed [SQLDialect]DataType from DefaultDataType's type hierarchy
This commit is contained in:
Lukas Eder 2012-12-21 20:54:14 +01:00
parent e3de50d152
commit 623ee20bb6
30 changed files with 1380 additions and 1559 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
View File

@ -67,7 +67,7 @@ import org.jooq.UDT;
import org.jooq.UDTField;
import org.jooq.UniqueKey;
import org.jooq.exception.SQLDialectNotSupportedException;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.AbstractKeys;
import org.jooq.impl.AbstractRoutine;
import org.jooq.impl.ArrayRecordImpl;
@ -2422,7 +2422,7 @@ public class JavaGenerator extends AbstractGenerator {
// Try finding a basic standard SQL type according to the current dialect
else {
try {
Class<?> clazz = AbstractDataType.getType(db.getDialect(), t, p, s);
Class<?> clazz = DefaultDataType.getType(db.getDialect(), t, p, s);
type = clazz.getCanonicalName();
if (clazz.getTypeParameters().length > 0) {
@ -2471,7 +2471,7 @@ public class JavaGenerator extends AbstractGenerator {
sb.append(".");
sb.append(db.getDialect().getName());
sb.append("DataType.");
sb.append(AbstractDataType.normalise(AbstractDataType.getDataType(db.getDialect(), String.class).getTypeName()));
sb.append(DefaultDataType.normalise(DefaultDataType.getDataType(db.getDialect(), String.class).getTypeName()));
sb.append(".asEnumDataType(");
sb.append(getStrategy().getFullJavaClassName(db.getEnum(schema, u)));
sb.append(".class)");
@ -2480,7 +2480,7 @@ public class JavaGenerator extends AbstractGenerator {
DataType<?> dataType = null;
try {
dataType = AbstractDataType.getDataType(db.getDialect(), t, p, s);
dataType = DefaultDataType.getDataType(db.getDialect(), t, p, s);
}
// Mostly because of unsupported data types. Will be handled later.
@ -2494,7 +2494,7 @@ public class JavaGenerator extends AbstractGenerator {
sb.append(SQLDataType.class.getCanonicalName());
sb.append(".");
sb.append(AbstractDataType.normalise(sqlDataType.getTypeName()));
sb.append(DefaultDataType.normalise(sqlDataType.getTypeName()));
if (db.getConfiguredCustomType(u) != null) {
sb.append(".asConvertedDataType(new ");
@ -2518,14 +2518,14 @@ public class JavaGenerator extends AbstractGenerator {
try {
String type1 = getType(db, schema, t, p, s, u, null);
String type2 = getType(db, schema, t, 0, 0, u, null);
String typeName = AbstractDataType.normalise(t);
String typeName = DefaultDataType.normalise(t);
// [#1298] Prevent compilation errors for missing types
Reflect.on(typeClass).field(typeName);
sb.append(typeName);
if (!type1.equals(type2)) {
Class<?> clazz = AbstractDataType.getType(db.getDialect(), t, p, s);
Class<?> clazz = DefaultDataType.getType(db.getDialect(), t, p, s);
sb.append(".asNumberDataType(");
sb.append(clazz.getCanonicalName());

8
jOOQ-meta/src/main/java/org/jooq/util/AbstractTypedElementDefinition.java
View File

@ -42,7 +42,7 @@ import java.util.List;
import org.jooq.DataType;
import org.jooq.exception.SQLDialectNotSupportedException;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.tools.JooqLogger;
import org.jooq.util.jaxb.ForcedType;
@ -108,7 +108,7 @@ abstract class AbstractTypedElementDefinition<T extends Definition>
int s = definedType.getScale();
try {
forcedDataType = AbstractDataType.getDataType(db.getDialect(), forcedType.getName(), p, s);
forcedDataType = DefaultDataType.getDataType(db.getDialect(), forcedType.getName(), p, s);
} catch (SQLDialectNotSupportedException ignore) {}
// [#677] SQLDataType matches are actual type-rewrites
@ -127,12 +127,12 @@ abstract class AbstractTypedElementDefinition<T extends Definition>
DataType<?> dataType = null;
try {
dataType = AbstractDataType.getDataType(db.getDialect(), definedType.getType(), 0, 0);
dataType = DefaultDataType.getDataType(db.getDialect(), definedType.getType(), 0, 0);
} catch (SQLDialectNotSupportedException ignore) {}
if (dataType != null) {
if (dataType.getSQLType() == Types.DATE) {
DataType<?> forcedDataType = AbstractDataType.getDataType(db.getDialect(), SQLDataType.TIMESTAMP.getTypeName(), 0, 0);
DataType<?> forcedDataType = DefaultDataType.getDataType(db.getDialect(), SQLDataType.TIMESTAMP.getTypeName(), 0, 0);
type = new DefaultDataTypeDefinition(db, getSchema(), forcedDataType.getTypeName(), 0, 0, 0);
}
}

2
jOOQ-meta/src/main/java/org/jooq/util/DefaultDataTypeDefinition.java
View File

@ -36,7 +36,7 @@
package org.jooq.util;
import static org.jooq.impl.AbstractDataType.normalise;
import static org.jooq.impl.DefaultDataType.normalise;
import org.jooq.SQLDialect;
import org.jooq.util.oracle.OracleDataType;

679
jOOQ/src/main/java/org/jooq/impl/AbstractDataType.java
View File

@ -1,679 +0,0 @@
/**
* Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com
* All rights reserved.
*
* This software is licensed to you under the Apache License, Version 2.0
* (the "License"); You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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 "jOOQ" 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 THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
package org.jooq.impl;
import static org.jooq.impl.SQLDataType.BLOB;
import static org.jooq.impl.SQLDataType.CLOB;
import static org.jooq.impl.SQLDataType.NCLOB;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.jooq.ArrayRecord;
import org.jooq.Configuration;
import org.jooq.Converter;
import org.jooq.DataType;
import org.jooq.EnumType;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.UDTRecord;
import org.jooq.exception.SQLDialectNotSupportedException;
import org.jooq.tools.Convert;
import org.jooq.types.Interval;
/**
* A common base class for data types.
* <p>
* This also acts as a static data type registry for jOOQ internally.
* <p>
* This type is for JOOQ INTERNAL USE only. Do not reference directly
*
* @author Lukas Eder
*/
@SuppressWarnings({"unchecked", "deprecation"})
public abstract class AbstractDataType<T> implements DataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = 4155588654449505119L;
/**
* A pattern for data type name normalisation
*/
private static final Pattern NORMALISE_PATTERN = Pattern.compile("\"|\\.|\\s|\\(\\w+(,\\w+)*\\)|(NOT\\s*NULL)?");
// -------------------------------------------------------------------------
// Data type caches
// -------------------------------------------------------------------------
/**
* A cache for dialect-specific data types by normalised
*/
private static final Map<String, DataType<?>>[] TYPES_BY_NAME;
/**
* A cache for dialect-specific data types by Java type
*/
private static final Map<Class<?>, DataType<?>>[] TYPES_BY_TYPE;
/**
* A cache for dialect-specific data types by SQL DataTypes
*/
private static final Map<DataType<?>, DataType<?>>[] TYPES_BY_SQL_DATATYPE;
/**
* A cache for SQL DataTypes by Java type
*/
private static final Map<Class<?>, DataType<?>> SQL_DATATYPES_BY_TYPE;
// -------------------------------------------------------------------------
// Precisions
// -------------------------------------------------------------------------
/**
* The minimum decimal precision needed to represent a Java {@link Long} type
*/
private static final int LONG_PRECISION = String.valueOf(Long.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Integer} type
*/
private static final int INTEGER_PRECISION = String.valueOf(Integer.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Short} type
*/
private static final int SHORT_PRECISION = String.valueOf(Short.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Byte} type
*/
private static final int BYTE_PRECISION = String.valueOf(Byte.MAX_VALUE).length();
// -------------------------------------------------------------------------
// Data type attributes
// -------------------------------------------------------------------------
/**
* The SQL dialect associated with this data type
*/
private final SQLDialect dialect;
/**
* The SQL DataType corresponding to this data type
*/
private final SQLDataType<T> sqlDataType;
/**
* The Java class corresponding to this data type
*/
private final Class<T> type;
/**
* The Java class corresponding to arrays of this data type
*/
private final Class<T[]> arrayType;
/**
* The type name used for casting to this type
*/
private final String castTypeName;
/**
* The type name
*/
private final String typeName;
static {
TYPES_BY_SQL_DATATYPE = new Map[SQLDialect.values().length];
TYPES_BY_NAME = new Map[SQLDialect.values().length];
TYPES_BY_TYPE = new Map[SQLDialect.values().length];
for (SQLDialect dialect : SQLDialect.values()) {
TYPES_BY_SQL_DATATYPE[dialect.ordinal()] = new LinkedHashMap<DataType<?>, DataType<?>>();
TYPES_BY_NAME[dialect.ordinal()] = new LinkedHashMap<String, DataType<?>>();
TYPES_BY_TYPE[dialect.ordinal()] = new LinkedHashMap<Class<?>, DataType<?>>();
}
SQL_DATATYPES_BY_TYPE = new LinkedHashMap<Class<?>, DataType<?>>();
}
protected AbstractDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, Class<T> type, String typeName) {
this(dialect, sqlDataType, type, typeName, typeName);
}
protected AbstractDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, Class<T> type, String typeName, String castTypeName) {
this.dialect = dialect;
// [#858] SQLDataTypes should reference themselves for more convenience
this.sqlDataType = (SQLDataType<T>) ((this instanceof SQLDataType) ? this : sqlDataType);
this.type = type;
this.typeName = typeName;
this.castTypeName = castTypeName;
this.arrayType = (Class<T[]>) Array.newInstance(type, 0).getClass();
init();
}
private final void init() {
// Dialect-specific data types
int ordinal = dialect == null ? SQLDialect.SQL99.ordinal() : dialect.ordinal();
String normalised = AbstractDataType.normalise(typeName);
if (TYPES_BY_NAME[ordinal].get(normalised) == null) {
TYPES_BY_NAME[ordinal].put(normalised, this);
}
if (TYPES_BY_TYPE[ordinal].get(type) == null) {
TYPES_BY_TYPE[ordinal].put(type, this);
}
if (TYPES_BY_SQL_DATATYPE[ordinal].get(sqlDataType) == null) {
TYPES_BY_SQL_DATATYPE[ordinal].put(sqlDataType, this);
}
// Global data types
if (dialect == null) {
if (SQL_DATATYPES_BY_TYPE.get(type) == null) {
SQL_DATATYPES_BY_TYPE.put(type, this);
}
}
}
@Override
public final SQLDataType<T> getSQLDataType() {
return sqlDataType;
}
@Override
public final DataType<T> getDataType(Configuration configuration) {
// If this is a SQLDataType find the most suited dialect-specific
// data type
if (getDialect() == null) {
DataType<?> dataType = TYPES_BY_SQL_DATATYPE[configuration.getDialect().ordinal()].get(this);
if (dataType != null) {
return (DataType<T>) dataType;
}
}
// If this is already the dialect's specific data type, return this
else if (getDialect() == configuration.getDialect()) {
return this;
}
// If the SQL data type is not available stick with this data type
else if (getSQLDataType() == null) {
return this;
}
// If this is another dialect's specific data type, recurse
else {
getSQLDataType().getDataType(configuration);
}
return this;
}
@Override
public /* final */ int getSQLType() {
// TODO [#1227] There is some confusion with these types, especially
// when it comes to byte[] which can be mapped to BLOB, BINARY, VARBINARY
if (type == Blob.class) {
return Types.BLOB;
}
else if (type == Boolean.class) {
return Types.BOOLEAN;
}
else if (type == BigInteger.class) {
return Types.BIGINT;
}
else if (type == BigDecimal.class) {
return Types.DECIMAL;
}
else if (type == Byte.class) {
return Types.TINYINT;
}
else if (type == byte[].class) {
return Types.BLOB;
}
else if (type == Clob.class) {
return Types.CLOB;
}
else if (type == Date.class) {
return Types.DATE;
}
else if (type == Double.class) {
return Types.DOUBLE;
}
else if (type == Float.class) {
return Types.FLOAT;
}
else if (type == Integer.class) {
return Types.INTEGER;
}
else if (type == Long.class) {
return Types.BIGINT;
}
else if (type == Short.class) {
return Types.SMALLINT;
}
else if (type == String.class) {
return Types.VARCHAR;
}
else if (type == Time.class) {
return Types.TIME;
}
else if (type == Timestamp.class) {
return Types.TIMESTAMP;
}
// The type byte[] is handled earlier.
else if (type.isArray()) {
return Types.ARRAY;
}
else if (ArrayRecord.class.isAssignableFrom(type)) {
return Types.ARRAY;
}
else if (EnumType.class.isAssignableFrom(type)) {
return Types.VARCHAR;
}
else if (UDTRecord.class.isAssignableFrom(type)) {
return Types.STRUCT;
}
else if (Result.class.isAssignableFrom(type)) {
switch (dialect) {
case ORACLE:
case H2:
return -10; // OracleTypes.CURSOR;
case POSTGRES:
default:
return Types.OTHER;
}
}
else {
return Types.OTHER;
}
}
@Override
public final Class<T> getType() {
return type;
}
@Override
public final Class<T[]> getArrayType() {
return arrayType;
}
@Override
public final String getTypeName() {
return typeName;
}
@Override
public String getTypeName(Configuration configuration) {
return getDataType(configuration).getTypeName();
}
@Override
public final String getCastTypeName() {
return castTypeName;
}
@Override
public /* final */ String getCastTypeName(Configuration configuration, int length) {
String result = getCastTypeName(configuration);
if (length != 0) {
// Remove existing length information, first
result = result.replaceAll("\\([^\\)]*\\)", "");
result += "(" + length + ")";
}
return result;
}
@Override
public /* final */ String getCastTypeName(Configuration configuration, int precision, int scale) {
String result = getCastTypeName(configuration);
if (precision != 0) {
// Remove existing precision / scale information, first
result = result.replaceAll("\\([^\\)]*\\)", "");
if (scale != 0) {
result += "(" + precision + ", " + scale + ")";
}
else {
result += "(" + precision + ")";
}
}
return result;
}
@Override
public String getCastTypeName(Configuration configuration) {
return getDataType(configuration).getCastTypeName();
}
@Override
public final DataType<T[]> getArrayDataType() {
return new ArrayDataType<T>(this);
}
@Override
public final <A extends ArrayRecord<T>> DataType<A> asArrayDataType(Class<A> arrayDataType) {
return new DefaultDataType<A>(dialect, arrayDataType, typeName, castTypeName);
}
@Override
public final <E extends EnumType> DataType<E> asEnumDataType(Class<E> enumDataType) {
return new DefaultDataType<E>(dialect, enumDataType, typeName, castTypeName);
}
@Override
public final <U> DataType<U> asConvertedDataType(Converter<? super T, U> converter) {
return new ConvertedDataType<T, U>(this, converter);
}
@Override
public final SQLDialect getDialect() {
return dialect;
}
@Override
public /* final */ T convert(Object object) {
// [#1441] Avoid unneeded type conversions to improve performance
if (object == null) {
return null;
}
else if (object.getClass() == type) {
return (T) object;
}
else {
return Convert.convert(object, type);
}
}
@Override
public final T[] convert(Object... objects) {
return (T[]) Convert.convertArray(objects, type);
}
@Override
public final List<T> convert(Collection<?> objects) {
return Convert.convert(objects, type);
}
public static DataType<Object> getDefaultDataType(String typeName) {
return new DefaultDataType<Object>(SQLDialect.SQL99, Object.class, typeName, typeName);
}
public static DataType<Object> getDefaultDataType(SQLDialect dialect, String typeName) {
return new DefaultDataType<Object>(dialect, Object.class, typeName, typeName);
}
public static DataType<?> getDataType(SQLDialect dialect, String typeName) {
String normalised = AbstractDataType.normalise(typeName);
DataType<?> result = TYPES_BY_NAME[dialect.ordinal()].get(normalised);
// UDT data types and others are registered using SQL99
if (result == null) {
result = TYPES_BY_NAME[SQLDialect.SQL99.ordinal()].get(normalised);
}
if (result == null) {
// [#366] Don't log a warning here. The warning is logged when
// catching the exception in jOOQ-codegen
throw new SQLDialectNotSupportedException("Type " + typeName + " is not supported in dialect " + dialect, false);
}
return result;
}
public static <T> DataType<T> getDataType(SQLDialect dialect, Class<T> type) {
// Recurse for arrays
if (byte[].class != type && type.isArray()) {
return (DataType<T>) getDataType(dialect, type.getComponentType()).getArrayDataType();
}
// Base types are registered statically
else {
DataType<?> result = null;
if (dialect != null) {
result = TYPES_BY_TYPE[dialect.ordinal()].get(type);
}
if (result == null) {
// jOOQ data types are handled here
if (EnumType.class.isAssignableFrom(type) ||
UDTRecord.class.isAssignableFrom(type) ||
ArrayRecord.class.isAssignableFrom(type)) {
for (SQLDialect d : SQLDialect.values()) {
result = TYPES_BY_TYPE[d.ordinal()].get(type);
if (result != null) {
break;
}
}
}
}
if (result == null) {
if (SQL_DATATYPES_BY_TYPE.get(type) != null) {
return (DataType<T>) SQL_DATATYPES_BY_TYPE.get(type);
}
// All other data types are illegal
else {
throw new SQLDialectNotSupportedException("Type " + type + " is not supported in dialect " + dialect);
}
}
return (DataType<T>) result;
}
}
@Override
public final boolean isNumeric() {
return Number.class.isAssignableFrom(type) && !isInterval();
}
@Override
public final boolean isString() {
return type == String.class;
}
@Override
public final boolean isDateTime() {
return java.util.Date.class.isAssignableFrom(type);
}
@Override
public final boolean isTemporal() {
return isDateTime() || isInterval();
}
@Override
public final boolean isInterval() {
return Interval.class.isAssignableFrom(type);
}
@Override
public final boolean isLob() {
SQLDataType<T> t = getSQLDataType();
return (t == BLOB || t == CLOB || t == NCLOB);
}
@Override
public final boolean isBinary() {
return type == byte[].class;
}
@Override
public final boolean isArray() {
return ArrayRecord.class.isAssignableFrom(type)
|| (!isBinary() && type.isArray());
}
// ------------------------------------------------------------------------
// The Object API
// ------------------------------------------------------------------------
@Override
public String toString() {
return getClass().getSimpleName() + " [" + type + ", " + typeName + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((dialect == null) ? 0 : dialect.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
result = prime * result + ((typeName == null) ? 0 : typeName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AbstractDataType<?> other = (AbstractDataType<?>) obj;
if (dialect != other.dialect)
return false;
if (type == null) {
if (other.type != null)
return false;
}
else if (!type.equals(other.type))
return false;
if (typeName == null) {
if (other.typeName != null)
return false;
}
else if (!typeName.equals(other.typeName))
return false;
return true;
}
/**
* @return The type name without all special characters and white spaces
*/
public static String normalise(String typeName) {
return NORMALISE_PATTERN.matcher(typeName.toUpperCase()).replaceAll("");
}
/**
* Convert a type name (using precision and scale) into a Java class
*/
public static DataType<?> getDataType(SQLDialect dialect, String t, int p, int s) throws SQLDialectNotSupportedException {
DataType<?> result = AbstractDataType.getDataType(dialect, AbstractDataType.normalise(t));
if (result.getType() == BigDecimal.class) {
result = AbstractDataType.getDataType(dialect, getNumericClass(p, s));
}
return result;
}
/**
* Convert a type name (using precision and scale) into a Java class
*/
public static Class<?> getType(SQLDialect dialect, String t, int p, int s) throws SQLDialectNotSupportedException {
return getDataType(dialect, t, p, s).getType();
}
/**
* Get the most suitable Java class for a given precision and scale
*/
private static Class<?> getNumericClass(int precision, int scale) {
// Integer numbers
if (scale == 0 && precision != 0) {
if (precision < BYTE_PRECISION) {
return Byte.class;
}
if (precision < SHORT_PRECISION) {
return Short.class;
}
if (precision < INTEGER_PRECISION) {
return Integer.class;
}
if (precision < LONG_PRECISION) {
return Long.class;
}
// Default integer number
return BigInteger.class;
}
// Real numbers should not be represented as float or double
else {
return BigDecimal.class;
}
}
}

2
jOOQ/src/main/java/org/jooq/impl/ArrayDataType.java
View File

@ -43,7 +43,7 @@ import org.jooq.DataType;
*
* @author Lukas Eder
*/
class ArrayDataType<T> extends AbstractDataType<T[]> {
class ArrayDataType<T> extends DefaultDataType<T[]> {
/**
* Generated UID

2
jOOQ/src/main/java/org/jooq/impl/ConvertedDataType.java
View File

@ -44,7 +44,7 @@ import org.jooq.DataType;
*
* @author Lukas Eder
*/
class ConvertedDataType<T, U> extends AbstractDataType<U> {
class ConvertedDataType<T, U> extends DefaultDataType<U> {
/**
* Generated UID

2
jOOQ/src/main/java/org/jooq/impl/DefaultArray.java
View File

@ -56,7 +56,7 @@ class DefaultArray implements Array {
@Override
public String getBaseTypeName() {
return AbstractDataType.getDataType(dialect, type.getComponentType()).getTypeName();
return DefaultDataType.getDataType(dialect, type.getComponentType()).getTypeName();
}
@Override

2
jOOQ/src/main/java/org/jooq/impl/DefaultBindContext.java
View File

@ -126,7 +126,7 @@ class DefaultBindContext extends AbstractBindContext {
// Setting null onto a prepared statement is subtly different for every
// SQL dialect. See the following section for details
if (value == null) {
int sqlType = AbstractDataType.getDataType(dialect, type).getSQLType();
int sqlType = DefaultDataType.getDataType(dialect, type).getSQLType();
// Oracle-style ARRAY types need to be bound with their type name
if (ArrayRecord.class.isAssignableFrom(type)) {

643
jOOQ/src/main/java/org/jooq/impl/DefaultDataType.java
View File

@ -35,22 +35,653 @@
*/
package org.jooq.impl;
import static org.jooq.impl.SQLDataType.BLOB;
import static org.jooq.impl.SQLDataType.CLOB;
import static org.jooq.impl.SQLDataType.NCLOB;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.jooq.ArrayRecord;
import org.jooq.Configuration;
import org.jooq.Converter;
import org.jooq.DataType;
import org.jooq.EnumType;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.UDTRecord;
import org.jooq.exception.SQLDialectNotSupportedException;
import org.jooq.tools.Convert;
import org.jooq.types.Interval;
/**
* A default data type for data types without any specific features or unknown
* data types.
* A common base class for data types.
* <p>
* This also acts as a static data type registry for jOOQ internally.
* <p>
* This type is for JOOQ INTERNAL USE only. Do not reference directly
*
* @author Lukas Eder
*/
class DefaultDataType<T> extends AbstractDataType<T> {
@SuppressWarnings({"unchecked", "deprecation"})
public class DefaultDataType<T> implements DataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -2612295936942892367L;
private static final long serialVersionUID = 4155588654449505119L;
DefaultDataType(SQLDialect dialect, Class<T> type, String typeName, String castTypeName) {
super(dialect, null, type, typeName, castTypeName);
/**
* A pattern for data type name normalisation
*/
private static final Pattern NORMALISE_PATTERN = Pattern.compile("\"|\\.|\\s|\\(\\w+(,\\w+)*\\)|(NOT\\s*NULL)?");
// -------------------------------------------------------------------------
// Data type caches
// -------------------------------------------------------------------------
/**
* A cache for dialect-specific data types by normalised
*/
private static final Map<String, DataType<?>>[] TYPES_BY_NAME;
/**
* A cache for dialect-specific data types by Java type
*/
private static final Map<Class<?>, DataType<?>>[] TYPES_BY_TYPE;
/**
* A cache for dialect-specific data types by SQL DataTypes
*/
private static final Map<DataType<?>, DataType<?>>[] TYPES_BY_SQL_DATATYPE;
/**
* A cache for SQL DataTypes by Java type
*/
private static final Map<Class<?>, DataType<?>> SQL_DATATYPES_BY_TYPE;
// -------------------------------------------------------------------------
// Precisions
// -------------------------------------------------------------------------
/**
* The minimum decimal precision needed to represent a Java {@link Long} type
*/
private static final int LONG_PRECISION = String.valueOf(Long.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Integer} type
*/
private static final int INTEGER_PRECISION = String.valueOf(Integer.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Short} type
*/
private static final int SHORT_PRECISION = String.valueOf(Short.MAX_VALUE).length();
/**
* The minimum decimal precision needed to represent a Java {@link Byte} type
*/
private static final int BYTE_PRECISION = String.valueOf(Byte.MAX_VALUE).length();
// -------------------------------------------------------------------------
// Data type attributes
// -------------------------------------------------------------------------
/**
* The SQL dialect associated with this data type
*/
private final SQLDialect dialect;
/**
* The SQL DataType corresponding to this data type
*/
private final SQLDataType<T> sqlDataType;
/**
* The Java class corresponding to this data type
*/
private final Class<T> type;
/**
* The Java class corresponding to arrays of this data type
*/
private final Class<T[]> arrayType;
/**
* The type name used for casting to this type
*/
private final String castTypeName;
/**
* The type name
*/
private final String typeName;
static {
TYPES_BY_SQL_DATATYPE = new Map[SQLDialect.values().length];
TYPES_BY_NAME = new Map[SQLDialect.values().length];
TYPES_BY_TYPE = new Map[SQLDialect.values().length];
for (SQLDialect dialect : SQLDialect.values()) {
TYPES_BY_SQL_DATATYPE[dialect.ordinal()] = new LinkedHashMap<DataType<?>, DataType<?>>();
TYPES_BY_NAME[dialect.ordinal()] = new LinkedHashMap<String, DataType<?>>();
TYPES_BY_TYPE[dialect.ordinal()] = new LinkedHashMap<Class<?>, DataType<?>>();
}
SQL_DATATYPES_BY_TYPE = new LinkedHashMap<Class<?>, DataType<?>>();
}
public DefaultDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, String typeName) {
this(dialect, sqlDataType, sqlDataType.getType(), typeName, typeName);
}
public DefaultDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
this(dialect, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public DefaultDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, Class<T> type, String typeName) {
this(dialect, sqlDataType, type, typeName, typeName);
}
public DefaultDataType(SQLDialect dialect, SQLDataType<T> sqlDataType, Class<T> type, String typeName, String castTypeName) {
this.dialect = dialect;
// [#858] SQLDataTypes should reference themselves for more convenience
this.sqlDataType = (SQLDataType<T>) ((this instanceof SQLDataType) ? this : sqlDataType);
this.type = type;
this.typeName = typeName;
this.castTypeName = castTypeName;
this.arrayType = (Class<T[]>) Array.newInstance(type, 0).getClass();
init();
}
private final void init() {
// Dialect-specific data types
int ordinal = dialect == null ? SQLDialect.SQL99.ordinal() : dialect.ordinal();
String normalised = DefaultDataType.normalise(typeName);
if (TYPES_BY_NAME[ordinal].get(normalised) == null) {
TYPES_BY_NAME[ordinal].put(normalised, this);
}
if (TYPES_BY_TYPE[ordinal].get(type) == null) {
TYPES_BY_TYPE[ordinal].put(type, this);
}
if (TYPES_BY_SQL_DATATYPE[ordinal].get(sqlDataType) == null) {
TYPES_BY_SQL_DATATYPE[ordinal].put(sqlDataType, this);
}
// Global data types
if (dialect == null) {
if (SQL_DATATYPES_BY_TYPE.get(type) == null) {
SQL_DATATYPES_BY_TYPE.put(type, this);
}
}
}
@Override
public final SQLDataType<T> getSQLDataType() {
return sqlDataType;
}
@Override
public final DataType<T> getDataType(Configuration configuration) {
// If this is a SQLDataType find the most suited dialect-specific
// data type
if (getDialect() == null) {
DataType<?> dataType = TYPES_BY_SQL_DATATYPE[configuration.getDialect().ordinal()].get(this);
if (dataType != null) {
return (DataType<T>) dataType;
}
}
// If this is already the dialect's specific data type, return this
else if (getDialect() == configuration.getDialect()) {
return this;
}
// If the SQL data type is not available stick with this data type
else if (getSQLDataType() == null) {
return this;
}
// If this is another dialect's specific data type, recurse
else {
getSQLDataType().getDataType(configuration);
}
return this;
}
@Override
public /* final */ int getSQLType() {
// TODO [#1227] There is some confusion with these types, especially
// when it comes to byte[] which can be mapped to BLOB, BINARY, VARBINARY
if (type == Blob.class) {
return Types.BLOB;
}
else if (type == Boolean.class) {
return Types.BOOLEAN;
}
else if (type == BigInteger.class) {
return Types.BIGINT;
}
else if (type == BigDecimal.class) {
return Types.DECIMAL;
}
else if (type == Byte.class) {
return Types.TINYINT;
}
else if (type == byte[].class) {
return Types.BLOB;
}
else if (type == Clob.class) {
return Types.CLOB;
}
else if (type == Date.class) {
return Types.DATE;
}
else if (type == Double.class) {
return Types.DOUBLE;
}
else if (type == Float.class) {
return Types.FLOAT;
}
else if (type == Integer.class) {
return Types.INTEGER;
}
else if (type == Long.class) {
return Types.BIGINT;
}
else if (type == Short.class) {
return Types.SMALLINT;
}
else if (type == String.class) {
return Types.VARCHAR;
}
else if (type == Time.class) {
return Types.TIME;
}
else if (type == Timestamp.class) {
return Types.TIMESTAMP;
}
// The type byte[] is handled earlier.
else if (type.isArray()) {
return Types.ARRAY;
}
else if (ArrayRecord.class.isAssignableFrom(type)) {
return Types.ARRAY;
}
else if (EnumType.class.isAssignableFrom(type)) {
return Types.VARCHAR;
}
else if (UDTRecord.class.isAssignableFrom(type)) {
return Types.STRUCT;
}
else if (Result.class.isAssignableFrom(type)) {
switch (dialect) {
case ORACLE:
case H2:
return -10; // OracleTypes.CURSOR;
case POSTGRES:
default:
return Types.OTHER;
}
}
else {
return Types.OTHER;
}
}
@Override
public final Class<T> getType() {
return type;
}
@Override
public final Class<T[]> getArrayType() {
return arrayType;
}
@Override
public final String getTypeName() {
return typeName;
}
@Override
public String getTypeName(Configuration configuration) {
return getDataType(configuration).getTypeName();
}
@Override
public final String getCastTypeName() {
return castTypeName;
}
@Override
public /* final */ String getCastTypeName(Configuration configuration, int length) {
String result = getCastTypeName(configuration);
if (length != 0) {
// Remove existing length information, first
result = result.replaceAll("\\([^\\)]*\\)", "");
result += "(" + length + ")";
}
return result;
}
@Override
public /* final */ String getCastTypeName(Configuration configuration, int precision, int scale) {
String result = getCastTypeName(configuration);
if (precision != 0) {
// Remove existing precision / scale information, first
result = result.replaceAll("\\([^\\)]*\\)", "");
if (scale != 0) {
result += "(" + precision + ", " + scale + ")";
}
else {
result += "(" + precision + ")";
}
}
return result;
}
@Override
public String getCastTypeName(Configuration configuration) {
return getDataType(configuration).getCastTypeName();
}
@Override
public final DataType<T[]> getArrayDataType() {
return new ArrayDataType<T>(this);
}
@Override
public final <A extends ArrayRecord<T>> DataType<A> asArrayDataType(Class<A> arrayDataType) {
return new DefaultDataType<A>(dialect, null, arrayDataType, typeName, castTypeName);
}
@Override
public final <E extends EnumType> DataType<E> asEnumDataType(Class<E> enumDataType) {
return new DefaultDataType<E>(dialect, null, enumDataType, typeName, castTypeName);
}
@Override
public final <U> DataType<U> asConvertedDataType(Converter<? super T, U> converter) {
return new ConvertedDataType<T, U>(this, converter);
}
@Override
public final SQLDialect getDialect() {
return dialect;
}
@Override
public /* final */ T convert(Object object) {
// [#1441] Avoid unneeded type conversions to improve performance
if (object == null) {
return null;
}
else if (object.getClass() == type) {
return (T) object;
}
else {
return Convert.convert(object, type);
}
}
@Override
public final T[] convert(Object... objects) {
return (T[]) Convert.convertArray(objects, type);
}
@Override
public final List<T> convert(Collection<?> objects) {
return Convert.convert(objects, type);
}
public static DataType<Object> getDefaultDataType(String typeName) {
return new DefaultDataType<Object>(SQLDialect.SQL99, null, Object.class, typeName, typeName);
}
public static DataType<Object> getDefaultDataType(SQLDialect dialect, String typeName) {
return new DefaultDataType<Object>(dialect, null, Object.class, typeName, typeName);
}
public static DataType<?> getDataType(SQLDialect dialect, String typeName) {
String normalised = DefaultDataType.normalise(typeName);
DataType<?> result = TYPES_BY_NAME[dialect.ordinal()].get(normalised);
// UDT data types and others are registered using SQL99
if (result == null) {
result = TYPES_BY_NAME[SQLDialect.SQL99.ordinal()].get(normalised);
}
if (result == null) {
// [#366] Don't log a warning here. The warning is logged when
// catching the exception in jOOQ-codegen
throw new SQLDialectNotSupportedException("Type " + typeName + " is not supported in dialect " + dialect, false);
}
return result;
}
public static <T> DataType<T> getDataType(SQLDialect dialect, Class<T> type) {
// Recurse for arrays
if (byte[].class != type && type.isArray()) {
return (DataType<T>) getDataType(dialect, type.getComponentType()).getArrayDataType();
}
// Base types are registered statically
else {
DataType<?> result = null;
if (dialect != null) {
result = TYPES_BY_TYPE[dialect.ordinal()].get(type);
}
if (result == null) {
// jOOQ data types are handled here
if (EnumType.class.isAssignableFrom(type) ||
UDTRecord.class.isAssignableFrom(type) ||
ArrayRecord.class.isAssignableFrom(type)) {
for (SQLDialect d : SQLDialect.values()) {
result = TYPES_BY_TYPE[d.ordinal()].get(type);
if (result != null) {
break;
}
}
}
}
if (result == null) {
if (SQL_DATATYPES_BY_TYPE.get(type) != null) {
return (DataType<T>) SQL_DATATYPES_BY_TYPE.get(type);
}
// All other data types are illegal
else {
throw new SQLDialectNotSupportedException("Type " + type + " is not supported in dialect " + dialect);
}
}
return (DataType<T>) result;
}
}
@Override
public final boolean isNumeric() {
return Number.class.isAssignableFrom(type) && !isInterval();
}
@Override
public final boolean isString() {
return type == String.class;
}
@Override
public final boolean isDateTime() {
return java.util.Date.class.isAssignableFrom(type);
}
@Override
public final boolean isTemporal() {
return isDateTime() || isInterval();
}
@Override
public final boolean isInterval() {
return Interval.class.isAssignableFrom(type);
}
@Override
public final boolean isLob() {
SQLDataType<T> t = getSQLDataType();
return (t == BLOB || t == CLOB || t == NCLOB);
}
@Override
public final boolean isBinary() {
return type == byte[].class;
}
@Override
public final boolean isArray() {
return ArrayRecord.class.isAssignableFrom(type)
|| (!isBinary() && type.isArray());
}
// ------------------------------------------------------------------------
// The Object API
// ------------------------------------------------------------------------
@Override
public String toString() {
return getClass().getSimpleName() + " [" + type + ", " + typeName + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((dialect == null) ? 0 : dialect.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
result = prime * result + ((typeName == null) ? 0 : typeName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DefaultDataType<?> other = (DefaultDataType<?>) obj;
if (dialect != other.dialect)
return false;
if (type == null) {
if (other.type != null)
return false;
}
else if (!type.equals(other.type))
return false;
if (typeName == null) {
if (other.typeName != null)
return false;
}
else if (!typeName.equals(other.typeName))
return false;
return true;
}
/**
* @return The type name without all special characters and white spaces
*/
public static String normalise(String typeName) {
return NORMALISE_PATTERN.matcher(typeName.toUpperCase()).replaceAll("");
}
/**
* Convert a type name (using precision and scale) into a Java class
*/
public static DataType<?> getDataType(SQLDialect dialect, String t, int p, int s) throws SQLDialectNotSupportedException {
DataType<?> result = DefaultDataType.getDataType(dialect, DefaultDataType.normalise(t));
if (result.getType() == BigDecimal.class) {
result = DefaultDataType.getDataType(dialect, getNumericClass(p, s));
}
return result;
}
/**
* Convert a type name (using precision and scale) into a Java class
*/
public static Class<?> getType(SQLDialect dialect, String t, int p, int s) throws SQLDialectNotSupportedException {
return getDataType(dialect, t, p, s).getType();
}
/**
* Get the most suitable Java class for a given precision and scale
*/
private static Class<?> getNumericClass(int precision, int scale) {
// Integer numbers
if (scale == 0 && precision != 0) {
if (precision < BYTE_PRECISION) {
return Byte.class;
}
if (precision < SHORT_PRECISION) {
return Short.class;
}
if (precision < INTEGER_PRECISION) {
return Integer.class;
}
if (precision < LONG_PRECISION) {
return Long.class;
}
// Default integer number
return BigInteger.class;
}
// Real numbers should not be represented as float or double
else {
return BigDecimal.class;
}
}
}

2
jOOQ/src/main/java/org/jooq/impl/Factory.java
View File

@ -7652,7 +7652,7 @@ public class Factory {
@SuppressWarnings("deprecation")
@Support
public static <T> DataType<T> getDataType(Class<T> type) {
return AbstractDataType.getDataType(SQLDialect.SQL99, type);
return DefaultDataType.getDataType(SQLDialect.SQL99, type);
}
/**

2
jOOQ/src/main/java/org/jooq/impl/MetaDataFieldProvider.java
View File

@ -104,7 +104,7 @@ class MetaDataFieldProvider implements FieldProvider, Serializable {
String type = meta.getColumnTypeName(i);
try {
dataType = AbstractDataType.getDataType(configuration.getDialect(), type, precision, scale);
dataType = DefaultDataType.getDataType(configuration.getDialect(), type, precision, scale);
}
// [#650, #667] TODO This should not happen. All types

2
jOOQ/src/main/java/org/jooq/impl/MetaImpl.java
View File

@ -223,7 +223,7 @@ class MetaImpl implements Meta {
// TODO: Exception handling should be moved inside SQLDataType
DataType<?> type = null;
try {
type = AbstractDataType.getDataType(SQLDialect.SQL99, typeName, precision, scale);
type = DefaultDataType.getDataType(SQLDialect.SQL99, typeName, precision, scale);
}
catch (SQLDialectNotSupportedException e) {
type = SQLDataType.OTHER;

2
jOOQ/src/main/java/org/jooq/impl/SQLDataType.java
View File

@ -79,7 +79,7 @@ import org.jooq.util.sybase.SybaseDataType;
*
* @author Lukas Eder
*/
public final class SQLDataType<T> extends AbstractDataType<T> {
public final class SQLDataType<T> extends DefaultDataType<T> {
/**
* Generated UID

2
jOOQ/src/main/java/org/jooq/impl/UDTDataType.java
View File

@ -42,7 +42,7 @@ import org.jooq.UDTRecord;
/**
* @author Lukas Eder
*/
class UDTDataType<R extends UDTRecord<R>> extends AbstractDataType<R> {
class UDTDataType<R extends UDTRecord<R>> extends DefaultDataType<R> {
/**
* Generated UID

6
jOOQ/src/main/java/org/jooq/impl/Val.java
View File

@ -217,7 +217,7 @@ class Val<T> extends AbstractField<T> implements Param<T> {
// If the bind value is set, it can be used to derive the cast type
if (value != null) {
toSQLCast(context, AbstractDataType.getDataType(dialect, value.getClass()), 0, 0);
toSQLCast(context, DefaultDataType.getDataType(dialect, value.getClass()), 0, 0);
}
// [#632] [#722] Current integration tests show that Ingres and
@ -229,7 +229,7 @@ class Val<T> extends AbstractField<T> implements Param<T> {
// Derby and DB2 must have a type associated with NULL. Use VARCHAR
// as a workaround. That's probably not correct in all cases, though
else {
toSQLCast(context, AbstractDataType.getDataType(dialect, String.class), 0, 0);
toSQLCast(context, DefaultDataType.getDataType(dialect, String.class), 0, 0);
}
}
@ -510,7 +510,7 @@ class Val<T> extends AbstractField<T> implements Param<T> {
if (type.isArray() && byte[].class != type) {
context.sql(getBindVariable(context));
context.sql("::");
context.keyword(AbstractDataType.getDataType(dialect, type).getCastTypeName(context));
context.keyword(DefaultDataType.getDataType(dialect, type).getCastTypeName(context));
}
// ... and also for enum types

101
jOOQ/src/main/java/org/jooq/util/ase/ASEDataType.java
View File

@ -36,8 +36,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -46,78 +47,70 @@ import org.jooq.impl.SQLDataType;
* @see <a href="http://infocenter.sybase.com/help/topic/com.sybase.infocenter.dc36271.1550/html/blocks/X31825.htm">http://infocenter.sybase.com/help/topic/com.sybase.infocenter.dc36271.1550/html/blocks/X31825.htm</a>
* @author Lukas Eder
*/
public class ASEDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -4442303192680774346L;
public class ASEDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final ASEDataType<Byte> TINYINT = new ASEDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final ASEDataType<Short> SMALLINT = new ASEDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final ASEDataType<Short> UNSIGNEDSMALLLINT = new ASEDataType<Short>(SQLDataType.SMALLINT, "unsigned smallint");
public static final ASEDataType<Integer> INT = new ASEDataType<Integer>(SQLDataType.INTEGER, "int");
public static final ASEDataType<Integer> INTEGER = new ASEDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final ASEDataType<Integer> UNSIGNEDINT = new ASEDataType<Integer>(SQLDataType.INTEGER, "unsigned int");
public static final ASEDataType<Long> BIGINT = new ASEDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final ASEDataType<Long> UNSIGNEDBIGINT = new ASEDataType<Long>(SQLDataType.BIGINT, "unsigned bigint");
public static final ASEDataType<Double> DOUBLE_PRECISION = new ASEDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final ASEDataType<Double> FLOAT = new ASEDataType<Double>(SQLDataType.FLOAT, "float");
public static final ASEDataType<Float> REAL = new ASEDataType<Float>(SQLDataType.REAL, "real");
public static final ASEDataType<BigDecimal> DECIMAL = new ASEDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final ASEDataType<BigDecimal> DEC = new ASEDataType<BigDecimal>(SQLDataType.DECIMAL, "dec");
public static final ASEDataType<BigDecimal> NUMERIC = new ASEDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final ASEDataType<Boolean> BIT = new ASEDataType<Boolean>(SQLDataType.BIT, "bit");
public static final ASEDataType<String> VARCHAR = new ASEDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final ASEDataType<String> CHAR = new ASEDataType<String>(SQLDataType.CHAR, "char");
public static final ASEDataType<String> LONGVARCHAR = new ASEDataType<String>(SQLDataType.LONGVARCHAR, "text");
public static final ASEDataType<String> NCHAR = new ASEDataType<String>(SQLDataType.NCHAR, "nchar");
public static final ASEDataType<String> NVARCHAR = new ASEDataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final ASEDataType<String> TEXT = new ASEDataType<String>(SQLDataType.CLOB, "text");
public static final ASEDataType<Date> DATE = new ASEDataType<Date>(SQLDataType.DATE, "date");
public static final ASEDataType<Time> TIME = new ASEDataType<Time>(SQLDataType.TIME, "time");
public static final ASEDataType<Timestamp> DATETIME = new ASEDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final ASEDataType<Timestamp> TIMESTAMP = new ASEDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final ASEDataType<byte[]> BINARY = new ASEDataType<byte[]>(SQLDataType.BINARY, "binary");
public static final ASEDataType<byte[]> VARBINARY = new ASEDataType<byte[]>(SQLDataType.VARBINARY, "varbinary");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.ASE, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.ASE, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> UNSIGNEDSMALLLINT = new DefaultDataType<Short>(SQLDialect.ASE, SQLDataType.SMALLINT, "unsigned smallint");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.ASE, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.ASE, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> UNSIGNEDINT = new DefaultDataType<Integer>(SQLDialect.ASE, SQLDataType.INTEGER, "unsigned int");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.ASE, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> UNSIGNEDBIGINT = new DefaultDataType<Long>(SQLDialect.ASE, SQLDataType.BIGINT, "unsigned bigint");
public static final DataType<Double> DOUBLE_PRECISION = new DefaultDataType<Double>(SQLDialect.ASE, SQLDataType.DOUBLE, "double precision");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.ASE, SQLDataType.FLOAT, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.ASE, SQLDataType.REAL, "real");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.ASE, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.ASE, SQLDataType.DECIMAL, "dec");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.ASE, SQLDataType.NUMERIC, "numeric");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.ASE, SQLDataType.BIT, "bit");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.CHAR, "char");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.LONGVARCHAR, "text");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.CLOB, "text");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.ASE, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.ASE, SQLDataType.TIME, "time");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.ASE, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.ASE, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.ASE, SQLDataType.BINARY, "binary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.ASE, SQLDataType.VARBINARY, "varbinary");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// -------------------------------------------------------------------------
protected static final ASEDataType<byte[]> __BLOB = new ASEDataType<byte[]>(SQLDataType.BLOB, "binary");
protected static final ASEDataType<byte[]> __LONGVARBINARY = new ASEDataType<byte[]>(SQLDataType.LONGVARBINARY, "varbinary");
protected static final ASEDataType<Boolean> __BOOLEAN = new ASEDataType<Boolean>(SQLDataType.BOOLEAN, "bit");
protected static final ASEDataType<String> __LONGNVARCHAR = new ASEDataType<String>(SQLDataType.LONGNVARCHAR, "unitext");
protected static final DataType<byte[]> __BLOB = new DefaultDataType<byte[]>(SQLDialect.ASE, SQLDataType.BLOB, "binary");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.ASE, SQLDataType.LONGVARBINARY, "varbinary");
protected static final DataType<Boolean> __BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.ASE, SQLDataType.BOOLEAN, "bit");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.LONGNVARCHAR, "unitext");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final ASEDataType<BigInteger> __BIGINTEGER = new ASEDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.ASE, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final ASEDataType<String> UNICHAR = new ASEDataType<String>(SQLDataType.NCHAR, "unichar");
public static final ASEDataType<String> UNITEXT = new ASEDataType<String>(SQLDataType.NCLOB, "unitext");
public static final ASEDataType<String> UNIVARCHAR = new ASEDataType<String>(SQLDataType.NVARCHAR, "univarchar");
public static final ASEDataType<String> SYSNAME = new ASEDataType<String>(SQLDataType.VARCHAR, "sysname");
public static final ASEDataType<String> LONGSYSNAME = new ASEDataType<String>(SQLDataType.VARCHAR, "longsysname");
public static final ASEDataType<BigDecimal> MONEY = new ASEDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
public static final ASEDataType<BigDecimal> SMALLMONEY = new ASEDataType<BigDecimal>(SQLDataType.DECIMAL, "smallmoney");
public static final ASEDataType<Timestamp> SMALLDATETIME = new ASEDataType<Timestamp>(SQLDataType.TIMESTAMP, "smalldatetime");
public static final ASEDataType<Timestamp> BIGDATETIME = new ASEDataType<Timestamp>(SQLDataType.TIMESTAMP, "bigdatetime");
public static final ASEDataType<Time> BIGTIME = new ASEDataType<Time>(SQLDataType.TIME, "bigtime");
public static final ASEDataType<byte[]> IMAGE = new ASEDataType<byte[]>(SQLDataType.BINARY, "image");
public static final DataType<String> UNICHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.NCHAR, "unichar");
public static final DataType<String> UNITEXT = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.NCLOB, "unitext");
public static final DataType<String> UNIVARCHAR = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.NVARCHAR, "univarchar");
public static final DataType<String> SYSNAME = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.VARCHAR, "sysname");
public static final DataType<String> LONGSYSNAME = new DefaultDataType<String>(SQLDialect.ASE, SQLDataType.VARCHAR, "longsysname");
public static final DataType<BigDecimal> MONEY = new DefaultDataType<BigDecimal>(SQLDialect.ASE, SQLDataType.DECIMAL, "money");
public static final DataType<BigDecimal> SMALLMONEY = new DefaultDataType<BigDecimal>(SQLDialect.ASE, SQLDataType.DECIMAL, "smallmoney");
public static final DataType<Timestamp> SMALLDATETIME = new DefaultDataType<Timestamp>(SQLDialect.ASE, SQLDataType.TIMESTAMP, "smalldatetime");
public static final DataType<Timestamp> BIGDATETIME = new DefaultDataType<Timestamp>(SQLDialect.ASE, SQLDataType.TIMESTAMP, "bigdatetime");
public static final DataType<Time> BIGTIME = new DefaultDataType<Time>(SQLDialect.ASE, SQLDataType.TIME, "bigtime");
public static final DataType<byte[]> IMAGE = new DefaultDataType<byte[]>(SQLDialect.ASE, SQLDataType.BINARY, "image");
private ASEDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.ASE, sqlDataType, sqlDataType.getType(), typeName);
}
private ASEDataType() {}
}

120
jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDDataType.java
View File

@ -42,8 +42,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -51,93 +52,80 @@ import org.jooq.impl.SQLDataType;
*
* @author Lukas Eder
*/
public class CUBRIDDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class CUBRIDDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final CUBRIDDataType<Integer> INT = new CUBRIDDataType<Integer>(SQLDataType.INTEGER, "int");
public static final CUBRIDDataType<Integer> INTEGER = new CUBRIDDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final CUBRIDDataType<Short> SHORT = new CUBRIDDataType<Short>(SQLDataType.SMALLINT, "short");
public static final CUBRIDDataType<Short> SMALLINT = new CUBRIDDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final CUBRIDDataType<Long> BIGINT = new CUBRIDDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final CUBRIDDataType<BigDecimal> DECIMAL = new CUBRIDDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final CUBRIDDataType<BigDecimal> DEC = new CUBRIDDataType<BigDecimal>(SQLDataType.DECIMAL, "dec");
public static final CUBRIDDataType<BigDecimal> NUMERIC = new CUBRIDDataType<BigDecimal>(SQLDataType.DECIMAL, "numeric");
public static final CUBRIDDataType<Float> FLOAT = new CUBRIDDataType<Float>(SQLDataType.REAL, "float");
public static final CUBRIDDataType<Float> REAL = new CUBRIDDataType<Float>(SQLDataType.REAL, "real");
public static final CUBRIDDataType<Double> DOUBLE = new CUBRIDDataType<Double>(SQLDataType.DOUBLE, "double");
public static final CUBRIDDataType<Double> DOUBLEPRECISION = new CUBRIDDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.CUBRID, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.CUBRID, SQLDataType.INTEGER, "integer");
public static final DataType<Short> SHORT = new DefaultDataType<Short>(SQLDialect.CUBRID, SQLDataType.SMALLINT, "short");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.CUBRID, SQLDataType.SMALLINT, "smallint");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.CUBRID, SQLDataType.BIGINT, "bigint");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.CUBRID, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.CUBRID, SQLDataType.DECIMAL, "dec");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.CUBRID, SQLDataType.DECIMAL, "numeric");
public static final DataType<Float> FLOAT = new DefaultDataType<Float>(SQLDialect.CUBRID, SQLDataType.REAL, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.CUBRID, SQLDataType.REAL, "real");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.CUBRID, SQLDataType.DOUBLE, "double");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.CUBRID, SQLDataType.DOUBLE, "double precision");
public static final CUBRIDDataType<String> VARCHAR = new CUBRIDDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final CUBRIDDataType<String> CHARVARYING = new CUBRIDDataType<String>(SQLDataType.VARCHAR, "char varying");
public static final CUBRIDDataType<String> CHARACTERVARYING = new CUBRIDDataType<String>(SQLDataType.VARCHAR, "character varying");
public static final CUBRIDDataType<String> CHAR = new CUBRIDDataType<String>(SQLDataType.CHAR, "char", "varchar");
public static final CUBRIDDataType<String> CHARACTER = new CUBRIDDataType<String>(SQLDataType.CHAR, "character", "varchar");
public static final CUBRIDDataType<String> STRING = new CUBRIDDataType<String>(SQLDataType.VARCHAR, "string");
public static final CUBRIDDataType<String> NCHAR = new CUBRIDDataType<String>(SQLDataType.NCHAR, "nchar");
public static final CUBRIDDataType<String> NCHARVARYING = new CUBRIDDataType<String>(SQLDataType.NVARCHAR, "nchar varying");
public static final CUBRIDDataType<String> NATIONALCHARVARYING = new CUBRIDDataType<String>(SQLDataType.NVARCHAR, "national char varying");
public static final CUBRIDDataType<String> NATIONALCHARACTERVARYING = new CUBRIDDataType<String>(SQLDataType.NVARCHAR, "national character varying");
public static final CUBRIDDataType<String> VARNCHAR = new CUBRIDDataType<String>(SQLDataType.NVARCHAR, "varnchar");
public static final CUBRIDDataType<String> CLOB = new CUBRIDDataType<String>(SQLDataType.CLOB, "clob");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHARVARYING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.VARCHAR, "char varying");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.VARCHAR, "character varying");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.CHAR, "char", "varchar");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.CHAR, "character", "varchar");
public static final DataType<String> STRING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.VARCHAR, "string");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NCHARVARYING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NVARCHAR, "nchar varying");
public static final DataType<String> NATIONALCHARVARYING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NVARCHAR, "national char varying");
public static final DataType<String> NATIONALCHARACTERVARYING = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NVARCHAR, "national character varying");
public static final DataType<String> VARNCHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NVARCHAR, "varnchar");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.CLOB, "clob");
public static final CUBRIDDataType<Date> DATE = new CUBRIDDataType<Date>(SQLDataType.DATE, "date");
public static final CUBRIDDataType<Time> TIME = new CUBRIDDataType<Time>(SQLDataType.TIME, "time");
public static final CUBRIDDataType<Timestamp> DATETIME = new CUBRIDDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final CUBRIDDataType<Timestamp> TIMESTAMP = new CUBRIDDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.CUBRID, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.CUBRID, SQLDataType.TIME, "time");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.CUBRID, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.CUBRID, SQLDataType.TIMESTAMP, "timestamp");
public static final CUBRIDDataType<byte[]> BITVARYING = new CUBRIDDataType<byte[]>(SQLDataType.VARBINARY, "bitvarying");
public static final CUBRIDDataType<byte[]> VARBIT = new CUBRIDDataType<byte[]>(SQLDataType.VARBINARY, "varbit");
public static final CUBRIDDataType<byte[]> BIT = new CUBRIDDataType<byte[]>(SQLDataType.BINARY, "bit");
public static final CUBRIDDataType<byte[]> BLOB = new CUBRIDDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final DataType<byte[]> BITVARYING = new DefaultDataType<byte[]>(SQLDialect.CUBRID, SQLDataType.VARBINARY, "bitvarying");
public static final DataType<byte[]> VARBIT = new DefaultDataType<byte[]>(SQLDialect.CUBRID, SQLDataType.VARBINARY, "varbit");
public static final DataType<byte[]> BIT = new DefaultDataType<byte[]>(SQLDialect.CUBRID, SQLDataType.BINARY, "bit");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.CUBRID, SQLDataType.BLOB, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.CUBRID, SQLDataTypes
// -------------------------------------------------------------------------
protected static final CUBRIDDataType<Boolean> __BOOL = new CUBRIDDataType<Boolean>(SQLDataType.BOOLEAN, "bit", "bit(1)");
protected static final CUBRIDDataType<Boolean> __BIT = new CUBRIDDataType<Boolean>(SQLDataType.BIT, "bit", "bit(1)");
protected static final CUBRIDDataType<String> __LONGNVARCHAR = new CUBRIDDataType<String>(SQLDataType.LONGNVARCHAR, "nvarchar");
protected static final CUBRIDDataType<String> __NCLOB = new CUBRIDDataType<String>(SQLDataType.NCLOB, "clob");
protected static final CUBRIDDataType<String> __LONGVARCHAR = new CUBRIDDataType<String>(SQLDataType.LONGVARCHAR, "varchar");
protected static final CUBRIDDataType<byte[]> __LONGVARBINARY = new CUBRIDDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
protected static final CUBRIDDataType<Byte> __TINYINT = new CUBRIDDataType<Byte>(SQLDataType.TINYINT, "smallint");
protected static final CUBRIDDataType<Double> __FLOAT = new CUBRIDDataType<Double>(SQLDataType.DOUBLE, "double");
protected static final CUBRIDDataType<BigDecimal> __NUMERIC = new CUBRIDDataType<BigDecimal>(SQLDataType.NUMERIC, "decimal");
protected static final DataType<Boolean> __BOOL = new DefaultDataType<Boolean>(SQLDialect.CUBRID, SQLDataType.BOOLEAN, "bit", "bit(1)");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.CUBRID, SQLDataType.BIT, "bit", "bit(1)");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.LONGNVARCHAR, "nvarchar");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.NCLOB, "clob");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.LONGVARCHAR, "varchar");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.CUBRID, SQLDataType.LONGVARBINARY, "blob");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.CUBRID, SQLDataType.TINYINT, "smallint");
protected static final DataType<Double> __FLOAT = new DefaultDataType<Double>(SQLDialect.CUBRID, SQLDataType.DOUBLE, "double");
protected static final DataType<BigDecimal> __NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.CUBRID, SQLDataType.NUMERIC, "decimal");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final CUBRIDDataType<BigInteger> __BIGINTEGER = new CUBRIDDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal", "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.CUBRID, SQLDataType.DECIMAL_INTEGER, "decimal", "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final CUBRIDDataType<Double> MONETARY = new CUBRIDDataType<Double>(SQLDataType.DOUBLE, "monetary");
public static final CUBRIDDataType<String> ENUM = new CUBRIDDataType<String>(SQLDataType.VARCHAR, "enum", "varchar");
public static final DataType<Double> MONETARY = new DefaultDataType<Double>(SQLDialect.CUBRID, SQLDataType.DOUBLE, "monetary");
public static final DataType<String> ENUM = new DefaultDataType<String>(SQLDialect.CUBRID, SQLDataType.VARCHAR, "enum", "varchar");
// These types are not yet formally supported
public static final CUBRIDDataType<Object> OBJECT = new CUBRIDDataType<Object>(SQLDataType.OTHER, "object");
public static final CUBRIDDataType<Object> OID = new CUBRIDDataType<Object>(SQLDataType.OTHER, "oid");
public static final CUBRIDDataType<Object> ELO = new CUBRIDDataType<Object>(SQLDataType.OTHER, "elo");
public static final CUBRIDDataType<Object> MULTISET = new CUBRIDDataType<Object>(SQLDataType.OTHER, "multiset");
public static final CUBRIDDataType<Object> SEQUENCE = new CUBRIDDataType<Object>(SQLDataType.OTHER, "sequence");
public static final CUBRIDDataType<Object> SET = new CUBRIDDataType<Object>(SQLDataType.OTHER, "set");
private CUBRIDDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.CUBRID, sqlDataType, sqlDataType.getType(), typeName);
}
private CUBRIDDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.CUBRID, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public static final DataType<Object> OBJECT = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "object");
public static final DataType<Object> OID = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "oid");
public static final DataType<Object> ELO = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "elo");
public static final DataType<Object> MULTISET = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "multiset");
public static final DataType<Object> SEQUENCE = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "sequence");
public static final DataType<Object> SET = new DefaultDataType<Object>(SQLDialect.CUBRID, SQLDataType.OTHER, "set");
}

91
jOOQ/src/main/java/org/jooq/util/db2/DB2DataType.java
View File

@ -40,8 +40,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -50,74 +51,60 @@ import org.jooq.impl.SQLDataType;
* @see <a href="http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com.ibm.db2.udb.apdv.java.doc/doc/rjvjdata.htm">http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com.ibm.db2.udb.apdv.java.doc/doc/rjvjdata.htm</a>
* @author Espen Stromsnes
*/
public class DB2DataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class DB2DataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final DB2DataType<Short> SMALLINT = new DB2DataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final DB2DataType<Integer> INTEGER = new DB2DataType<Integer>(SQLDataType.INTEGER, "integer");
public static final DB2DataType<Long> BIGINT = new DB2DataType<Long>(SQLDataType.BIGINT, "bigint");
public static final DB2DataType<Float> REAL = new DB2DataType<Float>(SQLDataType.REAL, "real");
public static final DB2DataType<Double> DOUBLE = new DB2DataType<Double>(SQLDataType.DOUBLE, "double");
public static final DB2DataType<BigDecimal> DECIMAL = new DB2DataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final DB2DataType<BigDecimal> DECFLOAT = new DB2DataType<BigDecimal>(SQLDataType.DECIMAL, "decfloat");
public static final DB2DataType<String> VARCHAR = new DB2DataType<String>(SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final DB2DataType<String> CHAR = new DB2DataType<String>(SQLDataType.CHAR, "char", "varchar(32672)");
public static final DB2DataType<String> CHARACTER = new DB2DataType<String>(SQLDataType.CHAR, "character", "varchar(32672)");
public static final DB2DataType<String> LONGVARCHAR = new DB2DataType<String>(SQLDataType.LONGVARCHAR, "long varchar");
public static final DB2DataType<String> CLOB = new DB2DataType<String>(SQLDataType.CLOB, "clob");
public static final DB2DataType<byte[]> BLOB = new DB2DataType<byte[]>(SQLDataType.BLOB, "blob");
public static final DB2DataType<Date> DATE = new DB2DataType<Date>(SQLDataType.DATE, "date");
public static final DB2DataType<Time> TIME = new DB2DataType<Time>(SQLDataType.TIME, "time");
public static final DB2DataType<Timestamp> TIMESTAMP = new DB2DataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.DB2, SQLDataType.SMALLINT, "smallint");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.DB2, SQLDataType.INTEGER, "integer");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.DB2, SQLDataType.BIGINT, "bigint");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.DB2, SQLDataType.REAL, "real");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.DB2, SQLDataType.DOUBLE, "double");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.DB2, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DECFLOAT = new DefaultDataType<BigDecimal>(SQLDialect.DB2, SQLDataType.DECIMAL, "decfloat");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CHAR, "char", "varchar(32672)");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CHAR, "character", "varchar(32672)");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.LONGVARCHAR, "long varchar");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CLOB, "clob");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.BLOB, "blob");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.DB2, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.DB2, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.DB2, SQLDataType.TIMESTAMP, "timestamp");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.DB2, SQLDataTypes
// -------------------------------------------------------------------------
protected static final DB2DataType<byte[]> __BINARY = new DB2DataType<byte[]>(SQLDataType.BINARY, "blob");
protected static final DB2DataType<Boolean> __BIT = new DB2DataType<Boolean>(SQLDataType.BIT, "smallint");
protected static final DB2DataType<Boolean> __BOOLEAN = new DB2DataType<Boolean>(SQLDataType.BOOLEAN, "smallint");
protected static final DB2DataType<byte[]> __LONGVARBINARY = new DB2DataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
protected static final DB2DataType<String> __NCHAR = new DB2DataType<String>(SQLDataType.NCHAR, "char", "varchar(32672)");
protected static final DB2DataType<String> __NCLOB = new DB2DataType<String>(SQLDataType.NCLOB, "clob");
protected static final DB2DataType<String> __LONGNVARCHAR = new DB2DataType<String>(SQLDataType.LONGNVARCHAR, "long varchar");
protected static final DB2DataType<BigDecimal> __NUMERIC = new DB2DataType<BigDecimal>(SQLDataType.NUMERIC, "decimal", "decimal");
protected static final DB2DataType<String> __NVARCHAR = new DB2DataType<String>(SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
protected static final DB2DataType<Byte> __TINYINT = new DB2DataType<Byte>(SQLDataType.TINYINT, "smallint");
protected static final DB2DataType<byte[]> __VARBINARY = new DB2DataType<byte[]>(SQLDataType.VARBINARY, "blob");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.BINARY, "blob");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.DB2, SQLDataType.BIT, "smallint");
protected static final DataType<Boolean> __BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.DB2, SQLDataType.BOOLEAN, "smallint");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.LONGVARBINARY, "blob");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.NCHAR, "char", "varchar(32672)");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.NCLOB, "clob");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.LONGNVARCHAR, "long varchar");
protected static final DataType<BigDecimal> __NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.DB2, SQLDataType.NUMERIC, "decimal", "decimal");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.DB2, SQLDataType.TINYINT, "smallint");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.VARBINARY, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final DB2DataType<BigInteger> __BIGINTEGER = new DB2DataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(31)");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.DB2, SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(31)");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final DB2DataType<String> XML = new DB2DataType<String>(SQLDataType.CLOB, "xml");
public static final DB2DataType<String> DBCLOB = new DB2DataType<String>(SQLDataType.CLOB, "dbclob");
public static final DB2DataType<String> GRAPHIC = new DB2DataType<String>(SQLDataType.CLOB, "graphic");
public static final DB2DataType<String> VARGRAPHIC = new DB2DataType<String>(SQLDataType.CLOB, "vargraphic");
public static final DB2DataType<byte[]> CHARFORBITDATA = new DB2DataType<byte[]>(SQLDataType.BLOB, "char for bit data");
public static final DB2DataType<byte[]> VARCHARFORBITDATA = new DB2DataType<byte[]>(SQLDataType.BLOB, "varchar(32672) for bit data");
public static final DB2DataType<byte[]> ROWID = new DB2DataType<byte[]>(SQLDataType.BLOB, "rowid");
private DB2DataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.DB2, sqlDataType, sqlDataType.getType(), typeName);
}
private DB2DataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.DB2, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public static final DataType<String> XML = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CLOB, "xml");
public static final DataType<String> DBCLOB = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CLOB, "dbclob");
public static final DataType<String> GRAPHIC = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CLOB, "graphic");
public static final DataType<String> VARGRAPHIC = new DefaultDataType<String>(SQLDialect.DB2, SQLDataType.CLOB, "vargraphic");
public static final DataType<byte[]> CHARFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.BLOB, "char for bit data");
public static final DataType<byte[]> VARCHARFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.BLOB, "varchar(32672) for bit data");
public static final DataType<byte[]> ROWID = new DefaultDataType<byte[]>(SQLDialect.DB2, SQLDataType.BLOB, "rowid");
}

113
jOOQ/src/main/java/org/jooq/util/derby/DerbyDataType.java
View File

@ -42,8 +42,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -52,85 +53,71 @@ import org.jooq.impl.SQLDataType;
* @author Lukas Eder
* @see <a href="http://db.apache.org/derby/docs/10.7/ref/crefsqlj31068.html">http://db.apache.org/derby/docs/10.7/ref/crefsqlj31068.html</a>
*/
public class DerbyDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = 9064795517702394227L;
public class DerbyDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final DerbyDataType<Short> SMALLINT = new DerbyDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final DerbyDataType<Integer> INT = new DerbyDataType<Integer>(SQLDataType.INTEGER, "int");
public static final DerbyDataType<Integer> INTEGER = new DerbyDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final DerbyDataType<Long> BIGINT = new DerbyDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final DerbyDataType<Double> DOUBLE = new DerbyDataType<Double>(SQLDataType.DOUBLE, "double");
public static final DerbyDataType<Double> DOUBLEPRECISION = new DerbyDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final DerbyDataType<Double> FLOAT = new DerbyDataType<Double>(SQLDataType.FLOAT, "float");
public static final DerbyDataType<Float> REAL = new DerbyDataType<Float>(SQLDataType.REAL, "real");
public static final DerbyDataType<BigDecimal> DECIMAL = new DerbyDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final DerbyDataType<BigDecimal> DEC = new DerbyDataType<BigDecimal>(SQLDataType.DECIMAL, "dec");
public static final DerbyDataType<BigDecimal> NUMERIC = new DerbyDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final DerbyDataType<String> VARCHAR = new DerbyDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final DerbyDataType<String> LONGVARCHAR = new DerbyDataType<String>(SQLDataType.LONGVARCHAR, "long varchar");
public static final DerbyDataType<String> CHAR = new DerbyDataType<String>(SQLDataType.CHAR, "char", "varchar(32672)");
public static final DerbyDataType<String> CHARACTER = new DerbyDataType<String>(SQLDataType.CHAR, "character", "varchar(32672)");
public static final DerbyDataType<String> CLOB = new DerbyDataType<String>(SQLDataType.CLOB, "clob");
public static final DerbyDataType<String> CHARACTERLARGEOBJECT = new DerbyDataType<String>(SQLDataType.CLOB, "character large object");
public static final DerbyDataType<String> CHARVARYING = new DerbyDataType<String>(SQLDataType.VARCHAR, "char varying", "char varying(32672)");
public static final DerbyDataType<String> CHARACTERVARYING = new DerbyDataType<String>(SQLDataType.VARCHAR, "character varying", "character varying(32672)");
public static final DerbyDataType<Boolean> BOOLEAN = new DerbyDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final DerbyDataType<Date> DATE = new DerbyDataType<Date>(SQLDataType.DATE, "date");
public static final DerbyDataType<Time> TIME = new DerbyDataType<Time>(SQLDataType.TIME, "time");
public static final DerbyDataType<Timestamp> TIMESTAMP = new DerbyDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final DerbyDataType<byte[]> BLOB = new DerbyDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final DerbyDataType<byte[]> BINARYLARGEOBJECT = new DerbyDataType<byte[]>(SQLDataType.BLOB, "binary large object");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.DERBY, SQLDataType.SMALLINT, "smallint");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.DERBY, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.DERBY, SQLDataType.INTEGER, "integer");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.DERBY, SQLDataType.BIGINT, "bigint");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.DERBY, SQLDataType.DOUBLE, "double");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.DERBY, SQLDataType.DOUBLE, "double precision");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.DERBY, SQLDataType.FLOAT, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.DERBY, SQLDataType.REAL, "real");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.DERBY, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.DERBY, SQLDataType.DECIMAL, "dec");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.DERBY, SQLDataType.NUMERIC, "numeric");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.LONGVARCHAR, "long varchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CHAR, "char", "varchar(32672)");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CHAR, "character", "varchar(32672)");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CLOB, "clob");
public static final DataType<String> CHARACTERLARGEOBJECT = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CLOB, "character large object");
public static final DataType<String> CHARVARYING = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.VARCHAR, "char varying", "char varying(32672)");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.VARCHAR, "character varying", "character varying(32672)");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.DERBY, SQLDataType.BOOLEAN, "boolean");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.DERBY, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.DERBY, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.DERBY, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BLOB, "blob");
public static final DataType<byte[]> BINARYLARGEOBJECT = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BLOB, "binary large object");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.DERBY, SQLDataTypes
// -------------------------------------------------------------------------
protected static final DerbyDataType<byte[]> __BINARY = new DerbyDataType<byte[]>(SQLDataType.BINARY, "blob");
protected static final DerbyDataType<Boolean> __BIT = new DerbyDataType<Boolean>(SQLDataType.BIT, "boolean");
protected static final DerbyDataType<byte[]> __LONGVARBINARY = new DerbyDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
protected static final DerbyDataType<String> __NCHAR = new DerbyDataType<String>(SQLDataType.NCHAR, "char", "varchar(32672)");
protected static final DerbyDataType<String> __NCLOB = new DerbyDataType<String>(SQLDataType.NCLOB, "clob");
protected static final DerbyDataType<String> __LONGNVARCHAR = new DerbyDataType<String>(SQLDataType.LONGNVARCHAR, "long varchar");
protected static final DerbyDataType<String> __NVARCHAR = new DerbyDataType<String>(SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
protected static final DerbyDataType<Byte> __TINYINT = new DerbyDataType<Byte>(SQLDataType.TINYINT, "smallint");
protected static final DerbyDataType<byte[]> __VARBINARY = new DerbyDataType<byte[]>(SQLDataType.VARBINARY, "blob");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BINARY, "blob");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.DERBY, SQLDataType.BIT, "boolean");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.LONGVARBINARY, "blob");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.NCHAR, "char", "varchar(32672)");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.NCLOB, "clob");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.LONGNVARCHAR, "long varchar");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.DERBY, SQLDataType.TINYINT, "smallint");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.VARBINARY, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final DerbyDataType<BigInteger> __BIGINTEGER = new DerbyDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(31)");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.DERBY, SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(31)");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final DerbyDataType<byte[]> CHARFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.BINARY, "char for bit data");
public static final DerbyDataType<byte[]> CHARACTERFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.BINARY, "character for bit data");
public static final DerbyDataType<byte[]> LONGVARCHARFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.BINARY, "long varchar for bit data");
public static final DerbyDataType<byte[]> VARCHARFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.VARBINARY, "varchar for bit data", "varchar(32672) for bit data");
public static final DerbyDataType<byte[]> CHARVARYINGFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.VARBINARY, "char varying for bit data", "char varying(32672) for bit data");
public static final DerbyDataType<byte[]> CHARACTERVARYINGFORBITDATA = new DerbyDataType<byte[]>(SQLDataType.VARBINARY, "character varying for bit data", "character varying (32672) for bit data");
public static final DerbyDataType<String> ORGAPACHEDERBYCATALOGTYPEDESCRIPTOR
= new DerbyDataType<String>(SQLDataType.CLOB, "org.apache.derby.catalog.TypeDescriptor");
public static final DerbyDataType<String> ORGAPACHEDERBYCATALOGINDEXDESCRIPTOR
= new DerbyDataType<String>(SQLDataType.CLOB, "org.apache.derby.catalog.IndexDescriptor");
public static final DerbyDataType<String> JAVAIOSERIALIZABLE = new DerbyDataType<String>(SQLDataType.CLOB, "java.io.Serializable");
private DerbyDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.DERBY, sqlDataType, sqlDataType.getType(), typeName);
}
private DerbyDataType(SQLDataType<T> sqlDataType, String typeName, String castName) {
super(SQLDialect.DERBY, sqlDataType, sqlDataType.getType(), typeName, castName);
}
public static final DataType<byte[]> CHARFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BINARY, "char for bit data");
public static final DataType<byte[]> CHARACTERFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BINARY, "character for bit data");
public static final DataType<byte[]> LONGVARCHARFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.BINARY, "long varchar for bit data");
public static final DataType<byte[]> VARCHARFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.VARBINARY, "varchar for bit data", "varchar(32672) for bit data");
public static final DataType<byte[]> CHARVARYINGFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.VARBINARY, "char varying for bit data", "char varying(32672) for bit data");
public static final DataType<byte[]> CHARACTERVARYINGFORBITDATA = new DefaultDataType<byte[]>(SQLDialect.DERBY, SQLDataType.VARBINARY, "character varying for bit data", "character varying (32672) for bit data");
public static final DataType<String> ORGAPACHEDERBYCATALOGTYPEDESCRIPTOR
= new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CLOB, "org.apache.derby.catalog.TypeDescriptor");
public static final DataType<String> ORGAPACHEDERBYCATALOGINDEXDESCRIPTOR
= new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CLOB, "org.apache.derby.catalog.IndexDescriptor");
public static final DataType<String> JAVAIOSERIALIZABLE = new DefaultDataType<String>(SQLDialect.DERBY, SQLDataType.CLOB, "java.io.Serializable");
}

92
jOOQ/src/main/java/org/jooq/util/firebird/FirebirdDataType.java
View File

@ -42,8 +42,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.types.DayToSecond;
import org.jooq.types.YearToMonth;
@ -53,76 +54,63 @@ import org.jooq.types.YearToMonth;
*
* @author Lukas Eder
*/
public class FirebirdDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class FirebirdDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final FirebirdDataType<Short> SMALLINT = new FirebirdDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final FirebirdDataType<Integer> INTEGER = new FirebirdDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final FirebirdDataType<Integer> INT = new FirebirdDataType<Integer>(SQLDataType.INTEGER, "int");
public static final FirebirdDataType<Long> BIGINT = new FirebirdDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final FirebirdDataType<Long> INT64 = new FirebirdDataType<Long>(SQLDataType.BIGINT, "int64");
public static final FirebirdDataType<Double> DOUBLEPRECISION = new FirebirdDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final FirebirdDataType<Double> DOUBLE = new FirebirdDataType<Double>(SQLDataType.DOUBLE, "double");
public static final FirebirdDataType<Double> D_FLOAT = new FirebirdDataType<Double>(SQLDataType.DOUBLE, "d_float");
public static final FirebirdDataType<Float> FLOAT = new FirebirdDataType<Float>(SQLDataType.REAL, "float");
public static final FirebirdDataType<Boolean> BOOLEAN = new FirebirdDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final FirebirdDataType<BigDecimal> DECIMAL = new FirebirdDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final FirebirdDataType<BigDecimal> NUMERIC = new FirebirdDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final FirebirdDataType<String> VARCHAR = new FirebirdDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar(4000)");
public static final FirebirdDataType<String> CHARACTERVARYING = new FirebirdDataType<String>(SQLDataType.VARCHAR, "character varying", "varchar(4000)");
public static final FirebirdDataType<String> CHAR = new FirebirdDataType<String>(SQLDataType.CHAR, "char");
public static final FirebirdDataType<String> CHARACTER = new FirebirdDataType<String>(SQLDataType.CHAR, "character");
public static final FirebirdDataType<String> CLOB = new FirebirdDataType<String>(SQLDataType.CLOB, "blob sub_type text");
public static final FirebirdDataType<Date> DATE = new FirebirdDataType<Date>(SQLDataType.DATE, "date");
public static final FirebirdDataType<Time> TIME = new FirebirdDataType<Time>(SQLDataType.TIME, "time");
public static final FirebirdDataType<Timestamp> TIMESTAMP = new FirebirdDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final FirebirdDataType<byte[]> BLOB = new FirebirdDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.FIREBIRD, SQLDataType.SMALLINT, "smallint");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.FIREBIRD, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.FIREBIRD, SQLDataType.INTEGER, "int");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.FIREBIRD, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> INT64 = new DefaultDataType<Long>(SQLDialect.FIREBIRD, SQLDataType.BIGINT, "int64");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.FIREBIRD, SQLDataType.DOUBLE, "double precision");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.FIREBIRD, SQLDataType.DOUBLE, "double");
public static final DataType<Double> D_FLOAT = new DefaultDataType<Double>(SQLDialect.FIREBIRD, SQLDataType.DOUBLE, "d_float");
public static final DataType<Float> FLOAT = new DefaultDataType<Float>(SQLDialect.FIREBIRD, SQLDataType.REAL, "float");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.FIREBIRD, SQLDataType.BOOLEAN, "boolean");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.FIREBIRD, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.FIREBIRD, SQLDataType.NUMERIC, "numeric");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.VARCHAR, "varchar", "varchar(4000)");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.VARCHAR, "character varying", "varchar(4000)");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.CHAR, "character");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.CLOB, "blob sub_type text");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.FIREBIRD, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.FIREBIRD, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.FIREBIRD, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.FIREBIRD, SQLDataType.BLOB, "blob");
// TODO Below are HSQLDB data types. Fix this
public static final FirebirdDataType<Boolean> BIT = new FirebirdDataType<Boolean>(SQLDataType.BIT, "bit");
public static final FirebirdDataType<Object> OTHER = new FirebirdDataType<Object>(SQLDataType.OTHER, "other");
public static final FirebirdDataType<YearToMonth> INTERVALYEARTOMONTH = new FirebirdDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final FirebirdDataType<DayToSecond> INTERVALDAYTOSECOND = new FirebirdDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.FIREBIRD, SQLDataType.BIT, "bit");
public static final DataType<Object> OTHER = new DefaultDataType<Object>(SQLDialect.FIREBIRD, SQLDataType.OTHER, "other");
public static final DataType<YearToMonth> INTERVALYEARTOMONTH = new DefaultDataType<YearToMonth>(SQLDialect.FIREBIRD, SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final DataType<DayToSecond> INTERVALDAYTOSECOND = new DefaultDataType<DayToSecond>(SQLDialect.FIREBIRD, SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.FIREBIRD, SQLDataTypes
// -------------------------------------------------------------------------
protected static final FirebirdDataType<byte[]> __BINARY = new FirebirdDataType<byte[]>(SQLDataType.BINARY, "blob");
protected static final FirebirdDataType<Double> __FLOAT = new FirebirdDataType<Double>(SQLDataType.FLOAT, "double precision");
protected static final FirebirdDataType<String> __LONGNVARCHAR = new FirebirdDataType<String>(SQLDataType.LONGNVARCHAR, "blob sub_type text");
protected static final FirebirdDataType<byte[]> __LONGVARBINARY = new FirebirdDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
protected static final FirebirdDataType<String> __LONGVARCHAR = new FirebirdDataType<String>(SQLDataType.LONGVARCHAR, "varchar", "varchar(4000)");
protected static final FirebirdDataType<String> __NCHAR = new FirebirdDataType<String>(SQLDataType.NCHAR, "char");
protected static final FirebirdDataType<String> __NCLOB = new FirebirdDataType<String>(SQLDataType.NCLOB, "clob");
protected static final FirebirdDataType<String> __NVARCHAR = new FirebirdDataType<String>(SQLDataType.NVARCHAR, "varchar", "varchar(4000)");
protected static final FirebirdDataType<Byte> __TINYINT = new FirebirdDataType<Byte>(SQLDataType.TINYINT, "smallint");
protected static final FirebirdDataType<byte[]> __VARBINARY = new FirebirdDataType<byte[]>(SQLDataType.VARBINARY, "blob");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.FIREBIRD, SQLDataType.BINARY, "blob");
protected static final DataType<Double> __FLOAT = new DefaultDataType<Double>(SQLDialect.FIREBIRD, SQLDataType.FLOAT, "double precision");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.LONGNVARCHAR, "blob sub_type text");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.FIREBIRD, SQLDataType.LONGVARBINARY, "blob");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.LONGVARCHAR, "varchar", "varchar(4000)");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.NCHAR, "char");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.NCLOB, "clob");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.FIREBIRD, SQLDataType.NVARCHAR, "varchar", "varchar(4000)");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.FIREBIRD, SQLDataType.TINYINT, "smallint");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.FIREBIRD, SQLDataType.VARBINARY, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final FirebirdDataType<BigInteger> __BIGINTEGER = new FirebirdDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.FIREBIRD, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
private FirebirdDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.FIREBIRD, sqlDataType, sqlDataType.getType(), typeName);
}
private FirebirdDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.FIREBIRD, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
}

141
jOOQ/src/main/java/org/jooq/util/h2/H2DataType.java
View File

@ -41,10 +41,11 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -53,97 +54,87 @@ import org.jooq.impl.SQLDataType;
* @author Lukas Eder
* @see <a href="http://www.h2database.com/html/datatypes.html">http://www.h2database.com/html/datatypes.html</a>
*/
public class H2DataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class H2DataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final H2DataType<Byte> TINYINT = new H2DataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final H2DataType<Short> SMALLINT = new H2DataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final H2DataType<Short> INT2 = new H2DataType<Short>(SQLDataType.SMALLINT, "int2");
public static final H2DataType<Integer> INT = new H2DataType<Integer>(SQLDataType.INTEGER, "int");
public static final H2DataType<Integer> INTEGER = new H2DataType<Integer>(SQLDataType.INTEGER, "integer");
public static final H2DataType<Integer> MEDIUMINT = new H2DataType<Integer>(SQLDataType.INTEGER, "mediumint");
public static final H2DataType<Integer> INT4 = new H2DataType<Integer>(SQLDataType.INTEGER, "int4");
public static final H2DataType<Integer> SIGNED = new H2DataType<Integer>(SQLDataType.INTEGER, "signed");
public static final H2DataType<Boolean> BOOLEAN = new H2DataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final H2DataType<Boolean> BOOL = new H2DataType<Boolean>(SQLDataType.BOOLEAN, "bool");
public static final H2DataType<Boolean> BIT = new H2DataType<Boolean>(SQLDataType.BIT, "bit");
public static final H2DataType<Long> BIGINT = new H2DataType<Long>(SQLDataType.BIGINT, "bigint");
public static final H2DataType<Long> INT8 = new H2DataType<Long>(SQLDataType.BIGINT, "int8");
public static final H2DataType<BigDecimal> DECIMAL = new H2DataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final H2DataType<BigDecimal> DEC = new H2DataType<BigDecimal>(SQLDataType.DECIMAL, "dec");
public static final H2DataType<BigDecimal> NUMBER = new H2DataType<BigDecimal>(SQLDataType.NUMERIC, "number");
public static final H2DataType<BigDecimal> NUMERIC = new H2DataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final H2DataType<Double> DOUBLE = new H2DataType<Double>(SQLDataType.DOUBLE, "double");
public static final H2DataType<Double> FLOAT = new H2DataType<Double>(SQLDataType.FLOAT, "float");
public static final H2DataType<Double> FLOAT4 = new H2DataType<Double>(SQLDataType.FLOAT, "float4");
public static final H2DataType<Double> FLOAT8 = new H2DataType<Double>(SQLDataType.FLOAT, "float8");
public static final H2DataType<Float> REAL = new H2DataType<Float>(SQLDataType.REAL, "real");
public static final H2DataType<Time> TIME = new H2DataType<Time>(SQLDataType.TIME, "time");
public static final H2DataType<Date> DATE = new H2DataType<Date>(SQLDataType.DATE, "date");
public static final H2DataType<Timestamp> TIMESTAMP = new H2DataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final H2DataType<Timestamp> DATETIME = new H2DataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final H2DataType<byte[]> BINARY = new H2DataType<byte[]>(SQLDataType.BINARY, "binary");
public static final H2DataType<byte[]> VARBINARY = new H2DataType<byte[]>(SQLDataType.VARBINARY, "varbinary");
public static final H2DataType<byte[]> LONGVARBINARY = new H2DataType<byte[]>(SQLDataType.LONGVARBINARY, "longvarbinary");
public static final H2DataType<byte[]> BLOB = new H2DataType<byte[]>(SQLDataType.BLOB, "blob");
public static final H2DataType<Object> OTHER = new H2DataType<Object>(SQLDataType.OTHER, "other");
public static final H2DataType<String> VARCHAR = new H2DataType<String>(SQLDataType.VARCHAR, "varchar");
public static final H2DataType<String> VARCHAR2 = new H2DataType<String>(SQLDataType.VARCHAR, "varchar2");
public static final H2DataType<String> CHAR = new H2DataType<String>(SQLDataType.CHAR, "char");
public static final H2DataType<String> CHARACTER = new H2DataType<String>(SQLDataType.CHAR, "character");
public static final H2DataType<String> LONGVARCHAR = new H2DataType<String>(SQLDataType.LONGVARCHAR, "longvarchar");
public static final H2DataType<String> CLOB = new H2DataType<String>(SQLDataType.CLOB, "clob");
public static final H2DataType<String> NVARCHAR = new H2DataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final H2DataType<String> NVARCHAR2 = new H2DataType<String>(SQLDataType.NVARCHAR, "nvarchar2");
public static final H2DataType<String> NCHAR = new H2DataType<String>(SQLDataType.NCHAR, "nchar");
public static final H2DataType<String> NCLOB = new H2DataType<String>(SQLDataType.NCLOB, "nclob");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.H2, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.H2, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> INT2 = new DefaultDataType<Short>(SQLDialect.H2, SQLDataType.SMALLINT, "int2");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.H2, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.H2, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> MEDIUMINT = new DefaultDataType<Integer>(SQLDialect.H2, SQLDataType.INTEGER, "mediumint");
public static final DataType<Integer> INT4 = new DefaultDataType<Integer>(SQLDialect.H2, SQLDataType.INTEGER, "int4");
public static final DataType<Integer> SIGNED = new DefaultDataType<Integer>(SQLDialect.H2, SQLDataType.INTEGER, "signed");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.H2, SQLDataType.BOOLEAN, "boolean");
public static final DataType<Boolean> BOOL = new DefaultDataType<Boolean>(SQLDialect.H2, SQLDataType.BOOLEAN, "bool");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.H2, SQLDataType.BIT, "bit");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.H2, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> INT8 = new DefaultDataType<Long>(SQLDialect.H2, SQLDataType.BIGINT, "int8");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.H2, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.H2, SQLDataType.DECIMAL, "dec");
public static final DataType<BigDecimal> NUMBER = new DefaultDataType<BigDecimal>(SQLDialect.H2, SQLDataType.NUMERIC, "number");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.H2, SQLDataType.NUMERIC, "numeric");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.H2, SQLDataType.DOUBLE, "double");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.H2, SQLDataType.FLOAT, "float");
public static final DataType<Double> FLOAT4 = new DefaultDataType<Double>(SQLDialect.H2, SQLDataType.FLOAT, "float4");
public static final DataType<Double> FLOAT8 = new DefaultDataType<Double>(SQLDialect.H2, SQLDataType.FLOAT, "float8");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.H2, SQLDataType.REAL, "real");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.H2, SQLDataType.TIME, "time");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.H2, SQLDataType.DATE, "date");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.H2, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.H2, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BINARY, "binary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.VARBINARY, "varbinary");
public static final DataType<byte[]> LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.LONGVARBINARY, "longvarbinary");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "blob");
public static final DataType<Object> OTHER = new DefaultDataType<Object>(SQLDialect.H2, SQLDataType.OTHER, "other");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> VARCHAR2 = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.VARCHAR, "varchar2");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CHAR, "character");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.LONGVARCHAR, "longvarchar");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CLOB, "clob");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> NVARCHAR2 = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.NVARCHAR, "nvarchar2");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NCLOB = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.NCLOB, "nclob");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.H2, SQLDataTypes
// -------------------------------------------------------------------------
protected static final H2DataType<String> __LONGNVARCHAR = new H2DataType<String>(SQLDataType.LONGNVARCHAR, "longvarchar");
protected static final H2DataType<Result<Record>> __RESULT = new H2DataType<Result<Record>>(SQLDataType.RESULT, "result_set");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.LONGNVARCHAR, "longvarchar");
protected static final DataType<Result<Record>> __RESULT = new DefaultDataType<Result<Record>>(SQLDialect.H2, SQLDataType.RESULT, "result_set");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final H2DataType<BigInteger> __BIGINTEGER = new H2DataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.H2, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final H2DataType<Short> YEAR = new H2DataType<Short>(SQLDataType.SMALLINT, "year");
public static final H2DataType<Long> IDENTITY = new H2DataType<Long>(SQLDataType.BIGINT, "identity");
public static final H2DataType<Timestamp> SMALLDATETIME = new H2DataType<Timestamp>(SQLDataType.TIMESTAMP, "smalldatetime");
public static final H2DataType<byte[]> RAW = new H2DataType<byte[]>(SQLDataType.BLOB, "raw");
public static final H2DataType<byte[]> BYTEA = new H2DataType<byte[]>(SQLDataType.BLOB, "bytea");
public static final H2DataType<byte[]> TINYBLOB = new H2DataType<byte[]>(SQLDataType.BLOB, "tinyblob");
public static final H2DataType<byte[]> MEDIUMBLOB = new H2DataType<byte[]>(SQLDataType.BLOB, "mediumblob");
public static final H2DataType<byte[]> LONGBLOB = new H2DataType<byte[]>(SQLDataType.BLOB, "longblob");
public static final H2DataType<byte[]> IMAGE = new H2DataType<byte[]>(SQLDataType.BLOB, "image");
public static final H2DataType<byte[]> OID = new H2DataType<byte[]>(SQLDataType.BLOB, "oid");
public static final H2DataType<String> VARCHAR_CASESENSITIVE = new H2DataType<String>(SQLDataType.VARCHAR, "varchar_casesensitive");
public static final H2DataType<String> VARCHAR_IGNORECASE = new H2DataType<String>(SQLDataType.VARCHAR, "varchar_ignorecase");
public static final H2DataType<String> UUID = new H2DataType<String>(SQLDataType.VARCHAR, "uuid");
public static final H2DataType<String> TINYTEXT = new H2DataType<String>(SQLDataType.CLOB, "tinytext");
public static final H2DataType<String> TEXT = new H2DataType<String>(SQLDataType.CLOB, "text");
public static final H2DataType<String> MEDIUMTEXT = new H2DataType<String>(SQLDataType.CLOB, "mediumtext");
public static final H2DataType<String> LONGTEXT = new H2DataType<String>(SQLDataType.CLOB, "longtext");
public static final H2DataType<String> NTEXT = new H2DataType<String>(SQLDataType.NCLOB, "ntext");
private H2DataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.H2, sqlDataType, sqlDataType.getType(), typeName);
}
public static final DataType<Short> YEAR = new DefaultDataType<Short>(SQLDialect.H2, SQLDataType.SMALLINT, "year");
public static final DataType<Long> IDENTITY = new DefaultDataType<Long>(SQLDialect.H2, SQLDataType.BIGINT, "identity");
public static final DataType<Timestamp> SMALLDATETIME = new DefaultDataType<Timestamp>(SQLDialect.H2, SQLDataType.TIMESTAMP, "smalldatetime");
public static final DataType<byte[]> RAW = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "raw");
public static final DataType<byte[]> BYTEA = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "bytea");
public static final DataType<byte[]> TINYBLOB = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "tinyblob");
public static final DataType<byte[]> MEDIUMBLOB = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "mediumblob");
public static final DataType<byte[]> LONGBLOB = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "longblob");
public static final DataType<byte[]> IMAGE = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "image");
public static final DataType<byte[]> OID = new DefaultDataType<byte[]>(SQLDialect.H2, SQLDataType.BLOB, "oid");
public static final DataType<String> VARCHAR_CASESENSITIVE = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.VARCHAR, "varchar_casesensitive");
public static final DataType<String> VARCHAR_IGNORECASE = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.VARCHAR, "varchar_ignorecase");
public static final DataType<String> UUID = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.VARCHAR, "uuid");
public static final DataType<String> TINYTEXT = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CLOB, "tinytext");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CLOB, "text");
public static final DataType<String> MEDIUMTEXT = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CLOB, "mediumtext");
public static final DataType<String> LONGTEXT = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.CLOB, "longtext");
public static final DataType<String> NTEXT = new DefaultDataType<String>(SQLDialect.H2, SQLDataType.NCLOB, "ntext");
}

103
jOOQ/src/main/java/org/jooq/util/hsqldb/HSQLDBDataType.java
View File

@ -42,10 +42,11 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.types.DayToSecond;
import org.jooq.types.YearToMonth;
@ -57,80 +58,66 @@ import org.jooq.types.YearToMonth;
* @see <a href="http://hsqldb.org/doc/guide/ch09.html#datatypes-section">http://hsqldb.org/doc/guide/ch09.html#datatypes-section</a>
* @see <a href="http://hsqldb.org/doc/2.0/guide/sqlgeneral-chapt.html#sqlgeneral_types_ops-sect">http://hsqldb.org/doc/2.0/guide/sqlgeneral-chapt.html#sqlgeneral_types_ops-sect</a>
*/
public class HSQLDBDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class HSQLDBDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final HSQLDBDataType<Byte> TINYINT = new HSQLDBDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final HSQLDBDataType<Short> SMALLINT = new HSQLDBDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final HSQLDBDataType<Integer> INT = new HSQLDBDataType<Integer>(SQLDataType.INTEGER, "int");
public static final HSQLDBDataType<Integer> INTEGER = new HSQLDBDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final HSQLDBDataType<Long> BIGINT = new HSQLDBDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final HSQLDBDataType<Double> DOUBLE = new HSQLDBDataType<Double>(SQLDataType.DOUBLE, "double");
public static final HSQLDBDataType<Double> DOUBLEPRECISION = new HSQLDBDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final HSQLDBDataType<Double> FLOAT = new HSQLDBDataType<Double>(SQLDataType.FLOAT, "float");
public static final HSQLDBDataType<Float> REAL = new HSQLDBDataType<Float>(SQLDataType.REAL, "real");
public static final HSQLDBDataType<Boolean> BOOLEAN = new HSQLDBDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final HSQLDBDataType<Boolean> BIT = new HSQLDBDataType<Boolean>(SQLDataType.BIT, "bit");
public static final HSQLDBDataType<BigDecimal> DECIMAL = new HSQLDBDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final HSQLDBDataType<BigDecimal> NUMERIC = new HSQLDBDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final HSQLDBDataType<String> VARCHAR = new HSQLDBDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final HSQLDBDataType<String> LONGVARCHAR = new HSQLDBDataType<String>(SQLDataType.LONGVARCHAR, "longvarchar");
public static final HSQLDBDataType<String> CHAR = new HSQLDBDataType<String>(SQLDataType.CHAR, "char");
public static final HSQLDBDataType<String> CHARACTER = new HSQLDBDataType<String>(SQLDataType.CHAR, "character");
public static final HSQLDBDataType<String> CHARACTERVARYING = new HSQLDBDataType<String>(SQLDataType.VARCHAR, "character varying", "character varying(32672)");
public static final HSQLDBDataType<String> CLOB = new HSQLDBDataType<String>(SQLDataType.CLOB, "clob");
public static final HSQLDBDataType<String> CHARLARGEOBJECT = new HSQLDBDataType<String>(SQLDataType.CLOB, "char large object", "clob");
public static final HSQLDBDataType<String> CHARACTERLARGEOBJECT = new HSQLDBDataType<String>(SQLDataType.CLOB, "character large object", "clob");
public static final HSQLDBDataType<Date> DATE = new HSQLDBDataType<Date>(SQLDataType.DATE, "date");
public static final HSQLDBDataType<Time> TIME = new HSQLDBDataType<Time>(SQLDataType.TIME, "time");
public static final HSQLDBDataType<Timestamp> TIMESTAMP = new HSQLDBDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final HSQLDBDataType<Timestamp> DATETIME = new HSQLDBDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final HSQLDBDataType<byte[]> LONGVARBINARY = new HSQLDBDataType<byte[]>(SQLDataType.LONGVARBINARY, "longvarbinary");
public static final HSQLDBDataType<byte[]> VARBINARY = new HSQLDBDataType<byte[]>(SQLDataType.VARBINARY, "varbinary", "varbinary(32672)");
public static final HSQLDBDataType<byte[]> BINARY = new HSQLDBDataType<byte[]>(SQLDataType.BINARY, "binary");
public static final HSQLDBDataType<byte[]> BLOB = new HSQLDBDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final HSQLDBDataType<byte[]> BINARYLARGEOBJECT = new HSQLDBDataType<byte[]>(SQLDataType.BLOB, "binary large object", "blob");
public static final HSQLDBDataType<Object> OTHER = new HSQLDBDataType<Object>(SQLDataType.OTHER, "other");
public static final HSQLDBDataType<YearToMonth> INTERVALYEARTOMONTH = new HSQLDBDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final HSQLDBDataType<DayToSecond> INTERVALDAYTOSECOND = new HSQLDBDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.HSQLDB, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.HSQLDB, SQLDataType.SMALLINT, "smallint");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.HSQLDB, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.HSQLDB, SQLDataType.INTEGER, "integer");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.HSQLDB, SQLDataType.BIGINT, "bigint");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.HSQLDB, SQLDataType.DOUBLE, "double");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.HSQLDB, SQLDataType.DOUBLE, "double precision");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.HSQLDB, SQLDataType.FLOAT, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.HSQLDB, SQLDataType.REAL, "real");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.HSQLDB, SQLDataType.BOOLEAN, "boolean");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.HSQLDB, SQLDataType.BIT, "bit");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.HSQLDB, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.HSQLDB, SQLDataType.NUMERIC, "numeric");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.VARCHAR, "varchar", "varchar(32672)");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.LONGVARCHAR, "longvarchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.CHAR, "character");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.VARCHAR, "character varying", "character varying(32672)");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.CLOB, "clob");
public static final DataType<String> CHARLARGEOBJECT = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.CLOB, "char large object", "clob");
public static final DataType<String> CHARACTERLARGEOBJECT = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.CLOB, "character large object", "clob");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.HSQLDB, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.HSQLDB, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.HSQLDB, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.HSQLDB, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<byte[]> LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.HSQLDB, SQLDataType.LONGVARBINARY, "longvarbinary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.HSQLDB, SQLDataType.VARBINARY, "varbinary", "varbinary(32672)");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.HSQLDB, SQLDataType.BINARY, "binary");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.HSQLDB, SQLDataType.BLOB, "blob");
public static final DataType<byte[]> BINARYLARGEOBJECT = new DefaultDataType<byte[]>(SQLDialect.HSQLDB, SQLDataType.BLOB, "binary large object", "blob");
public static final DataType<Object> OTHER = new DefaultDataType<Object>(SQLDialect.HSQLDB, SQLDataType.OTHER, "other");
public static final DataType<YearToMonth> INTERVALYEARTOMONTH = new DefaultDataType<YearToMonth>(SQLDialect.HSQLDB, SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final DataType<DayToSecond> INTERVALDAYTOSECOND = new DefaultDataType<DayToSecond>(SQLDialect.HSQLDB, SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.HSQLDB, SQLDataTypes
// -------------------------------------------------------------------------
protected static final HSQLDBDataType<String> __NCHAR = new HSQLDBDataType<String>(SQLDataType.NCHAR, "char");
protected static final HSQLDBDataType<String> __NCLOB = new HSQLDBDataType<String>(SQLDataType.NCLOB, "clob");
protected static final HSQLDBDataType<String> __LONGNVARCHAR = new HSQLDBDataType<String>(SQLDataType.LONGNVARCHAR, "longvarchar");
protected static final HSQLDBDataType<String> __NVARCHAR = new HSQLDBDataType<String>(SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.NCHAR, "char");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.NCLOB, "clob");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.LONGNVARCHAR, "longvarchar");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.NVARCHAR, "varchar", "varchar(32672)");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final HSQLDBDataType<BigInteger> __BIGINTEGER = new HSQLDBDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.HSQLDB, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final HSQLDBDataType<String> VARCHARIGNORECASE = new HSQLDBDataType<String>(SQLDataType.VARCHAR, "varchar_ignorecase", "varchar_ignorecase(32672)");
public static final HSQLDBDataType<Object> OBJECT = new HSQLDBDataType<Object>(SQLDataType.OTHER, "object");
public static final HSQLDBDataType<Result<Record>> ROW = new HSQLDBDataType<Result<Record>>(SQLDataType.RESULT, "row");
private HSQLDBDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.HSQLDB, sqlDataType, sqlDataType.getType(), typeName);
}
private HSQLDBDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.HSQLDB, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public static final DataType<String> VARCHARIGNORECASE = new DefaultDataType<String>(SQLDialect.HSQLDB, SQLDataType.VARCHAR, "varchar_ignorecase", "varchar_ignorecase(32672)");
public static final DataType<Object> OBJECT = new DefaultDataType<Object>(SQLDialect.HSQLDB, SQLDataType.OTHER, "object");
public static final DataType<Result<Record>> ROW = new DefaultDataType<Result<Record>>(SQLDialect.HSQLDB, SQLDataType.RESULT, "row");
}

133
jOOQ/src/main/java/org/jooq/util/ingres/IngresDataType.java
View File

@ -42,8 +42,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -53,95 +54,81 @@ import org.jooq.impl.SQLDataType;
* @see <a href="http://docs.ingres.com/ingres/9.3/quel-reference-guide/1240-data-types">http://docs.ingres.com/ingres/9.3/quel-reference-guide/1240-data-types</a>
* @see <a href="http://docs.ingres.com/ingres/10.0/sql-reference-guide/2638-storage-formats-of-data-types">http://docs.ingres.com/ingres/10.0/sql-reference-guide/2638-storage-formats-of-data-types</a>
*/
public class IngresDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class IngresDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final IngresDataType<Byte> TINYINT = new IngresDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final IngresDataType<Byte> INTEGER1 = new IngresDataType<Byte>(SQLDataType.TINYINT, "integer1");
public static final IngresDataType<Byte> I1 = new IngresDataType<Byte>(SQLDataType.TINYINT, "i1");
public static final IngresDataType<Short> SMALLINT = new IngresDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final IngresDataType<Short> INTEGER2 = new IngresDataType<Short>(SQLDataType.SMALLINT, "integer2");
public static final IngresDataType<Short> I2 = new IngresDataType<Short>(SQLDataType.SMALLINT, "i2");
public static final IngresDataType<Integer> INTEGER = new IngresDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final IngresDataType<Integer> INTEGER4 = new IngresDataType<Integer>(SQLDataType.INTEGER, "integer4");
public static final IngresDataType<Integer> I4 = new IngresDataType<Integer>(SQLDataType.INTEGER, "i4");
public static final IngresDataType<Long> BIGINT = new IngresDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final IngresDataType<Long> INTEGER8 = new IngresDataType<Long>(SQLDataType.BIGINT, "integer8");
public static final IngresDataType<Long> I8 = new IngresDataType<Long>(SQLDataType.BIGINT, "i8");
public static final IngresDataType<Double> FLOAT = new IngresDataType<Double>(SQLDataType.FLOAT, "float");
public static final IngresDataType<Double> FLOAT8 = new IngresDataType<Double>(SQLDataType.DOUBLE, "float8");
public static final IngresDataType<Double> DOUBLEPRECISION = new IngresDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final IngresDataType<Float> REAL = new IngresDataType<Float>(SQLDataType.REAL, "real");
public static final IngresDataType<Float> FLOAT4 = new IngresDataType<Float>(SQLDataType.REAL, "float4");
public static final IngresDataType<Boolean> BOOLEAN = new IngresDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final IngresDataType<BigDecimal> DECIMAL = new IngresDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal", "decimal(38, 19)");
public static final IngresDataType<String> VARCHAR = new IngresDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final IngresDataType<String> CHARACTERVARYING = new IngresDataType<String>(SQLDataType.VARCHAR, "character varying");
public static final IngresDataType<String> LONGVARCHAR = new IngresDataType<String>(SQLDataType.LONGVARCHAR, "long varchar");
public static final IngresDataType<String> CHAR = new IngresDataType<String>(SQLDataType.CHAR, "char");
public static final IngresDataType<String> CHARACTER = new IngresDataType<String>(SQLDataType.CHAR, "character");
public static final IngresDataType<String> C = new IngresDataType<String>(SQLDataType.CHAR, "c");
public static final IngresDataType<String> CLOB = new IngresDataType<String>(SQLDataType.CLOB, "clob");
public static final IngresDataType<String> CHARLARGEOBJECT = new IngresDataType<String>(SQLDataType.CLOB, "char large object");
public static final IngresDataType<String> CHARACTERLARGEOBJECT = new IngresDataType<String>(SQLDataType.CLOB, "character large object");
public static final IngresDataType<String> NVARCHAR = new IngresDataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final IngresDataType<String> LONGNVARCHAR = new IngresDataType<String>(SQLDataType.LONGNVARCHAR, "long nvarchar");
public static final IngresDataType<String> NCHAR = new IngresDataType<String>(SQLDataType.NCHAR, "nchar");
public static final IngresDataType<String> NCLOB = new IngresDataType<String>(SQLDataType.NCLOB, "nclob");
public static final IngresDataType<String> NCHARLARGEOBJECT = new IngresDataType<String>(SQLDataType.NCLOB, "nchar large object");
public static final IngresDataType<String> NATIONALCHARACTERLARGEOBJECT = new IngresDataType<String>(SQLDataType.NCLOB, "national character large object");
public static final IngresDataType<Date> DATE = new IngresDataType<Date>(SQLDataType.DATE, "date");
public static final IngresDataType<Time> TIME = new IngresDataType<Time>(SQLDataType.TIME, "time");
public static final IngresDataType<Timestamp> TIMESTAMP = new IngresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final IngresDataType<byte[]> BLOB = new IngresDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final IngresDataType<byte[]> BINARYLARGEOBJECT = new IngresDataType<byte[]>(SQLDataType.BLOB, "binary large object");
public static final IngresDataType<byte[]> BINARY = new IngresDataType<byte[]>(SQLDataType.BINARY, "binary");
public static final IngresDataType<byte[]> VARBINARY = new IngresDataType<byte[]>(SQLDataType.VARBINARY, "varbinary");
public static final IngresDataType<byte[]> LONGBYTE = new IngresDataType<byte[]>(SQLDataType.LONGVARBINARY, "long byte");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.INGRES, SQLDataType.TINYINT, "tinyint");
public static final DataType<Byte> INTEGER1 = new DefaultDataType<Byte>(SQLDialect.INGRES, SQLDataType.TINYINT, "integer1");
public static final DataType<Byte> I1 = new DefaultDataType<Byte>(SQLDialect.INGRES, SQLDataType.TINYINT, "i1");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.INGRES, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> INTEGER2 = new DefaultDataType<Short>(SQLDialect.INGRES, SQLDataType.SMALLINT, "integer2");
public static final DataType<Short> I2 = new DefaultDataType<Short>(SQLDialect.INGRES, SQLDataType.SMALLINT, "i2");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.INGRES, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> INTEGER4 = new DefaultDataType<Integer>(SQLDialect.INGRES, SQLDataType.INTEGER, "integer4");
public static final DataType<Integer> I4 = new DefaultDataType<Integer>(SQLDialect.INGRES, SQLDataType.INTEGER, "i4");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.INGRES, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> INTEGER8 = new DefaultDataType<Long>(SQLDialect.INGRES, SQLDataType.BIGINT, "integer8");
public static final DataType<Long> I8 = new DefaultDataType<Long>(SQLDialect.INGRES, SQLDataType.BIGINT, "i8");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.INGRES, SQLDataType.FLOAT, "float");
public static final DataType<Double> FLOAT8 = new DefaultDataType<Double>(SQLDialect.INGRES, SQLDataType.DOUBLE, "float8");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.INGRES, SQLDataType.DOUBLE, "double precision");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.INGRES, SQLDataType.REAL, "real");
public static final DataType<Float> FLOAT4 = new DefaultDataType<Float>(SQLDialect.INGRES, SQLDataType.REAL, "float4");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.INGRES, SQLDataType.BOOLEAN, "boolean");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.INGRES, SQLDataType.DECIMAL, "decimal", "decimal(38, 19)");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.VARCHAR, "character varying");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.LONGVARCHAR, "long varchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CHAR, "character");
public static final DataType<String> C = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CHAR, "c");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CLOB, "clob");
public static final DataType<String> CHARLARGEOBJECT = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CLOB, "char large object");
public static final DataType<String> CHARACTERLARGEOBJECT = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CLOB, "character large object");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.LONGNVARCHAR, "long nvarchar");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NCLOB = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.NCLOB, "nclob");
public static final DataType<String> NCHARLARGEOBJECT = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.NCLOB, "nchar large object");
public static final DataType<String> NATIONALCHARACTERLARGEOBJECT = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.NCLOB, "national character large object");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.INGRES, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.INGRES, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.INGRES, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.BLOB, "blob");
public static final DataType<byte[]> BINARYLARGEOBJECT = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.BLOB, "binary large object");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.BINARY, "binary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.VARBINARY, "varbinary");
public static final DataType<byte[]> LONGBYTE = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.LONGVARBINARY, "long byte");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.INGRES, SQLDataTypes
// -------------------------------------------------------------------------
public static final IngresDataType<Boolean> BIT = new IngresDataType<Boolean>(SQLDataType.BIT, "boolean");
public static final IngresDataType<BigDecimal> NUMERIC = new IngresDataType<BigDecimal>(SQLDataType.NUMERIC, "decimal", "decimal(38, 19)");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.INGRES, SQLDataType.BIT, "boolean");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.INGRES, SQLDataType.NUMERIC, "decimal", "decimal(38, 19)");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final IngresDataType<BigInteger> __BIGINTEGER = new IngresDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(38, 0)");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.INGRES, SQLDataType.DECIMAL_INTEGER, "decimal", "decimal(38, 0)");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final IngresDataType<String> TEXT = new IngresDataType<String>(SQLDataType.CLOB, "text");
public static final IngresDataType<Date> ANSIDATE = new IngresDataType<Date>(SQLDataType.DATE, "ansidate");
public static final IngresDataType<Date> INGRESDATE = new IngresDataType<Date>(SQLDataType.DATE, "ingresdate");
public static final IngresDataType<Time> TIMEWITHTIMEZONE = new IngresDataType<Time>(SQLDataType.TIME, "time with time zone");
public static final IngresDataType<Time> TIMEWITHOUTTIMEZONE = new IngresDataType<Time>(SQLDataType.TIME, "time without time zone");
public static final IngresDataType<Time> TIMEWITHLOCALTIMEZONE = new IngresDataType<Time>(SQLDataType.TIME, "time with local time zone");
public static final IngresDataType<Timestamp> TIMESTAMPWITHTIMEZONE = new IngresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp with time zone");
public static final IngresDataType<Timestamp> TIMESTAMPWITHOUTTIMEZONE = new IngresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp without time zone");
public static final IngresDataType<Timestamp> TIMESTAMPWITHLOCALTIMEZONE = new IngresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp with local time zone");
public static final IngresDataType<byte[]> BYTE = new IngresDataType<byte[]>(SQLDataType.BINARY, "byte");
public static final IngresDataType<byte[]> VARBYTE = new IngresDataType<byte[]>(SQLDataType.VARBINARY, "varbyte");
private IngresDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.INGRES, sqlDataType, sqlDataType.getType(), typeName);
}
private IngresDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.INGRES, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.INGRES, SQLDataType.CLOB, "text");
public static final DataType<Date> ANSIDATE = new DefaultDataType<Date>(SQLDialect.INGRES, SQLDataType.DATE, "ansidate");
public static final DataType<Date> INGRESDATE = new DefaultDataType<Date>(SQLDialect.INGRES, SQLDataType.DATE, "ingresdate");
public static final DataType<Time> TIMEWITHTIMEZONE = new DefaultDataType<Time>(SQLDialect.INGRES, SQLDataType.TIME, "time with time zone");
public static final DataType<Time> TIMEWITHOUTTIMEZONE = new DefaultDataType<Time>(SQLDialect.INGRES, SQLDataType.TIME, "time without time zone");
public static final DataType<Time> TIMEWITHLOCALTIMEZONE = new DefaultDataType<Time>(SQLDialect.INGRES, SQLDataType.TIME, "time with local time zone");
public static final DataType<Timestamp> TIMESTAMPWITHTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.INGRES, SQLDataType.TIMESTAMP, "timestamp with time zone");
public static final DataType<Timestamp> TIMESTAMPWITHOUTTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.INGRES, SQLDataType.TIMESTAMP, "timestamp without time zone");
public static final DataType<Timestamp> TIMESTAMPWITHLOCALTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.INGRES, SQLDataType.TIMESTAMP, "timestamp with local time zone");
public static final DataType<byte[]> BYTE = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.BINARY, "byte");
public static final DataType<byte[]> VARBYTE = new DefaultDataType<byte[]>(SQLDialect.INGRES, SQLDataType.VARBINARY, "varbyte");
}

109
jOOQ/src/main/java/org/jooq/util/mysql/MySQLDataType.java
View File

@ -42,8 +42,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.types.UByte;
import org.jooq.types.UInteger;
@ -57,81 +58,71 @@ import org.jooq.types.UShort;
* @see <a href="http://dev.mysql.com/doc/refman/5.5/en/data-types.html">http://dev.mysql.com/doc/refman/5.5/en/data-types.html</a>
* @see <a href="http://dev.mysql.com/doc/refman/5.5/en/cast-functions.html#function_cast">http://dev.mysql.com/doc/refman/5.5/en/cast-functions.html#function_cast</a>
*/
public class MySQLDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class MySQLDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final MySQLDataType<Byte> TINYINT = new MySQLDataType<Byte>(SQLDataType.TINYINT, "tinyint", "signed");
public static final MySQLDataType<UByte> TINYINTUNSIGNED = new MySQLDataType<UByte>(SQLDataType.TINYINTUNSIGNED, "tinyintunsigned", "unsigned");
public static final MySQLDataType<Short> SMALLINT = new MySQLDataType<Short>(SQLDataType.SMALLINT, "smallint", "signed");
public static final MySQLDataType<UShort> SMALLINTUNSIGNED = new MySQLDataType<UShort>(SQLDataType.SMALLINTUNSIGNED, "smallintunsigned", "unsigned");
public static final MySQLDataType<Integer> INT = new MySQLDataType<Integer>(SQLDataType.INTEGER, "int", "signed");
public static final MySQLDataType<UInteger> INTUNSIGNED = new MySQLDataType<UInteger>(SQLDataType.INTEGERUNSIGNED, "intunsigned", "unsigned");
public static final MySQLDataType<Integer> MEDIUMINT = new MySQLDataType<Integer>(SQLDataType.INTEGER, "mediumint", "signed");
public static final MySQLDataType<UInteger> MEDIUMINTUNSIGNED= new MySQLDataType<UInteger>(SQLDataType.INTEGERUNSIGNED, "mediumintunsigned", "unsigned");
public static final MySQLDataType<Integer> INTEGER = new MySQLDataType<Integer>(SQLDataType.INTEGER, "integer", "signed");
public static final MySQLDataType<UInteger> INTEGERUNSIGNED = new MySQLDataType<UInteger>(SQLDataType.INTEGERUNSIGNED, "integerunsigned", "unsigned");
public static final MySQLDataType<Long> BIGINT = new MySQLDataType<Long>(SQLDataType.BIGINT, "bigint", "signed");
public static final MySQLDataType<ULong> BIGINTUNSIGNED = new MySQLDataType<ULong>(SQLDataType.BIGINTUNSIGNED, "bigintunsigned", "unsigned");
public static final MySQLDataType<Double> DOUBLE = new MySQLDataType<Double>(SQLDataType.DOUBLE, "double", "decimal");
public static final MySQLDataType<Double> FLOAT = new MySQLDataType<Double>(SQLDataType.FLOAT, "float", "decimal");
public static final MySQLDataType<Float> REAL = new MySQLDataType<Float>(SQLDataType.REAL, "real", "decimal");
public static final MySQLDataType<Boolean> BOOLEAN = new MySQLDataType<Boolean>(SQLDataType.BOOLEAN, "boolean", "unsigned");
public static final MySQLDataType<Boolean> BOOL = new MySQLDataType<Boolean>(SQLDataType.BOOLEAN, "bool", "unsigned");
public static final MySQLDataType<Boolean> BIT = new MySQLDataType<Boolean>(SQLDataType.BIT, "bit", "unsigned");
public static final MySQLDataType<BigDecimal> DECIMAL = new MySQLDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal", "decimal");
public static final MySQLDataType<BigDecimal> DEC = new MySQLDataType<BigDecimal>(SQLDataType.DECIMAL, "dec", "decimal");
public static final MySQLDataType<String> VARCHAR = new MySQLDataType<String>(SQLDataType.VARCHAR, "varchar", "char");
public static final MySQLDataType<String> CHAR = new MySQLDataType<String>(SQLDataType.CHAR, "char", "char");
public static final MySQLDataType<String> TEXT = new MySQLDataType<String>(SQLDataType.CLOB, "text", "char");
public static final MySQLDataType<byte[]> BLOB = new MySQLDataType<byte[]>(SQLDataType.BLOB, "blob", "binary");
public static final MySQLDataType<byte[]> BINARY = new MySQLDataType<byte[]>(SQLDataType.BINARY, "binary", "binary");
public static final MySQLDataType<byte[]> VARBINARY = new MySQLDataType<byte[]>(SQLDataType.VARBINARY, "varbinary", "binary");
public static final MySQLDataType<Date> DATE = new MySQLDataType<Date>(SQLDataType.DATE, "date", "date");
public static final MySQLDataType<Time> TIME = new MySQLDataType<Time>(SQLDataType.TIME, "time", "time");
public static final MySQLDataType<Timestamp> TIMESTAMP = new MySQLDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp", "datetime");
public static final MySQLDataType<Timestamp> DATETIME = new MySQLDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime", "datetime");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.MYSQL, SQLDataType.TINYINT, "tinyint", "signed");
public static final DataType<UByte> TINYINTUNSIGNED = new DefaultDataType<UByte>(SQLDialect.MYSQL, SQLDataType.TINYINTUNSIGNED, "tinyintunsigned", "unsigned");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.MYSQL, SQLDataType.SMALLINT, "smallint", "signed");
public static final DataType<UShort> SMALLINTUNSIGNED = new DefaultDataType<UShort>(SQLDialect.MYSQL, SQLDataType.SMALLINTUNSIGNED, "smallintunsigned", "unsigned");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.MYSQL, SQLDataType.INTEGER, "int", "signed");
public static final DataType<UInteger> INTUNSIGNED = new DefaultDataType<UInteger>(SQLDialect.MYSQL, SQLDataType.INTEGERUNSIGNED, "intunsigned", "unsigned");
public static final DataType<Integer> MEDIUMINT = new DefaultDataType<Integer>(SQLDialect.MYSQL, SQLDataType.INTEGER, "mediumint", "signed");
public static final DataType<UInteger> MEDIUMINTUNSIGNED = new DefaultDataType<UInteger>(SQLDialect.MYSQL, SQLDataType.INTEGERUNSIGNED, "mediumintunsigned", "unsigned");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.MYSQL, SQLDataType.INTEGER, "integer", "signed");
public static final DataType<UInteger> INTEGERUNSIGNED = new DefaultDataType<UInteger>(SQLDialect.MYSQL, SQLDataType.INTEGERUNSIGNED, "integerunsigned", "unsigned");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.MYSQL, SQLDataType.BIGINT, "bigint", "signed");
public static final DataType<ULong> BIGINTUNSIGNED = new DefaultDataType<ULong>(SQLDialect.MYSQL, SQLDataType.BIGINTUNSIGNED, "bigintunsigned", "unsigned");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.MYSQL, SQLDataType.DOUBLE, "double", "decimal");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.MYSQL, SQLDataType.FLOAT, "float", "decimal");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.MYSQL, SQLDataType.REAL, "real", "decimal");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.MYSQL, SQLDataType.BOOLEAN, "boolean", "unsigned");
public static final DataType<Boolean> BOOL = new DefaultDataType<Boolean>(SQLDialect.MYSQL, SQLDataType.BOOLEAN, "bool", "unsigned");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.MYSQL, SQLDataType.BIT, "bit", "unsigned");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.MYSQL, SQLDataType.DECIMAL, "decimal", "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.MYSQL, SQLDataType.DECIMAL, "dec", "decimal");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.VARCHAR, "varchar", "char");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.CHAR, "char", "char");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.CLOB, "text", "char");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.BLOB, "blob", "binary");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.BINARY, "binary", "binary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.VARBINARY, "varbinary", "binary");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.MYSQL, SQLDataType.DATE, "date", "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.MYSQL, SQLDataType.TIME, "time", "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.MYSQL, SQLDataType.TIMESTAMP, "timestamp", "datetime");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.MYSQL, SQLDataType.TIMESTAMP, "datetime", "datetime");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.MYSQL, SQLDataTypes
// -------------------------------------------------------------------------
protected static final MySQLDataType<String> __NCHAR = new MySQLDataType<String>(SQLDataType.NCHAR, "char", "char");
protected static final MySQLDataType<String> __NCLOB = new MySQLDataType<String>(SQLDataType.NCLOB, "clob", "char");
protected static final MySQLDataType<String> __LONGNVARCHAR = new MySQLDataType<String>(SQLDataType.LONGNVARCHAR, "varchar", "char");
protected static final MySQLDataType<BigDecimal> __NUMERIC = new MySQLDataType<BigDecimal>(SQLDataType.NUMERIC, "decimal", "decimal");
protected static final MySQLDataType<String> __NVARCHAR = new MySQLDataType<String>(SQLDataType.NVARCHAR, "varchar", "char");
protected static final MySQLDataType<String> __LONGVARCHAR = new MySQLDataType<String>(SQLDataType.LONGVARCHAR, "varchar", "char");
protected static final MySQLDataType<byte[]> __LONGVARBINARY = new MySQLDataType<byte[]>(SQLDataType.LONGVARBINARY, "varbinary", "binary");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.NCHAR, "char", "char");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.NCLOB, "clob", "char");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.LONGNVARCHAR, "varchar", "char");
protected static final DataType<BigDecimal> __NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.MYSQL, SQLDataType.NUMERIC, "decimal", "decimal");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.NVARCHAR, "varchar", "char");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.LONGVARCHAR, "varchar", "char");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.LONGVARBINARY, "varbinary", "binary");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final MySQLDataType<BigInteger> __BIGINTEGER = new MySQLDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal", "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.MYSQL, SQLDataType.DECIMAL_INTEGER, "decimal", "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final MySQLDataType<String> MEDIUMTEXT = new MySQLDataType<String>(SQLDataType.CLOB, "mediumtext", "char");
public static final MySQLDataType<String> LONGTEXT = new MySQLDataType<String>(SQLDataType.CLOB, "longtext", "char");
public static final MySQLDataType<String> ENUM = new MySQLDataType<String>(SQLDataType.VARCHAR, "enum", "char");
public static final MySQLDataType<String> SET = new MySQLDataType<String>(SQLDataType.VARCHAR, "set", "char");
public static final MySQLDataType<byte[]> TINYBLOB = new MySQLDataType<byte[]>(SQLDataType.BLOB, "tinyblob", "binary");
public static final MySQLDataType<byte[]> MEDIUMBLOB = new MySQLDataType<byte[]>(SQLDataType.BLOB, "mediumblob", "binary");
public static final MySQLDataType<byte[]> LONGBLOB = new MySQLDataType<byte[]>(SQLDataType.BLOB, "longblob", "binary");
public static final MySQLDataType<Date> YEAR = new MySQLDataType<Date>(SQLDataType.DATE, "year", "date");
private MySQLDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.MYSQL, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
}
public static final DataType<String> MEDIUMTEXT = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.CLOB, "mediumtext", "char");
public static final DataType<String> LONGTEXT = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.CLOB, "longtext", "char");
public static final DataType<String> ENUM = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.VARCHAR, "enum", "char");
public static final DataType<String> SET = new DefaultDataType<String>(SQLDialect.MYSQL, SQLDataType.VARCHAR, "set", "char");
public static final DataType<byte[]> TINYBLOB = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.BLOB, "tinyblob", "binary");
public static final DataType<byte[]> MEDIUMBLOB = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.BLOB, "mediumblob", "binary");
public static final DataType<byte[]> LONGBLOB = new DefaultDataType<byte[]>(SQLDialect.MYSQL, SQLDataType.BLOB, "longblob", "binary");
public static final DataType<Date> YEAR = new DefaultDataType<Date>(SQLDialect.MYSQL, SQLDataType.DATE, "year", "date");
}

129
jOOQ/src/main/java/org/jooq/util/oracle/OracleDataType.java
View File

@ -41,10 +41,11 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.types.DayToSecond;
import org.jooq.types.YearToMonth;
@ -56,95 +57,87 @@ import org.jooq.types.YearToMonth;
* @see <a href="http://www.techonthenet.com/oracle/datatypes.php">http://www.techonthenet.com/oracle/datatypes.php</a>
* @see <a href="http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14261/datatypes.htm">http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14261/datatypes.htm</a>
*/
public class OracleDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class OracleDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final OracleDataType<BigDecimal> NUMBER = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "number");
public static final OracleDataType<BigDecimal> NUMERIC = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final OracleDataType<BigDecimal> DECIMAL = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final OracleDataType<BigDecimal> DEC = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "dec");
public static final OracleDataType<String> VARCHAR2 = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar2", "varchar2(4000)");
public static final OracleDataType<String> VARCHAR = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar2(4000)");
public static final OracleDataType<String> CHAR = new OracleDataType<String>(SQLDataType.CHAR, "char", "varchar2(4000)");
public static final OracleDataType<String> CLOB = new OracleDataType<String>(SQLDataType.CLOB, "clob");
public static final OracleDataType<String> NVARCHAR2 = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar2", "varchar2(4000)");
public static final OracleDataType<String> NVARCHAR = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar", "varchar2(4000)");
public static final OracleDataType<String> NCHAR = new OracleDataType<String>(SQLDataType.NCHAR, "nchar", "varchar2(4000)");
public static final OracleDataType<String> NCLOB = new OracleDataType<String>(SQLDataType.NCLOB, "nclob");
public static final OracleDataType<Date> DATE = new OracleDataType<Date>(SQLDataType.DATE, "date");
public static final OracleDataType<Timestamp> TIMESTAMP = new OracleDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final OracleDataType<byte[]> BLOB = new OracleDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final OracleDataType<YearToMonth> INTERVALYEARTOMONTH = new OracleDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final OracleDataType<DayToSecond> INTERVALDAYTOSECOND = new OracleDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
public static final DataType<BigDecimal> NUMBER = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.NUMERIC, "number");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.NUMERIC, "numeric");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> DEC = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.DECIMAL, "dec");
public static final DataType<String> VARCHAR2 = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.VARCHAR, "varchar2", "varchar2(4000)");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.VARCHAR, "varchar", "varchar2(4000)");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.CHAR, "char", "varchar2(4000)");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.CLOB, "clob");
public static final DataType<String> NVARCHAR2 = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.NVARCHAR, "nvarchar2", "varchar2(4000)");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.NVARCHAR, "nvarchar", "varchar2(4000)");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.NCHAR, "nchar", "varchar2(4000)");
public static final DataType<String> NCLOB = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.NCLOB, "nclob");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.ORACLE, SQLDataType.DATE, "date");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.ORACLE, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.BLOB, "blob");
public static final DataType<YearToMonth> INTERVALYEARTOMONTH = new DefaultDataType<YearToMonth>(SQLDialect.ORACLE, SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final DataType<DayToSecond> INTERVALDAYTOSECOND = new DefaultDataType<DayToSecond>(SQLDialect.ORACLE, SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.ORACLE, SQLDataTypes
// -------------------------------------------------------------------------
protected static final OracleDataType<byte[]> __BINARY = new OracleDataType<byte[]>(SQLDataType.BINARY, "blob");
protected static final OracleDataType<Long> __BIGINT = new OracleDataType<Long>(SQLDataType.BIGINT, "number", "number(19)");
protected static final OracleDataType<Boolean> __BIT = new OracleDataType<Boolean>(SQLDataType.BIT, "number", "number(1)");
protected static final OracleDataType<Boolean> __BOOLEAN = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "number", "number(1)");
protected static final OracleDataType<Double> __DOUBLE = new OracleDataType<Double>(SQLDataType.DOUBLE, "number");
protected static final OracleDataType<Double> __FLOAT = new OracleDataType<Double>(SQLDataType.FLOAT, "number");
protected static final OracleDataType<Integer> __INTEGER = new OracleDataType<Integer>(SQLDataType.INTEGER, "number", "number(10)");
protected static final OracleDataType<byte[]> __LONGVARBINARY = new OracleDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
protected static final OracleDataType<String> __LONGVARCHAR = new OracleDataType<String>(SQLDataType.LONGVARCHAR, "varchar2", "varchar2(4000)");
protected static final OracleDataType<String> __LONGNVARCHAR = new OracleDataType<String>(SQLDataType.LONGNVARCHAR, "varchar2", "varchar2(4000)");
protected static final OracleDataType<Float> __REAL = new OracleDataType<Float>(SQLDataType.REAL, "number");
protected static final OracleDataType<Short> __SMALLINT = new OracleDataType<Short>(SQLDataType.SMALLINT, "number", "number(5)");
protected static final OracleDataType<Time> __TIME = new OracleDataType<Time>(SQLDataType.TIME, "timestamp");
protected static final OracleDataType<Byte> __TINYINT = new OracleDataType<Byte>(SQLDataType.TINYINT, "number", "number(3)");
protected static final OracleDataType<byte[]> __VARBINARY = new OracleDataType<byte[]>(SQLDataType.VARBINARY, "blob");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.BINARY, "blob");
protected static final DataType<Long> __BIGINT = new DefaultDataType<Long>(SQLDialect.ORACLE, SQLDataType.BIGINT, "number", "number(19)");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.ORACLE, SQLDataType.BIT, "number", "number(1)");
protected static final DataType<Boolean> __BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.ORACLE, SQLDataType.BOOLEAN, "number", "number(1)");
protected static final DataType<Double> __DOUBLE = new DefaultDataType<Double>(SQLDialect.ORACLE, SQLDataType.DOUBLE, "number");
protected static final DataType<Double> __FLOAT = new DefaultDataType<Double>(SQLDialect.ORACLE, SQLDataType.FLOAT, "number");
protected static final DataType<Integer> __INTEGER = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "number", "number(10)");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.LONGVARBINARY, "blob");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.LONGVARCHAR, "varchar2", "varchar2(4000)");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.LONGNVARCHAR, "varchar2", "varchar2(4000)");
protected static final DataType<Float> __REAL = new DefaultDataType<Float>(SQLDialect.ORACLE, SQLDataType.REAL, "number");
protected static final DataType<Short> __SMALLINT = new DefaultDataType<Short>(SQLDialect.ORACLE, SQLDataType.SMALLINT, "number", "number(5)");
protected static final DataType<Time> __TIME = new DefaultDataType<Time>(SQLDialect.ORACLE, SQLDataType.TIME, "timestamp");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.ORACLE, SQLDataType.TINYINT, "number", "number(3)");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.VARBINARY, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final OracleDataType<BigInteger> __BIGINTEGER = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "number");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.ORACLE, SQLDataType.DECIMAL_INTEGER, "number");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final OracleDataType<Result<Record>> REF_CURSOR = new OracleDataType<Result<Record>>(SQLDataType.RESULT, "ref cursor");
public static final DataType<Result<Record>> REF_CURSOR = new DefaultDataType<Result<Record>>(SQLDialect.ORACLE, SQLDataType.RESULT, "ref cursor");
public static final OracleDataType<String> LONG = new OracleDataType<String>(SQLDataType.CLOB, "long");
public static final OracleDataType<byte[]> RAW = new OracleDataType<byte[]>(SQLDataType.BLOB, "raw");
public static final OracleDataType<byte[]> LONGRAW = new OracleDataType<byte[]>(SQLDataType.BLOB, "longraw");
public static final OracleDataType<byte[]> BFILE = new OracleDataType<byte[]>(SQLDataType.BLOB, "bfile");
public static final DataType<String> LONG = new DefaultDataType<String>(SQLDialect.ORACLE, SQLDataType.CLOB, "long");
public static final DataType<byte[]> RAW = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.BLOB, "raw");
public static final DataType<byte[]> LONGRAW = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.BLOB, "longraw");
public static final DataType<byte[]> BFILE = new DefaultDataType<byte[]>(SQLDialect.ORACLE, SQLDataType.BLOB, "bfile");
// PL/SQL data types
public static final OracleDataType<Integer> BINARY_INTEGER = new OracleDataType<Integer>(SQLDataType.INTEGER, "binary_integer");
public static final OracleDataType<Integer> PLS_INTEGER = new OracleDataType<Integer>(SQLDataType.INTEGER, "pls_integer");
public static final OracleDataType<Integer> NATURAL = new OracleDataType<Integer>(SQLDataType.INTEGER, "natural");
public static final OracleDataType<Integer> NATURALN = new OracleDataType<Integer>(SQLDataType.INTEGER, "naturaln");
public static final OracleDataType<Integer> POSITIVE = new OracleDataType<Integer>(SQLDataType.INTEGER, "positive");
public static final OracleDataType<Integer> POSITIVEN = new OracleDataType<Integer>(SQLDataType.INTEGER, "positiven");
public static final OracleDataType<Integer> SIGNTYPE = new OracleDataType<Integer>(SQLDataType.INTEGER, "signtype");
public static final OracleDataType<Double> REAL = new OracleDataType<Double>(SQLDataType.DOUBLE, "real");
public static final OracleDataType<Double> DOUBLE_PRECISION = new OracleDataType<Double>(SQLDataType.DOUBLE, "double_precision");
public static final OracleDataType<Double> BINARY_DOUBLE = new OracleDataType<Double>(SQLDataType.DOUBLE, "binary_double");
public static final OracleDataType<BigDecimal> FLOAT = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "float");
public static final OracleDataType<BigDecimal> BINARY_FLOAT = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "binary_float");
public static final OracleDataType<BigInteger> INTEGER = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "integer");
public static final OracleDataType<BigInteger> INT = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "int");
public static final OracleDataType<BigInteger> SMALLINT = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "smallint");
public static final OracleDataType<Boolean> BOOLEAN = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final DataType<Integer> BINARY_INTEGER = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "binary_integer");
public static final DataType<Integer> PLS_INTEGER = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "pls_integer");
public static final DataType<Integer> NATURAL = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "natural");
public static final DataType<Integer> NATURALN = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "naturaln");
public static final DataType<Integer> POSITIVE = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "positive");
public static final DataType<Integer> POSITIVEN = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "positiven");
public static final DataType<Integer> SIGNTYPE = new DefaultDataType<Integer>(SQLDialect.ORACLE, SQLDataType.INTEGER, "signtype");
public static final DataType<Double> REAL = new DefaultDataType<Double>(SQLDialect.ORACLE, SQLDataType.DOUBLE, "real");
public static final DataType<Double> DOUBLE_PRECISION = new DefaultDataType<Double>(SQLDialect.ORACLE, SQLDataType.DOUBLE, "double_precision");
public static final DataType<Double> BINARY_DOUBLE = new DefaultDataType<Double>(SQLDialect.ORACLE, SQLDataType.DOUBLE, "binary_double");
public static final DataType<BigDecimal> FLOAT = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.DECIMAL, "float");
public static final DataType<BigDecimal> BINARY_FLOAT = new DefaultDataType<BigDecimal>(SQLDialect.ORACLE, SQLDataType.DECIMAL, "binary_float");
public static final DataType<BigInteger> INTEGER = new DefaultDataType<BigInteger>(SQLDialect.ORACLE, SQLDataType.DECIMAL_INTEGER, "integer");
public static final DataType<BigInteger> INT = new DefaultDataType<BigInteger>(SQLDialect.ORACLE, SQLDataType.DECIMAL_INTEGER, "int");
public static final DataType<BigInteger> SMALLINT = new DefaultDataType<BigInteger>(SQLDialect.ORACLE, SQLDataType.DECIMAL_INTEGER, "smallint");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.ORACLE, SQLDataType.BOOLEAN, "boolean");
private OracleDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.ORACLE, sqlDataType, sqlDataType.getType(), typeName);
}
private OracleDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.ORACLE, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
@Deprecated
public static DataType<Object> getDefaultDataType(String string) {
return DefaultDataType.getDefaultDataType(string);
}
}

142
jOOQ/src/main/java/org/jooq/util/postgres/PostgresDataType.java
View File

@ -42,10 +42,11 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
import org.jooq.types.DayToSecond;
import org.jooq.types.YearToMonth;
@ -56,99 +57,94 @@ import org.jooq.types.YearToMonth;
* @author Lukas Eder
* @see <a href="http://www.postgresql.org/docs/9.0/interactive/datatype.html">http://www.postgresql.org/docs/9.0/interactive/datatype.html</a>
*/
public class PostgresDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class PostgresDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final PostgresDataType<Short> SMALLINT = new PostgresDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final PostgresDataType<Short> INT2 = new PostgresDataType<Short>(SQLDataType.SMALLINT, "int2");
public static final PostgresDataType<Integer> INT = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int");
public static final PostgresDataType<Integer> INTEGER = new PostgresDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final PostgresDataType<Integer> INT4 = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int4");
public static final PostgresDataType<Long> BIGINT = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final PostgresDataType<Long> INT8 = new PostgresDataType<Long>(SQLDataType.BIGINT, "int8");
public static final PostgresDataType<Double> DOUBLEPRECISION = new PostgresDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final PostgresDataType<Double> FLOAT8 = new PostgresDataType<Double>(SQLDataType.FLOAT, "float8");
public static final PostgresDataType<Float> REAL = new PostgresDataType<Float>(SQLDataType.REAL, "real");
public static final PostgresDataType<Float> FLOAT4 = new PostgresDataType<Float>(SQLDataType.REAL, "float4");
public static final PostgresDataType<Boolean> BOOLEAN = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final PostgresDataType<Boolean> BOOL = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "bool");
public static final PostgresDataType<BigDecimal> NUMERIC = new PostgresDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final PostgresDataType<BigDecimal> DECIMAL = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final PostgresDataType<String> VARCHAR = new PostgresDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final PostgresDataType<String> CHARACTERVARYING = new PostgresDataType<String>(SQLDataType.VARCHAR, "character varying");
public static final PostgresDataType<String> CHAR = new PostgresDataType<String>(SQLDataType.CHAR, "char");
public static final PostgresDataType<String> CHARACTER = new PostgresDataType<String>(SQLDataType.CHAR, "character");
public static final PostgresDataType<String> TEXT = new PostgresDataType<String>(SQLDataType.CLOB, "text");
public static final PostgresDataType<Date> DATE = new PostgresDataType<Date>(SQLDataType.DATE, "date");
public static final PostgresDataType<Time> TIME = new PostgresDataType<Time>(SQLDataType.TIME, "time");
public static final PostgresDataType<Timestamp> TIMESTAMP = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final PostgresDataType<byte[]> BYTEA = new PostgresDataType<byte[]>(SQLDataType.BLOB, "bytea");
public static final PostgresDataType<YearToMonth> INTERVALYEARTOMONTH = new PostgresDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final PostgresDataType<DayToSecond> INTERVALDAYTOSECOND = new PostgresDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.POSTGRES, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> INT2 = new DefaultDataType<Short>(SQLDialect.POSTGRES, SQLDataType.SMALLINT, "int2");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.POSTGRES, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.POSTGRES, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> INT4 = new DefaultDataType<Integer>(SQLDialect.POSTGRES, SQLDataType.INTEGER, "int4");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> INT8 = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "int8");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.POSTGRES, SQLDataType.DOUBLE, "double precision");
public static final DataType<Double> FLOAT8 = new DefaultDataType<Double>(SQLDialect.POSTGRES, SQLDataType.FLOAT, "float8");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.POSTGRES, SQLDataType.REAL, "real");
public static final DataType<Float> FLOAT4 = new DefaultDataType<Float>(SQLDialect.POSTGRES, SQLDataType.REAL, "float4");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.POSTGRES, SQLDataType.BOOLEAN, "boolean");
public static final DataType<Boolean> BOOL = new DefaultDataType<Boolean>(SQLDialect.POSTGRES, SQLDataType.BOOLEAN, "bool");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.POSTGRES, SQLDataType.NUMERIC, "numeric");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.POSTGRES, SQLDataType.DECIMAL, "decimal");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHARACTERVARYING = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "character varying");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.CHAR, "character");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.CLOB, "text");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.POSTGRES, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.POSTGRES, SQLDataType.TIME, "time");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.POSTGRES, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BYTEA = new DefaultDataType<byte[]>(SQLDialect.POSTGRES, SQLDataType.BLOB, "bytea");
public static final DataType<YearToMonth> INTERVALYEARTOMONTH = new DefaultDataType<YearToMonth>(SQLDialect.POSTGRES, SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
public static final DataType<DayToSecond> INTERVALDAYTOSECOND = new DefaultDataType<DayToSecond>(SQLDialect.POSTGRES, SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.POSTGRES, SQLDataTypes
// -------------------------------------------------------------------------
protected static final PostgresDataType<byte[]> __BINARY = new PostgresDataType<byte[]>(SQLDataType.BINARY, "bytea");
protected static final PostgresDataType<Boolean> __BIT = new PostgresDataType<Boolean>(SQLDataType.BIT, "boolean");
protected static final PostgresDataType<byte[]> __LONGVARBINARY = new PostgresDataType<byte[]>(SQLDataType.LONGVARBINARY, "bytea");
protected static final PostgresDataType<String> __LONGVARCHAR = new PostgresDataType<String>(SQLDataType.LONGVARCHAR, "varchar");
protected static final PostgresDataType<String> __NCHAR = new PostgresDataType<String>(SQLDataType.NCHAR, "char");
protected static final PostgresDataType<String> __NCLOB = new PostgresDataType<String>(SQLDataType.NCLOB, "text");
protected static final PostgresDataType<String> __LONGNVARCHAR = new PostgresDataType<String>(SQLDataType.LONGNVARCHAR, "varchar");
protected static final PostgresDataType<String> __NVARCHAR = new PostgresDataType<String>(SQLDataType.NVARCHAR, "varchar");
protected static final PostgresDataType<Byte> __TINYINT = new PostgresDataType<Byte>(SQLDataType.TINYINT, "smallint");
protected static final PostgresDataType<byte[]> __VARBINARY = new PostgresDataType<byte[]>(SQLDataType.VARBINARY, "bytea");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.POSTGRES, SQLDataType.BINARY, "bytea");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.POSTGRES, SQLDataType.BIT, "boolean");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.POSTGRES, SQLDataType.LONGVARBINARY, "bytea");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.LONGVARCHAR, "varchar");
protected static final DataType<String> __NCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.NCHAR, "char");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.NCLOB, "text");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.LONGNVARCHAR, "varchar");
protected static final DataType<String> __NVARCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.NVARCHAR, "varchar");
protected static final DataType<Byte> __TINYINT = new DefaultDataType<Byte>(SQLDialect.POSTGRES, SQLDataType.TINYINT, "smallint");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.POSTGRES, SQLDataType.VARBINARY, "bytea");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final PostgresDataType<BigInteger> __BIGINTEGER = new PostgresDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.POSTGRES, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final PostgresDataType<Integer> SERIAL = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial");
public static final PostgresDataType<Integer> SERIAL4 = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial4");
public static final PostgresDataType<Long> BIGSERIAL = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigserial");
public static final PostgresDataType<Long> SERIAL8 = new PostgresDataType<Long>(SQLDataType.BIGINT, "serial8");
public static final PostgresDataType<BigDecimal> MONEY = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
public static final PostgresDataType<String> BITVARYING = new PostgresDataType<String>(SQLDataType.VARCHAR, "bit varying");
public static final PostgresDataType<String> VARBIT = new PostgresDataType<String>(SQLDataType.VARCHAR, "varbit");
public static final PostgresDataType<String> BIT = new PostgresDataType<String>(SQLDataType.CHAR, "bit");
public static final PostgresDataType<String> BPCHAR = new PostgresDataType<String>(SQLDataType.CHAR, "bpchar");
public static final PostgresDataType<Time> TIMEWITHOUTTIMEZONE = new PostgresDataType<Time>(SQLDataType.TIME, "time without time zone");
public static final PostgresDataType<Time> TIMEWITHTIMEZONE = new PostgresDataType<Time>(SQLDataType.TIME, "time with time zone");
public static final PostgresDataType<Time> TIMETZ = new PostgresDataType<Time>(SQLDataType.TIME, "timetz");
public static final PostgresDataType<Timestamp> TIMESTAMPWITHOUTTIMEZONE = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp without time zone");
public static final PostgresDataType<Timestamp> TIMESTAMPWITHTIMEZONE = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp with time zone");
public static final PostgresDataType<Timestamp> TIMESTAMPTZ = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamptz");
public static final PostgresDataType<Result<Record>> REFCURSOR = new PostgresDataType<Result<Record>>(SQLDataType.RESULT, "refcursor");
public static final PostgresDataType<Object> ANY = new PostgresDataType<Object>(SQLDataType.OTHER, "any");
public static final DataType<Integer> SERIAL = new DefaultDataType<Integer>(SQLDialect.POSTGRES, SQLDataType.INTEGER, "serial");
public static final DataType<Integer> SERIAL4 = new DefaultDataType<Integer>(SQLDialect.POSTGRES, SQLDataType.INTEGER, "serial4");
public static final DataType<Long> BIGSERIAL = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "bigserial");
public static final DataType<Long> SERIAL8 = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "serial8");
public static final DataType<BigDecimal> MONEY = new DefaultDataType<BigDecimal>(SQLDialect.POSTGRES, SQLDataType.DECIMAL, "money");
public static final DataType<String> BITVARYING = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "bit varying");
public static final DataType<String> VARBIT = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "varbit");
public static final DataType<String> BIT = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.CHAR, "bit");
public static final DataType<String> BPCHAR = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.CHAR, "bpchar");
public static final DataType<Time> TIMEWITHOUTTIMEZONE = new DefaultDataType<Time>(SQLDialect.POSTGRES, SQLDataType.TIME, "time without time zone");
public static final DataType<Time> TIMEWITHTIMEZONE = new DefaultDataType<Time>(SQLDialect.POSTGRES, SQLDataType.TIME, "time with time zone");
public static final DataType<Time> TIMETZ = new DefaultDataType<Time>(SQLDialect.POSTGRES, SQLDataType.TIME, "timetz");
public static final DataType<Timestamp> TIMESTAMPWITHOUTTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.POSTGRES, SQLDataType.TIMESTAMP, "timestamp without time zone");
public static final DataType<Timestamp> TIMESTAMPWITHTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.POSTGRES, SQLDataType.TIMESTAMP, "timestamp with time zone");
public static final DataType<Timestamp> TIMESTAMPTZ = new DefaultDataType<Timestamp>(SQLDialect.POSTGRES, SQLDataType.TIMESTAMP, "timestamptz");
public static final DataType<Result<Record>> REFCURSOR = new DefaultDataType<Result<Record>>(SQLDialect.POSTGRES, SQLDataType.RESULT, "refcursor");
public static final DataType<Object> ANY = new DefaultDataType<Object>(SQLDialect.POSTGRES, SQLDataType.OTHER, "any");
// Meta-table types
public static final PostgresDataType<Long> OID = new PostgresDataType<Long>(SQLDataType.BIGINT, "oid");
public static final PostgresDataType<Long> OIDVECTOR = new PostgresDataType<Long>(SQLDataType.BIGINT, "oidvector");
public static final PostgresDataType<Long> XID = new PostgresDataType<Long>(SQLDataType.BIGINT, "xid");
public static final PostgresDataType<Long> TID = new PostgresDataType<Long>(SQLDataType.BIGINT, "tid");
public static final PostgresDataType<Long> CID = new PostgresDataType<Long>(SQLDataType.BIGINT, "cid");
public static final PostgresDataType<String> ACLITEM = new PostgresDataType<String>(SQLDataType.VARCHAR, "aclitem");
public static final PostgresDataType<String> NAME = new PostgresDataType<String>(SQLDataType.VARCHAR, "name");
public static final PostgresDataType<String> REGPROC = new PostgresDataType<String>(SQLDataType.VARCHAR, "regproc");
public static final DataType<Long> OID = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "oid");
public static final DataType<Long> OIDVECTOR = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "oidvector");
public static final DataType<Long> XID = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "xid");
public static final DataType<Long> TID = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "tid");
public static final DataType<Long> CID = new DefaultDataType<Long>(SQLDialect.POSTGRES, SQLDataType.BIGINT, "cid");
public static final DataType<String> ACLITEM = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "aclitem");
public static final DataType<String> NAME = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "name");
public static final DataType<String> REGPROC = new DefaultDataType<String>(SQLDialect.POSTGRES, SQLDataType.VARCHAR, "regproc");
private PostgresDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.POSTGRES, sqlDataType, sqlDataType.getType(), typeName);
@Deprecated
public static DataType<Object> getDefaultDataType(String string) {
return DefaultDataType.getDefaultDataType(string);
}
}

94
jOOQ/src/main/java/org/jooq/util/sqlite/SQLiteDataType.java
View File

@ -41,8 +41,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -51,59 +52,54 @@ import org.jooq.impl.SQLDataType;
* @author Lukas Eder
* @see <a href="http://www.sqlite.org/datatype3.html">http://www.sqlite.org/datatype3.html</a>
*/
public class SQLiteDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class SQLiteDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SQLiteDataType<Byte> TINYINT = new SQLiteDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final SQLiteDataType<Short> SMALLINT = new SQLiteDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final SQLiteDataType<Short> INT2 = new SQLiteDataType<Short>(SQLDataType.SMALLINT, "int2");
public static final SQLiteDataType<Integer> INT = new SQLiteDataType<Integer>(SQLDataType.INTEGER, "int");
public static final SQLiteDataType<Integer> INTEGER = new SQLiteDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final SQLiteDataType<Integer> MEDIUMINT = new SQLiteDataType<Integer>(SQLDataType.INTEGER, "mediumint");
public static final SQLiteDataType<Long> INT8 = new SQLiteDataType<Long>(SQLDataType.BIGINT, "int8");
public static final SQLiteDataType<BigInteger> BIGINT = new SQLiteDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "bigint");
public static final SQLiteDataType<BigInteger> UNSIGNEDBIGINT = new SQLiteDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "unsigned big int");
public static final SQLiteDataType<Double> DOUBLE = new SQLiteDataType<Double>(SQLDataType.DOUBLE, "double");
public static final SQLiteDataType<Double> DOUBLEPRECISION = new SQLiteDataType<Double>(SQLDataType.DOUBLE, "double precision");
public static final SQLiteDataType<Float> REAL = new SQLiteDataType<Float>(SQLDataType.REAL, "real");
public static final SQLiteDataType<Float> FLOAT = new SQLiteDataType<Float>(SQLDataType.REAL, "float");
public static final SQLiteDataType<BigDecimal> NUMERIC = new SQLiteDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final SQLiteDataType<BigDecimal> DECIMAL = new SQLiteDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final SQLiteDataType<String> LONGVARCHAR = new SQLiteDataType<String>(SQLDataType.LONGVARCHAR, "longvarchar");
public static final SQLiteDataType<String> CHAR = new SQLiteDataType<String>(SQLDataType.CHAR, "char");
public static final SQLiteDataType<String> CHARACTER = new SQLiteDataType<String>(SQLDataType.CHAR, "character");
public static final SQLiteDataType<String> VARCHAR = new SQLiteDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final SQLiteDataType<String> VARYINGCHARACTER = new SQLiteDataType<String>(SQLDataType.VARCHAR, "varying character");
public static final SQLiteDataType<String> NCHAR = new SQLiteDataType<String>(SQLDataType.NCHAR, "nchar");
public static final SQLiteDataType<String> NATIVECHARACTER = new SQLiteDataType<String>(SQLDataType.NCHAR, "native character");
public static final SQLiteDataType<String> NVARCHAR = new SQLiteDataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final SQLiteDataType<String> CLOB = new SQLiteDataType<String>(SQLDataType.CLOB, "clob");
public static final SQLiteDataType<String> TEXT = new SQLiteDataType<String>(SQLDataType.CLOB, "text");
public static final SQLiteDataType<Boolean> BOOLEAN = new SQLiteDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
public static final SQLiteDataType<Date> DATE = new SQLiteDataType<Date>(SQLDataType.DATE, "date");
public static final SQLiteDataType<Timestamp> DATETIME = new SQLiteDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final SQLiteDataType<byte[]> LONGVARBINARY = new SQLiteDataType<byte[]>(SQLDataType.LONGVARBINARY, "longvarbinary");
public static final SQLiteDataType<byte[]> BLOB = new SQLiteDataType<byte[]>(SQLDataType.BLOB, "blob");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.SQLITE, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.SQLITE, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> INT2 = new DefaultDataType<Short>(SQLDialect.SQLITE, SQLDataType.SMALLINT, "int2");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.SQLITE, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.SQLITE, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> MEDIUMINT = new DefaultDataType<Integer>(SQLDialect.SQLITE, SQLDataType.INTEGER, "mediumint");
public static final DataType<Long> INT8 = new DefaultDataType<Long>(SQLDialect.SQLITE, SQLDataType.BIGINT, "int8");
public static final DataType<BigInteger> BIGINT = new DefaultDataType<BigInteger>(SQLDialect.SQLITE, SQLDataType.DECIMAL_INTEGER, "bigint");
public static final DataType<BigInteger> UNSIGNEDBIGINT = new DefaultDataType<BigInteger>(SQLDialect.SQLITE, SQLDataType.DECIMAL_INTEGER, "unsigned big int");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.SQLITE, SQLDataType.DOUBLE, "double");
public static final DataType<Double> DOUBLEPRECISION = new DefaultDataType<Double>(SQLDialect.SQLITE, SQLDataType.DOUBLE, "double precision");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.SQLITE, SQLDataType.REAL, "real");
public static final DataType<Float> FLOAT = new DefaultDataType<Float>(SQLDialect.SQLITE, SQLDataType.REAL, "float");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.SQLITE, SQLDataType.NUMERIC, "numeric");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.SQLITE, SQLDataType.DECIMAL, "decimal");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.LONGVARCHAR, "longvarchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.CHAR, "char");
public static final DataType<String> CHARACTER = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.CHAR, "character");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> VARYINGCHARACTER = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.VARCHAR, "varying character");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NATIVECHARACTER = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.NCHAR, "native character");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> CLOB = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.CLOB, "clob");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.CLOB, "text");
public static final DataType<Boolean> BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.SQLITE, SQLDataType.BOOLEAN, "boolean");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.SQLITE, SQLDataType.DATE, "date");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.SQLITE, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<byte[]> LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.SQLITE, SQLDataType.LONGVARBINARY, "longvarbinary");
public static final DataType<byte[]> BLOB = new DefaultDataType<byte[]>(SQLDialect.SQLITE, SQLDataType.BLOB, "blob");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.SQLITE, SQLDataTypes
// -------------------------------------------------------------------------
protected static final SQLiteDataType<byte[]> __BINARY = new SQLiteDataType<byte[]>(SQLDataType.BINARY, "longvarbinary");
protected static final SQLiteDataType<Boolean> __BIT = new SQLiteDataType<Boolean>(SQLDataType.BIT, "boolean");
protected static final SQLiteDataType<Double> __FLOAT = new SQLiteDataType<Double>(SQLDataType.FLOAT, "double");
protected static final SQLiteDataType<String> __NCLOB = new SQLiteDataType<String>(SQLDataType.NCLOB, "nclob");
protected static final SQLiteDataType<String> __LONGNVARCHAR = new SQLiteDataType<String>(SQLDataType.LONGNVARCHAR, "nvarchar");
protected static final SQLiteDataType<Time> __TIME = new SQLiteDataType<Time>(SQLDataType.TIME, "datetime");
protected static final SQLiteDataType<byte[]> __VARBINARY = new SQLiteDataType<byte[]>(SQLDataType.VARBINARY, "longvarbinary");
protected static final DataType<byte[]> __BINARY = new DefaultDataType<byte[]>(SQLDialect.SQLITE, SQLDataType.BINARY, "longvarbinary");
protected static final DataType<Boolean> __BIT = new DefaultDataType<Boolean>(SQLDialect.SQLITE, SQLDataType.BIT, "boolean");
protected static final DataType<Double> __FLOAT = new DefaultDataType<Double>(SQLDialect.SQLITE, SQLDataType.FLOAT, "double");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.NCLOB, "nclob");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.SQLITE, SQLDataType.LONGNVARCHAR, "nvarchar");
protected static final DataType<Time> __TIME = new DefaultDataType<Time>(SQLDialect.SQLITE, SQLDataType.TIME, "datetime");
protected static final DataType<byte[]> __VARBINARY = new DefaultDataType<byte[]>(SQLDialect.SQLITE, SQLDataType.VARBINARY, "longvarbinary");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
@ -113,10 +109,10 @@ public class SQLiteDataType<T> extends AbstractDataType<T> {
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SQLiteDataType<Object> NULL = new SQLiteDataType<Object>(SQLDataType.OTHER, "null");
public static final DataType<Object> NULL = new DefaultDataType<Object>(SQLDialect.SQLITE, SQLDataType.OTHER, "null");
private SQLiteDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.SQLITE, sqlDataType, sqlDataType.getType(), typeName);
@Deprecated
public static DataType<Object> getDefaultDataType(String string) {
return DefaultDataType.getDefaultDataType(string);
}
}

95
jOOQ/src/main/java/org/jooq/util/sqlserver/SQLServerDataType.java
View File

@ -41,8 +41,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -51,75 +52,67 @@ import org.jooq.impl.SQLDataType;
* @author Lukas Eder
* @see <a href="http://msdn.microsoft.com/en-us/library/aa258271%28v=sql.80%29.aspx">http://msdn.microsoft.com/en-us/library/aa258271%28v=sql.80%29.aspx</a>
*/
public class SQLServerDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -5677365115109672781L;
public class SQLServerDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SQLServerDataType<Byte> TINYINT = new SQLServerDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final SQLServerDataType<Short> SMALLINT = new SQLServerDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final SQLServerDataType<Integer> INT = new SQLServerDataType<Integer>(SQLDataType.INTEGER, "int");
public static final SQLServerDataType<Long> BIGINT = new SQLServerDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final SQLServerDataType<Double> FLOAT = new SQLServerDataType<Double>(SQLDataType.FLOAT, "float");
public static final SQLServerDataType<Float> REAL = new SQLServerDataType<Float>(SQLDataType.REAL, "real");
public static final SQLServerDataType<BigDecimal> NUMERIC = new SQLServerDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final SQLServerDataType<BigDecimal> DECIMAL = new SQLServerDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final SQLServerDataType<Boolean> BIT = new SQLServerDataType<Boolean>(SQLDataType.BIT, "bit");
public static final SQLServerDataType<Date> DATE = new SQLServerDataType<Date>(SQLDataType.DATE, "date");
public static final SQLServerDataType<Timestamp> DATETIME = new SQLServerDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final SQLServerDataType<Time> TIME = new SQLServerDataType<Time>(SQLDataType.TIME, "time");
public static final SQLServerDataType<String> VARCHAR = new SQLServerDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final SQLServerDataType<String> CHAR = new SQLServerDataType<String>(SQLDataType.CHAR, "char");
public static final SQLServerDataType<String> TEXT = new SQLServerDataType<String>(SQLDataType.CLOB, "text");
public static final SQLServerDataType<String> NVARCHAR = new SQLServerDataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final SQLServerDataType<String> NCHAR = new SQLServerDataType<String>(SQLDataType.NCHAR, "nchar");
public static final SQLServerDataType<String> NTEXT = new SQLServerDataType<String>(SQLDataType.NCLOB, "ntext");
public static final SQLServerDataType<byte[]> VARBINARY = new SQLServerDataType<byte[]>(SQLDataType.VARBINARY, "varbinary", "varbinary(max)");
public static final SQLServerDataType<byte[]> BINARY = new SQLServerDataType<byte[]>(SQLDataType.BINARY, "binary");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.SQLSERVER, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.SQLSERVER, SQLDataType.SMALLINT, "smallint");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.SQLSERVER, SQLDataType.INTEGER, "int");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.SQLSERVER, SQLDataType.BIGINT, "bigint");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.SQLSERVER, SQLDataType.FLOAT, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.SQLSERVER, SQLDataType.REAL, "real");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.SQLSERVER, SQLDataType.NUMERIC, "numeric");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.SQLSERVER, SQLDataType.DECIMAL, "decimal");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.SQLSERVER, SQLDataType.BIT, "bit");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.SQLSERVER, SQLDataType.DATE, "date");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.SQLSERVER, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.SQLSERVER, SQLDataType.TIME, "time");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.CHAR, "char");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.CLOB, "text");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NTEXT = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.NCLOB, "ntext");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.SQLSERVER, SQLDataType.VARBINARY, "varbinary", "varbinary(max)");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.SQLSERVER, SQLDataType.BINARY, "binary");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.SQLSERVER, SQLDataTypes
// -------------------------------------------------------------------------
protected static final SQLServerDataType<byte[]> __BLOB = new SQLServerDataType<byte[]>(SQLDataType.BLOB, "binary");
protected static final SQLServerDataType<Boolean> __BOOLEAN = new SQLServerDataType<Boolean>(SQLDataType.BOOLEAN, "bit");
protected static final SQLServerDataType<Double> __DOUBLE = new SQLServerDataType<Double>(SQLDataType.DOUBLE, "float");
protected static final SQLServerDataType<byte[]> __LONGVARBINARY = new SQLServerDataType<byte[]>(SQLDataType.LONGVARBINARY, "varbinary", "varbinary(max)");
protected static final SQLServerDataType<String> __LONGVARCHAR = new SQLServerDataType<String>(SQLDataType.LONGVARCHAR, "varchar");
protected static final SQLServerDataType<String> __NCLOB = new SQLServerDataType<String>(SQLDataType.NCLOB, "text");
protected static final SQLServerDataType<String> __LONGNVARCHAR = new SQLServerDataType<String>(SQLDataType.LONGNVARCHAR, "varchar");
protected static final DataType<byte[]> __BLOB = new DefaultDataType<byte[]>(SQLDialect.SQLSERVER, SQLDataType.BLOB, "binary");
protected static final DataType<Boolean> __BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.SQLSERVER, SQLDataType.BOOLEAN, "bit");
protected static final DataType<Double> __DOUBLE = new DefaultDataType<Double>(SQLDialect.SQLSERVER, SQLDataType.DOUBLE, "float");
protected static final DataType<byte[]> __LONGVARBINARY = new DefaultDataType<byte[]>(SQLDialect.SQLSERVER, SQLDataType.LONGVARBINARY, "varbinary", "varbinary(max)");
protected static final DataType<String> __LONGVARCHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.LONGVARCHAR, "varchar");
protected static final DataType<String> __NCLOB = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.NCLOB, "text");
protected static final DataType<String> __LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.LONGNVARCHAR, "varchar");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final SQLServerDataType<BigInteger> __BIGINTEGER = new SQLServerDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "numeric");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.SQLSERVER, SQLDataType.DECIMAL_INTEGER, "numeric");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SQLServerDataType<Timestamp> SMALLDATETIME = new SQLServerDataType<Timestamp>(SQLDataType.TIMESTAMP, "smalldatetime");
public static final SQLServerDataType<Timestamp> DATETIME2 = new SQLServerDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime2");
public static final SQLServerDataType<Timestamp> DATETIMEOFFSET = new SQLServerDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetimeoffset");
public static final SQLServerDataType<BigDecimal> MONEY = new SQLServerDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
public static final SQLServerDataType<BigDecimal> SMALLMONEY = new SQLServerDataType<BigDecimal>(SQLDataType.DECIMAL, "smallmoney");
public static final SQLServerDataType<byte[]> IMAGE = new SQLServerDataType<byte[]>(SQLDataType.BINARY, "image");
public static final SQLServerDataType<String> UNIQUEIDENTIFIER = new SQLServerDataType<String>(SQLDataType.VARCHAR, "uniqueidentifier");
public static final SQLServerDataType<Long> ROWVERSION = new SQLServerDataType<Long>(SQLDataType.BIGINT, "rowversion");
public static final SQLServerDataType<Long> TIMESTAMP = new SQLServerDataType<Long>(SQLDataType.BIGINT, "timestamp");
public static final DataType<Timestamp> SMALLDATETIME = new DefaultDataType<Timestamp>(SQLDialect.SQLSERVER, SQLDataType.TIMESTAMP, "smalldatetime");
public static final DataType<Timestamp> DATETIME2 = new DefaultDataType<Timestamp>(SQLDialect.SQLSERVER, SQLDataType.TIMESTAMP, "datetime2");
public static final DataType<Timestamp> DATETIMEOFFSET = new DefaultDataType<Timestamp>(SQLDialect.SQLSERVER, SQLDataType.TIMESTAMP, "datetimeoffset");
public static final DataType<BigDecimal> MONEY = new DefaultDataType<BigDecimal>(SQLDialect.SQLSERVER, SQLDataType.DECIMAL, "money");
public static final DataType<BigDecimal> SMALLMONEY = new DefaultDataType<BigDecimal>(SQLDialect.SQLSERVER, SQLDataType.DECIMAL, "smallmoney");
public static final DataType<byte[]> IMAGE = new DefaultDataType<byte[]>(SQLDialect.SQLSERVER, SQLDataType.BINARY, "image");
public static final DataType<String> UNIQUEIDENTIFIER = new DefaultDataType<String>(SQLDialect.SQLSERVER, SQLDataType.VARCHAR, "uniqueidentifier");
public static final DataType<Long> ROWVERSION = new DefaultDataType<Long>(SQLDialect.SQLSERVER, SQLDataType.BIGINT, "rowversion");
public static final DataType<Long> TIMESTAMP = new DefaultDataType<Long>(SQLDialect.SQLSERVER, SQLDataType.BIGINT, "timestamp");
private SQLServerDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.SQLSERVER, sqlDataType, sqlDataType.getType(), typeName);
}
private SQLServerDataType(SQLDataType<T> sqlDataType, String typeName, String castTypeName) {
super(SQLDialect.SQLSERVER, sqlDataType, sqlDataType.getType(), typeName, castTypeName);
@Deprecated
public static DataType<Object> getDefaultDataType(String string) {
return DefaultDataType.getDefaultDataType(string);
}
}

102
jOOQ/src/main/java/org/jooq/util/sybase/SybaseDataType.java
View File

@ -36,8 +36,9 @@ import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
import org.jooq.impl.SQLDataType;
/**
@ -46,78 +47,69 @@ import org.jooq.impl.SQLDataType;
* @see <a href="http://infocenter.sybase.com/help/topic/com.sybase.help.sqlanywhere.12.0.0/dbreference/rf-datatypes.html">http://infocenter.sybase.com/help/topic/com.sybase.help.sqlanywhere.12.0.0/dbreference/rf-datatypes.html</a>
* @author Espen Stromsnes
*/
public class SybaseDataType<T> extends AbstractDataType<T> {
/**
* Generated UID
*/
private static final long serialVersionUID = -4442303192680774346L;
public class SybaseDataType<T> {
// -------------------------------------------------------------------------
// Default SQL data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SybaseDataType<Byte> TINYINT = new SybaseDataType<Byte>(SQLDataType.TINYINT, "tinyint");
public static final SybaseDataType<Short> SMALLINT = new SybaseDataType<Short>(SQLDataType.SMALLINT, "smallint");
public static final SybaseDataType<Short> UNSIGNEDSMALLLINT = new SybaseDataType<Short>(SQLDataType.SMALLINT, "unsignedsmallint");
public static final SybaseDataType<Integer> INT = new SybaseDataType<Integer>(SQLDataType.INTEGER, "int");
public static final SybaseDataType<Integer> INTEGER = new SybaseDataType<Integer>(SQLDataType.INTEGER, "integer");
public static final SybaseDataType<Integer> UNSIGNEDINT = new SybaseDataType<Integer>(SQLDataType.INTEGER, "unsignedint");
public static final SybaseDataType<Long> BIGINT = new SybaseDataType<Long>(SQLDataType.BIGINT, "bigint");
public static final SybaseDataType<Long> UNSIGNEDBIGINT = new SybaseDataType<Long>(SQLDataType.BIGINT, "unsignedbigint");
public static final SybaseDataType<Double> DOUBLE = new SybaseDataType<Double>(SQLDataType.DOUBLE, "double");
public static final SybaseDataType<Double> FLOAT = new SybaseDataType<Double>(SQLDataType.FLOAT, "float");
public static final SybaseDataType<Float> REAL = new SybaseDataType<Float>(SQLDataType.REAL, "real");
public static final SybaseDataType<BigDecimal> DECIMAL = new SybaseDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
public static final SybaseDataType<BigDecimal> NUMERIC = new SybaseDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
public static final SybaseDataType<Boolean> BIT = new SybaseDataType<Boolean>(SQLDataType.BIT, "bit");
public static final SybaseDataType<String> VARCHAR = new SybaseDataType<String>(SQLDataType.VARCHAR, "varchar");
public static final SybaseDataType<String> CHAR = new SybaseDataType<String>(SQLDataType.CHAR, "char");
public static final SybaseDataType<String> LONGNVARCHAR = new SybaseDataType<String>(SQLDataType.LONGNVARCHAR, "long nvarchar");
public static final SybaseDataType<String> LONGVARCHAR = new SybaseDataType<String>(SQLDataType.LONGVARCHAR, "long varchar");
public static final SybaseDataType<String> NCHAR = new SybaseDataType<String>(SQLDataType.NCHAR, "nchar");
public static final SybaseDataType<String> NTEXT = new SybaseDataType<String>(SQLDataType.NCLOB, "ntext");
public static final SybaseDataType<String> NVARCHAR = new SybaseDataType<String>(SQLDataType.NVARCHAR, "nvarchar");
public static final SybaseDataType<String> TEXT = new SybaseDataType<String>(SQLDataType.CLOB, "text");
public static final SybaseDataType<Date> DATE = new SybaseDataType<Date>(SQLDataType.DATE, "date");
public static final SybaseDataType<Time> TIME = new SybaseDataType<Time>(SQLDataType.TIME, "time");
public static final SybaseDataType<Timestamp> DATETIME = new SybaseDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetime");
public static final SybaseDataType<Timestamp> TIMESTAMP = new SybaseDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
public static final SybaseDataType<byte[]> BINARY = new SybaseDataType<byte[]>(SQLDataType.BINARY, "binary");
public static final SybaseDataType<byte[]> LONGBINARY = new SybaseDataType<byte[]>(SQLDataType.LONGVARBINARY, "long binary");
public static final SybaseDataType<byte[]> VARBINARY = new SybaseDataType<byte[]>(SQLDataType.VARBINARY, "varbinary");
public static final DataType<Byte> TINYINT = new DefaultDataType<Byte>(SQLDialect.SYBASE, SQLDataType.TINYINT, "tinyint");
public static final DataType<Short> SMALLINT = new DefaultDataType<Short>(SQLDialect.SYBASE, SQLDataType.SMALLINT, "smallint");
public static final DataType<Short> UNSIGNEDSMALLLINT = new DefaultDataType<Short>(SQLDialect.SYBASE, SQLDataType.SMALLINT, "unsignedsmallint");
public static final DataType<Integer> INT = new DefaultDataType<Integer>(SQLDialect.SYBASE, SQLDataType.INTEGER, "int");
public static final DataType<Integer> INTEGER = new DefaultDataType<Integer>(SQLDialect.SYBASE, SQLDataType.INTEGER, "integer");
public static final DataType<Integer> UNSIGNEDINT = new DefaultDataType<Integer>(SQLDialect.SYBASE, SQLDataType.INTEGER, "unsignedint");
public static final DataType<Long> BIGINT = new DefaultDataType<Long>(SQLDialect.SYBASE, SQLDataType.BIGINT, "bigint");
public static final DataType<Long> UNSIGNEDBIGINT = new DefaultDataType<Long>(SQLDialect.SYBASE, SQLDataType.BIGINT, "unsignedbigint");
public static final DataType<Double> DOUBLE = new DefaultDataType<Double>(SQLDialect.SYBASE, SQLDataType.DOUBLE, "double");
public static final DataType<Double> FLOAT = new DefaultDataType<Double>(SQLDialect.SYBASE, SQLDataType.FLOAT, "float");
public static final DataType<Float> REAL = new DefaultDataType<Float>(SQLDialect.SYBASE, SQLDataType.REAL, "real");
public static final DataType<BigDecimal> DECIMAL = new DefaultDataType<BigDecimal>(SQLDialect.SYBASE, SQLDataType.DECIMAL, "decimal");
public static final DataType<BigDecimal> NUMERIC = new DefaultDataType<BigDecimal>(SQLDialect.SYBASE, SQLDataType.NUMERIC, "numeric");
public static final DataType<Boolean> BIT = new DefaultDataType<Boolean>(SQLDialect.SYBASE, SQLDataType.BIT, "bit");
public static final DataType<String> VARCHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.VARCHAR, "varchar");
public static final DataType<String> CHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.CHAR, "char");
public static final DataType<String> LONGNVARCHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.LONGNVARCHAR, "long nvarchar");
public static final DataType<String> LONGVARCHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.LONGVARCHAR, "long varchar");
public static final DataType<String> NCHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.NCHAR, "nchar");
public static final DataType<String> NTEXT = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.NCLOB, "ntext");
public static final DataType<String> NVARCHAR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.NVARCHAR, "nvarchar");
public static final DataType<String> TEXT = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.CLOB, "text");
public static final DataType<Date> DATE = new DefaultDataType<Date>(SQLDialect.SYBASE, SQLDataType.DATE, "date");
public static final DataType<Time> TIME = new DefaultDataType<Time>(SQLDialect.SYBASE, SQLDataType.TIME, "time");
public static final DataType<Timestamp> DATETIME = new DefaultDataType<Timestamp>(SQLDialect.SYBASE, SQLDataType.TIMESTAMP, "datetime");
public static final DataType<Timestamp> TIMESTAMP = new DefaultDataType<Timestamp>(SQLDialect.SYBASE, SQLDataType.TIMESTAMP, "timestamp");
public static final DataType<byte[]> BINARY = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.BINARY, "binary");
public static final DataType<byte[]> LONGBINARY = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.LONGVARBINARY, "long binary");
public static final DataType<byte[]> VARBINARY = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.VARBINARY, "varbinary");
// -------------------------------------------------------------------------
// Compatibility types for supported SQLDataTypes
// Compatibility types for supported SQLDialect.SYBASE, SQLDataTypes
// -------------------------------------------------------------------------
protected static final SybaseDataType<byte[]> __BLOB = new SybaseDataType<byte[]>(SQLDataType.BLOB, "binary");
protected static final SybaseDataType<Boolean> __BOOLEAN = new SybaseDataType<Boolean>(SQLDataType.BOOLEAN, "bit");
protected static final DataType<byte[]> __BLOB = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.BLOB, "binary");
protected static final DataType<Boolean> __BOOLEAN = new DefaultDataType<Boolean>(SQLDialect.SYBASE, SQLDataType.BOOLEAN, "bit");
// -------------------------------------------------------------------------
// Compatibility types for supported Java types
// -------------------------------------------------------------------------
protected static final SybaseDataType<BigInteger> __BIGINTEGER = new SybaseDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
protected static final DataType<BigInteger> __BIGINTEGER = new DefaultDataType<BigInteger>(SQLDialect.SYBASE, SQLDataType.DECIMAL_INTEGER, "decimal");
// -------------------------------------------------------------------------
// Dialect-specific data types and synonyms thereof
// -------------------------------------------------------------------------
public static final SybaseDataType<BigDecimal> MONEY = new SybaseDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
public static final SybaseDataType<BigDecimal> SMALLMONEY = new SybaseDataType<BigDecimal>(SQLDataType.DECIMAL, "smallmoney");
public static final SybaseDataType<String> UNIQUEIDENTIFIERSTR = new SybaseDataType<String>(SQLDataType.VARCHAR, "uniqueidentifierstr");
public static final SybaseDataType<String> XML = new SybaseDataType<String>(SQLDataType.VARCHAR, "xml");
public static final SybaseDataType<String> UNIQUEIDENTIFIER = new SybaseDataType<String>(SQLDataType.VARCHAR, "uniqueidentifier");
public static final SybaseDataType<Timestamp> DATETIMEOFFSET = new SybaseDataType<Timestamp>(SQLDataType.TIMESTAMP, "datetimeoffset");
public static final SybaseDataType<Timestamp> SMALLDATETIME = new SybaseDataType<Timestamp>(SQLDataType.TIMESTAMP, "smalldatetime");
public static final SybaseDataType<Timestamp> TIMESTAMPWITHTIMEZONE = new SybaseDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestampwithtimezone");
public static final SybaseDataType<byte[]> IMAGE = new SybaseDataType<byte[]>(SQLDataType.BINARY, "image");
public static final SybaseDataType<byte[]> VARBIT = new SybaseDataType<byte[]>(SQLDataType.VARBINARY, "varbit");
public static final SybaseDataType<byte[]> LONGVARBIT = new SybaseDataType<byte[]>(SQLDataType.LONGVARBINARY, "longvarbit");
public static final DataType<BigDecimal> MONEY = new DefaultDataType<BigDecimal>(SQLDialect.SYBASE, SQLDataType.DECIMAL, "money");
public static final DataType<BigDecimal> SMALLMONEY = new DefaultDataType<BigDecimal>(SQLDialect.SYBASE, SQLDataType.DECIMAL, "smallmoney");
public static final DataType<String> UNIQUEIDENTIFIERSTR = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.VARCHAR, "uniqueidentifierstr");
public static final DataType<String> XML = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.VARCHAR, "xml");
public static final DataType<String> UNIQUEIDENTIFIER = new DefaultDataType<String>(SQLDialect.SYBASE, SQLDataType.VARCHAR, "uniqueidentifier");
public static final DataType<Timestamp> DATETIMEOFFSET = new DefaultDataType<Timestamp>(SQLDialect.SYBASE, SQLDataType.TIMESTAMP, "datetimeoffset");
public static final DataType<Timestamp> SMALLDATETIME = new DefaultDataType<Timestamp>(SQLDialect.SYBASE, SQLDataType.TIMESTAMP, "smalldatetime");
public static final DataType<Timestamp> TIMESTAMPWITHTIMEZONE = new DefaultDataType<Timestamp>(SQLDialect.SYBASE, SQLDataType.TIMESTAMP, "timestampwithtimezone");
public static final DataType<byte[]> IMAGE = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.BINARY, "image");
public static final DataType<byte[]> VARBIT = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.VARBINARY, "varbit");
public static final DataType<byte[]> LONGVARBIT = new DefaultDataType<byte[]>(SQLDialect.SYBASE, SQLDataType.LONGVARBINARY, "longvarbit");
private SybaseDataType(SQLDataType<T> sqlDataType, String typeName) {
super(SQLDialect.SYBASE, sqlDataType, sqlDataType.getType(), typeName);
}
}

4
jOOQ/src/test/java/org/jooq/test/TestDataType.java
View File

@ -39,12 +39,12 @@ import java.sql.Date;
import org.jooq.DataType;
import org.jooq.SQLDialect;
import org.jooq.impl.AbstractDataType;
import org.jooq.impl.DefaultDataType;
/**
* @author Lukas Eder
*/
public final class TestDataType<T> extends AbstractDataType<T> {
public final class TestDataType<T> extends DefaultDataType<T> {
/**
* Generated UID