org.jooq/jooq/3.14.7 : org/jooq/DataType.java

DataType
http://www.jooq.org/jooq: jOOQ effectively combines complex SQL, typesafety, source code generation, active records, stored procedures, advanced data types, and Java in a fluent, intuitive DSL.
Apache License, Version 2.0
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Other licenses:
 * -----------------------------------------------------------------------------
 * Commercial licenses for this work are available. These replace the above
 * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
 * database integrations.
 *
 * For more information, please visit: http://www.jooq.org/licenses
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package org.jooq;

// ...
// ...
// ...
import static org.jooq.SQLDialect.HSQLDB;
import static org.jooq.SQLDialect.MARIADB;
// ...
import static org.jooq.SQLDialect.MYSQL;
// ...
import static org.jooq.SQLDialect.POSTGRES;
// ...
import static org.jooq.SQLDialect.SQLITE;
// ...

import java.sql.Types;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;

import org.jooq.exception.DataTypeException;
import org.jooq.impl.SQLDataType;
import org.jooq.tools.Convert;
import org.jooq.types.DayToSecond;
import org.jooq.types.YearToMonth;
import org.jooq.types.YearToSecond;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

A common interface to all dialect-specific data types.
 jOOQ provides built in data types through SQLDataType. Users can define their own data types programmatically by calling asConvertedDataType(Converter) or asConvertedDataType(Binding), for example. Custom data types can also be defined on generated code using the <forcedType/>
configuration, see the manual for more details
Author: Lukas Eder
Type parameters: <T> – The Java type associated with this SQL data type/**
 * A common interface to all dialect-specific data types.
 * <p>
 * jOOQ provides built in data types through {@link SQLDataType}. Users can
 * define their own data types programmatically by calling
 * {@link #asConvertedDataType(Converter)} or
 * {@link #asConvertedDataType(Binding)}, for example. Custom data types can
 * also be defined on generated code using the <code>&lt;forcedType/&gt;</code>
 * configuration, see <a href=
 * "https://www.jooq.org/doc/latest/manual/code-generation/codegen-advanced/codegen-config-database/codegen-database-forced-types/">the manual for more details</a>
 *
 * @param <T> The Java type associated with this SQL data type
 * @author Lukas Eder
 */
public interface DataType<T> extends Named {

    Get the standard SQL data type of this (dialect-specific) data type if
available.
/**
     * Get the standard SQL data type of this (dialect-specific) data type if
     * available.
     */
    @Nullable
    DataType<T> getSQLDataType();

    The dialect-specific data type representing this data type.
/**
     * The dialect-specific data type representing this data type.
     */
    @NotNull
    DataType<T> getDataType(Configuration configuration);

    Get JDBC Types value. /**
     * Get JDBC {@link Types} value.
     */
    int getSQLType();

    Get the dialect-specific JDBC Types value. /**
     * Get the dialect-specific JDBC {@link Types} value.
     */
    int getSQLType(Configuration configuration);

    Get the data type binding associated with this data type.
/**
     * Get the data type binding associated with this data type.
     */
    @NotNull
    Binding<?, T> getBinding();

    Get the converter associated with this data type.
/**
     * Get the converter associated with this data type.
     */
    @NotNull
    Converter<?, T> getConverter();

    Retrieve the Java type associated with this data type.
/**
     * Retrieve the Java type associated with this data type.
     */
    @NotNull
    Class<T> getType();

    Get the defining DOMAIN type or NULL if there is no such
type.
/**
     * Get the defining DOMAIN type or <code>NULL</code> if there is no such
     * type.
     */
    @Nullable
    Domain<T> getDomain();

    Retrieve the Java type associated with ARRAYs of this data type.
/**
     * Retrieve the Java type associated with ARRAYs of this data type.
     */
    @NotNull
    Class<T[]> getArrayType();

    Retrieve the data type for an ARRAY of this data type.
/**
     * Retrieve the data type for an ARRAY of this data type.
     */
    @NotNull
    DataType<T[]> getArrayDataType();

    Retrieve the Java component type if this is an ARRAY type, or
null, otherwise.
/**
     * Retrieve the Java component type if this is an ARRAY type, or
     * <code>null</code>, otherwise.
     */
    @Nullable
    Class<?> getArrayComponentType();

    Retrieve the Java component data type if this is an ARRAY type, or
null, otherwise.
/**
     * Retrieve the Java component data type if this is an ARRAY type, or
     * <code>null</code>, otherwise.
     */
    @Nullable
    DataType<?> getArrayComponentDataType();










    Retrieve the data type for a given enum data type.
/**
     * Retrieve the data type for a given enum data type.
     */
    @NotNull
    <E extends EnumType> DataType<E> asEnumDataType(Class<E> enumDataType);

    Retrieve the data type for a given converter.
/**
     * Retrieve the data type for a given converter.
     */
    @NotNull
    <U> DataType<U> asConvertedDataType(Converter<? super T, U> converter);



    Convenience method for converting this type using Converter.of(Class<Object>, Class<Object>, Function<? super Object,? extends Object>, Function<? super Object,? extends Object>). /**
     * Convenience method for converting this type using
     * {@link Converter#of(Class, Class, Function, Function)}.
     */
    @NotNull
    default <U> DataType<U> asConvertedDataType(
        Class<U> toType,
        Function<? super T, ? extends U> from,
        Function<? super U, ? extends T> to
    ) {
        return asConvertedDataType(Converter.of(getType(), toType, from, to));
    }



    Retrieve the data type for a given binding.
/**
     * Retrieve the data type for a given binding.
     */
    @NotNull
    <U> DataType<U> asConvertedDataType(Binding<? super T, U> binding);

    Retrieve the dialect-specific type name associated with this data type.
/**
     * Retrieve the dialect-specific type name associated with this data type.
     */
    @NotNull
    String getTypeName();

    Retrieve the dialect-specific type name associated with this data type.
/**
     * Retrieve the dialect-specific type name associated with this data type.
     */
    @NotNull
    String getTypeName(Configuration configuration);

    Retrieve the dialect-specific type name associated with this data type
used for casting.

This is useful for some dialects that have specialised type names for
cast expressions. Other dialects require type-length binding when
casting, (e.g. VARCHAR(32767))
/**
     * Retrieve the dialect-specific type name associated with this data type
     * used for casting.
     * <p>
     * This is useful for some dialects that have specialised type names for
     * cast expressions. Other dialects require type-length binding when
     * casting, (e.g. VARCHAR(32767))
     */
    @NotNull
    String getCastTypeName();

    Retrieve the dialect-specific type name associated with this data type
used for casting.

This is useful for some dialects that have specialised type names for
cast expressions. Other dialects require type-length binding when
casting, (e.g. VARCHAR(32767))
/**
     * Retrieve the dialect-specific type name associated with this data type
     * used for casting.
     * <p>
     * This is useful for some dialects that have specialised type names for
     * cast expressions. Other dialects require type-length binding when
     * casting, (e.g. VARCHAR(32767))
     */
    @NotNull
    String getCastTypeName(Configuration configuration);

    Retrieve the underlying SQLDialect. /**
     * Retrieve the underlying {@link SQLDialect}.
     */
    @Nullable
    SQLDialect getDialect();

    Convert an arbitrary object into <T>.
 See Convert.convert(Object, Class<? extends Object>) for details about conversion rules. Notice this does not pass through any Configuration.converterProvider(). 
Params: object – The object to be converted
Throws: DataTypeException – If conversion fails.
Returns: The converted object/**
     * Convert an arbitrary object into <code>&lt;T&gt;</code>.
     * <p>
     * See {@link Convert#convert(Object, Class)} for details about conversion
     * rules. Notice this does not pass through any
     * {@link Configuration#converterProvider()}.
     *
     * @param object The object to be converted
     * @return The converted object
     * @throws DataTypeException If conversion fails.
     */
    T convert(Object object);

    Convert an arbitrary set of objects into <T>.
 See Convert.convert(Object, Class<? extends Object>) for details about conversion rules. Notice this does not pass through any Configuration.converterProvider(). 
Params: objects – The objects to be converted
Throws: DataTypeException – If conversion fails.
Returns: The converted objects/**
     * Convert an arbitrary set of objects into <code>&lt;T&gt;</code>.
     * <p>
     * See {@link Convert#convert(Object, Class)} for details about conversion
     * rules. Notice this does not pass through any
     * {@link Configuration#converterProvider()}.
     *
     * @param objects The objects to be converted
     * @return The converted objects
     * @throws DataTypeException If conversion fails.
     */
    @NotNull
    T[] convert(Object... objects);

    Convert an arbitrary set of objects into <T>.
 See Convert.convert(Object, Class<? extends Object>) for details about conversion rules. Notice this does not pass through any Configuration.converterProvider(). 
Params: objects – The objects to be converted
Throws: DataTypeException – If conversion fails.
Returns: The converted objects/**
     * Convert an arbitrary set of objects into <code>&lt;T&gt;</code>.
     * <p>
     * See {@link Convert#convert(Object, Class)} for details about conversion
     * rules. Notice this does not pass through any
     * {@link Configuration#converterProvider()}.
     *
     * @param objects The objects to be converted
     * @return The converted objects
     * @throws DataTypeException If conversion fails.
     */
    @NotNull
    List<T> convert(Collection<?> objects);

    Return a new data type like this, with a new nullability.

[#5709] A nullable column cannot have an identity(). 
Params: nullability – The new nullability
Returns: The new data type/**
     * Return a new data type like this, with a new nullability.
     * <p>
     * [#5709] A <code>nullable</code> column cannot have an {@link #identity()}.
     *
     * @param nullability The new nullability
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> nullability(Nullability nullability);

    Get the nullability of this data type.
Returns: The nullability/**
     * Get the nullability of this data type.
     *
     * @return The nullability
     */
    @NotNull
    Nullability nullability();

    Return a new data type like this, with a new nullability.
 This is the same as calling nullability(Nullability) with any of Nullability.NULL or Nullability.NOT_NULL as an argument. 

[#5709] A nullable column cannot have an identity(). 
Params: nullable – The new nullability
Returns: The new data type/**
     * Return a new data type like this, with a new nullability.
     * <p>
     * This is the same as calling {@link #nullability(Nullability)} with any of
     * {@link Nullability#NULL} or {@link Nullability#NOT_NULL} as an argument.
     * <p>
     * [#5709] A <code>nullable</code> column cannot have an
     * {@link #identity()}.
     *
     * @param nullable The new nullability
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> nullable(boolean nullable);

    Get the nullability of this data type.

This returns true by default, i.e. if nullability() is Nullability.DEFAULT. 
Returns: The nullability/**
     * Get the nullability of this data type.
     * <p>
     * This returns <code>true</code> by default, i.e. if {@link #nullability()}
     * is {@link Nullability#DEFAULT}.
     *
     * @return The nullability
     */
    boolean nullable();

    Return a new data type like this, with a new collation.
/**
     * Return a new data type like this, with a new collation.
     */
    @NotNull
    @Support({ HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
    DataType<T> collation(Collation collation);

    Get the collation of this data type, or null if there is no
collation, or if the default collation applies.
/**
     * Get the collation of this data type, or <code>null</code> if there is no
     * collation, or if the default collation applies.
     */
    @Nullable
    Collation collation();

    Return a new data type like this, with a new character set.
/**
     * Return a new data type like this, with a new character set.
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    DataType<T> characterSet(CharacterSet characterSet);

    Get the character set of this data type, or null if there is
no character set, or if the default character set applies.
/**
     * Get the character set of this data type, or <code>null</code> if there is
     * no character set, or if the default character set applies.
     */
    @Nullable
    CharacterSet characterSet();

    Return a new data type like this, with a new identity flag.

[#5709] The IDENTITY flag imposes a NOT NULL constraint, and removes all
DEFAULT values.
Params: identity – The new identity flag
Returns: The new data type/**
     * Return a new data type like this, with a new identity flag.
     * <p>
     * [#5709] The IDENTITY flag imposes a NOT NULL constraint, and removes all
     * DEFAULT values.
     *
     * @param identity The new identity flag
     * @return The new data type
     */
    @NotNull
    @Support // TODO: List the correct dialects that support identities
    DataType<T> identity(boolean identity);

    Get the identity flag of this data type.
Returns: The identity flag./**
     * Get the identity flag of this data type.
     *
     * @return The identity flag.
     */
    boolean identity();

    Specify an expression to be applied as the DEFAULT value for
this data type.

[#5709] A defaulted column cannot have an identity(). 
 This is an alias for default_(Object). 
See Also: defaultValue(Field)/**
     * Specify an expression to be applied as the <code>DEFAULT</code> value for
     * this data type.
     * <p>
     * [#5709] A <code>defaulted</code> column cannot have an {@link #identity()}.
     * <p>
     * This is an alias for {@link #default_(Object)}.
     *
     * @see #defaultValue(Field)
     */
    @NotNull
    @Support
    DataType<T> defaultValue(T defaultValue);

    Specify an expression to be applied as the DEFAULT value for
this data type.

A default value of a data type applies to DDL statements, such as

CREATE TABLE
ALTER TABLE


The distinct types of possible DEFAULT expressions is
defined by the underlying database. Please refer to your database manual
to learn what expressions are possible.
 This is an alias for default_(Field). /**
     * Specify an expression to be applied as the <code>DEFAULT</code> value for
     * this data type.
     * <p>
     * A default value of a data type applies to DDL statements, such as
     * <ul>
     * <li><code>CREATE TABLE</code></li>
     * <li><code>ALTER TABLE</code></li>
     * </ul>
     * <p>
     * The distinct types of possible <code>DEFAULT</code> expressions is
     * defined by the underlying database. Please refer to your database manual
     * to learn what expressions are possible.
     * <p>
     * This is an alias for {@link #default_(Field)}.
     */
    @NotNull
    @Support
    DataType<T> defaultValue(Field<T> defaultValue);

    The expression to be applied as the DEFAULT value for this
data type.
 This is an alias for default_(). 
See Also: defaultValue(Field)
Returns: The default value if present, or null if no default
        value is specified for this data type./**
     * The expression to be applied as the <code>DEFAULT</code> value for this
     * data type.
     * <p>
     * This is an alias for {@link #default_()}.
     *
     * @return The default value if present, or <code>null</code> if no default
     *         value is specified for this data type.
     * @see #defaultValue(Field)
     */
    @Nullable
    Field<T> defaultValue();

    Specify an expression to be applied as the DEFAULT value for
this data type.

[#5709] A defaulted column cannot have an identity(). 
See Also: defaultValue(Field)/**
     * Specify an expression to be applied as the <code>DEFAULT</code> value for
     * this data type.
     * <p>
     * [#5709] A <code>defaulted</code> column cannot have an {@link #identity()}.
     *
     * @see #defaultValue(Field)
     */
    @NotNull
    @Support
    DataType<T> default_(T defaultValue);

    Specify an expression to be applied as the DEFAULT value for
this data type.

A default value of a data type applies to DDL statements, such as

CREATE TABLE
ALTER TABLE


The distinct types of possible DEFAULT expressions is
defined by the underlying database. Please refer to your database manual
to learn what expressions are possible.
/**
     * Specify an expression to be applied as the <code>DEFAULT</code> value for
     * this data type.
     * <p>
     * A default value of a data type applies to DDL statements, such as
     * <ul>
     * <li><code>CREATE TABLE</code></li>
     * <li><code>ALTER TABLE</code></li>
     * </ul>
     * <p>
     * The distinct types of possible <code>DEFAULT</code> expressions is
     * defined by the underlying database. Please refer to your database manual
     * to learn what expressions are possible.
     */
    @NotNull
    @Support
    DataType<T> default_(Field<T> defaultValue);

    The expression to be applied as the DEFAULT value for this
data type.
See Also: defaultValue(Field)
Returns: The default value if present, or null if no default
        value is specified for this data type./**
     * The expression to be applied as the <code>DEFAULT</code> value for this
     * data type.
     *
     * @return The default value if present, or <code>null</code> if no default
     *         value is specified for this data type.
     * @see #defaultValue(Field)
     */
    @Nullable
    Field<T> default_();

    Return a new data type like this, with a new defaultability.
Params: defaulted – The new defaultability
Returns: The new data type
Deprecated: - [#3852] - 3.8.0 - Use defaultValue(Field) instead./**
     * Return a new data type like this, with a new defaultability.
     *
     * @param defaulted The new defaultability
     * @return The new data type
     *
     * @deprecated - [#3852] - 3.8.0 - Use {@link #defaultValue(Field)} instead.
     */
    @NotNull
    @Deprecated
    DataType<T> defaulted(boolean defaulted);

    Get the defaultability of this data type.
Returns: The defaultability/**
     * Get the defaultability of this data type.
     *
     * @return The defaultability
     */
    boolean defaulted();

    Return a new data type like this, with a new precision value.
 This will have no effect if hasPrecision() is false
 This is the same as calling precision(int, int) with scale == 0
Params: precision – The new precision value
Returns: The new data type/**
     * Return a new data type like this, with a new precision value.
     * <p>
     * This will have no effect if {@link #hasPrecision()} is <code>false</code>
     * <p>
     * This is the same as calling {@link #precision(int, int)} with
     * <code>scale == 0</code>
     *
     * @param precision The new precision value
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> precision(int precision);

    Return a new data type like this, with a new precision and scale value.
 This will have no effect if hasPrecision() is false
, or if scale > 0 and hasScale() is false
Params: precision – The new precision value
scale – The new scale value
Returns: The new data type/**
     * Return a new data type like this, with a new precision and scale value.
     * <p>
     * This will have no effect if {@link #hasPrecision()} is <code>false</code>
     * , or if <code>scale &gt; 0</code> and {@link #hasScale()} is
     * <code>false</code>
     *
     * @param precision The new precision value
     * @param scale The new scale value
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> precision(int precision, int scale);

    Get the precision of this data type.
Returns: The precision of this data type/**
     * Get the precision of this data type.
     *
     * @return The precision of this data type
     */
    int precision();

    Whether this data type has a precision.
Returns: Whether this data type has a precision/**
     * Whether this data type has a precision.
     *
     * @return Whether this data type has a precision
     */
    boolean hasPrecision();

    Whether the precision returned by precision() is defined. 
The default precision is 0 for all data types. If a data type does not have a precision (see hasPrecision()), or if it was initialised without precision (e.g. SQLDataType.TIMESTAMP), then the precision is not defined. /**
     * Whether the precision returned by {@link #precision()} is defined.
     * <p>
     * The default precision is <code>0</code> for all data types. If a data
     * type does not have a precision (see {@link #hasPrecision()}), or if it
     * was initialised without precision (e.g. {@link SQLDataType#TIMESTAMP}),
     * then the precision is not defined.
     */
    boolean precisionDefined();

    Return a new data type like this, with a new scale value.
 This will have no effect if hasScale() is false
Params: scale – The new scale value
Returns: The new data type/**
     * Return a new data type like this, with a new scale value.
     * <p>
     * This will have no effect if {@link #hasScale()} is <code>false</code>
     *
     * @param scale The new scale value
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> scale(int scale);

    Get the scale of this data type.
Returns: The scale of this data type/**
     * Get the scale of this data type.
     *
     * @return The scale of this data type
     */
    int scale();

    Whether this data type has a scale.
Returns: Whether this data type has a scale/**
     * Whether this data type has a scale.
     *
     * @return Whether this data type has a scale
     */
    boolean hasScale();

    Whether the precision returned by scale() is defined. 
The default scale is 0 for all data types. If a data type does not have a scale (see hasScale()), or if it was initialised without scale (e.g. SQLDataType.TIMESTAMP), then the scale is not defined. /**
     * Whether the precision returned by {@link #scale()} is defined.
     * <p>
     * The default scale is <code>0</code> for all data types. If a data type
     * does not have a scale (see {@link #hasScale()}), or if it was initialised
     * without scale (e.g. {@link SQLDataType#TIMESTAMP}), then the scale is not
     * defined.
     */
    boolean scaleDefined();

    Return a new data type like this, with a new length value.
 This will have no effect if hasLength() is false
Params: length – The new length value
Returns: The new data type/**
     * Return a new data type like this, with a new length value.
     * <p>
     * This will have no effect if {@link #hasLength()} is <code>false</code>
     *
     * @param length The new length value
     * @return The new data type
     */
    @NotNull
    @Support
    DataType<T> length(int length);

    Get the length of this data type.
Returns: The length of this data type/**
     * Get the length of this data type.
     *
     * @return The length of this data type
     */
    int length();

    Whether this data type has a length.
Returns: Whether this data type has a length/**
     * Whether this data type has a length.
     *
     * @return Whether this data type has a length
     */
    boolean hasLength();

    Whether the precision returned by length() is defined. 
The default length is 0 for all data types. If a data type does not have a length (see hasLength()), or if it was initialised without length (e.g. SQLDataType.TIMESTAMP), then the length is not defined. /**
     * Whether the precision returned by {@link #length()} is defined.
     * <p>
     * The default length is <code>0</code> for all data types. If a data type
     * does not have a length (see {@link #hasLength()}), or if it was initialised
     * without length (e.g. {@link SQLDataType#TIMESTAMP}), then the length is not
     * defined.
     */
    boolean lengthDefined();

    Whether this data type is any numeric data type.

This applies to any of these types:

 SQLDataType.TINYINT
 SQLDataType.SMALLINT
 SQLDataType.INTEGER
 SQLDataType.BIGINT
 SQLDataType.FLOAT
 SQLDataType.DOUBLE
 SQLDataType.REAL
 SQLDataType.DECIMAL
 SQLDataType.DECIMAL_INTEGER
 SQLDataType.NUMERIC

See Also: isNumeric()/**
     * Whether this data type is any numeric data type.
     * <p>
     * This applies to any of these types:
     * <ul>
     * <li> {@link SQLDataType#TINYINT}</li>
     * <li> {@link SQLDataType#SMALLINT}</li>
     * <li> {@link SQLDataType#INTEGER}</li>
     * <li> {@link SQLDataType#BIGINT}</li>
     * <li> {@link SQLDataType#FLOAT}</li>
     * <li> {@link SQLDataType#DOUBLE}</li>
     * <li> {@link SQLDataType#REAL}</li>
     * <li> {@link SQLDataType#DECIMAL}</li>
     * <li> {@link SQLDataType#DECIMAL_INTEGER}</li>
     * <li> {@link SQLDataType#NUMERIC}</li>
     * </ul>
     *
     * @see #isNumeric()
     */
    boolean isNumeric();

    Whether this data type is any integer data type.

This applies to any of these types:

 SQLDataType.TINYINT
 SQLDataType.SMALLINT
 SQLDataType.INTEGER
 SQLDataType.BIGINT

/**
     * Whether this data type is any integer data type.
     * <p>
     * This applies to any of these types:
     * <ul>
     * <li> {@link SQLDataType#TINYINT}</li>
     * <li> {@link SQLDataType#SMALLINT}</li>
     * <li> {@link SQLDataType#INTEGER}</li>
     * <li> {@link SQLDataType#BIGINT}</li>
     * </ul>
     */
    boolean isInteger();

    Whether this data type is any character data type.

This applies to any of these types:

 SQLDataType.CHAR
 SQLDataType.CLOB
 SQLDataType.LONGNVARCHAR
 SQLDataType.LONGVARCHAR
 SQLDataType.NCHAR
 SQLDataType.NCLOB
 SQLDataType.NVARCHAR
 SQLDataType.VARCHAR

/**
     * Whether this data type is any character data type.
     * <p>
     * This applies to any of these types:
     * <ul>
     * <li> {@link SQLDataType#CHAR}</li>
     * <li> {@link SQLDataType#CLOB}</li>
     * <li> {@link SQLDataType#LONGNVARCHAR}</li>
     * <li> {@link SQLDataType#LONGVARCHAR}</li>
     * <li> {@link SQLDataType#NCHAR}</li>
     * <li> {@link SQLDataType#NCLOB}</li>
     * <li> {@link SQLDataType#NVARCHAR}</li>
     * <li> {@link SQLDataType#VARCHAR}</li>
     * </ul>
     */
    boolean isString();

    Whether this data type is any national character data type.

This applies to any of these types:

 SQLDataType.LONGNVARCHAR
 SQLDataType.NCHAR
 SQLDataType.NCLOB
 SQLDataType.NVARCHAR

/**
     * Whether this data type is any national character data type.
     * <p>
     * This applies to any of these types:
     * <ul>
     * <li> {@link SQLDataType#LONGNVARCHAR}</li>
     * <li> {@link SQLDataType#NCHAR}</li>
     * <li> {@link SQLDataType#NCLOB}</li>
     * <li> {@link SQLDataType#NVARCHAR}</li>
     * </ul>
     */
    boolean isNString();

    Whether this data type is any date or time type.

This applies to any of these types.

 SQLDataType.DATE
 SQLDataType.TIME
 SQLDataType.TIMESTAMP
 SQLDataType.LOCALDATE
 SQLDataType.LOCALTIME
 SQLDataType.LOCALDATETIME
 SQLDataType.OFFSETTIME
 SQLDataType.OFFSETDATETIME
 SQLDataType.INSTANT

See Also: isDate()/**
     * Whether this data type is any date or time type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li> {@link SQLDataType#DATE}</li>
     * <li> {@link SQLDataType#TIME}</li>
     * <li> {@link SQLDataType#TIMESTAMP}</li>
     * <li> {@link SQLDataType#LOCALDATE}</li>
     * <li> {@link SQLDataType#LOCALTIME}</li>
     * <li> {@link SQLDataType#LOCALDATETIME}</li>
     * <li> {@link SQLDataType#OFFSETTIME}</li>
     * <li> {@link SQLDataType#OFFSETDATETIME}</li>
     * <li> {@link SQLDataType#INSTANT}</li>
     * </ul>
     *
     * @see #isDate()
     */
    boolean isDateTime();

    Whether this data type is any date type.

This applies to any of these types.

SQLDataType.DATE
SQLDataType.LOCALDATE

/**
     * Whether this data type is any date type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li>{@link SQLDataType#DATE}</li>
     * <li>{@link SQLDataType#LOCALDATE}</li>
     * </ul>
     */
    boolean isDate();

    Whether this data type is any timestamp type.

This applies to any of these types.

SQLDataType.TIMESTAMP
SQLDataType.LOCALDATETIME

/**
     * Whether this data type is any timestamp type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li>{@link SQLDataType#TIMESTAMP}</li>
     * <li>{@link SQLDataType#LOCALDATETIME}</li>
     * </ul>
     */
    boolean isTimestamp();

    Whether this data type is any time type.

This applies to any of these types.

SQLDataType.TIME
SQLDataType.LOCALTIME

/**
     * Whether this data type is any time type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li>{@link SQLDataType#TIME}</li>
     * <li>{@link SQLDataType#LOCALTIME}</li>
     * </ul>
     */
    boolean isTime();

    Whether this data type is any date or time type.

This applies to any of these types.

 SQLDataType.DATE
 SQLDataType.TIME
 SQLDataType.TIMESTAMP
 SQLDataType.LOCALDATE
 SQLDataType.LOCALTIME
 SQLDataType.LOCALDATETIME
 SQLDataType.OFFSETTIME
 SQLDataType.OFFSETDATETIME
 YearToSecond
 YearToMonth
 DayToSecond

 This is a combination of isDateTime() or isInterval() /**
     * Whether this data type is any date or time type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li> {@link SQLDataType#DATE}</li>
     * <li> {@link SQLDataType#TIME}</li>
     * <li> {@link SQLDataType#TIMESTAMP}</li>
     * <li> {@link SQLDataType#LOCALDATE}</li>
     * <li> {@link SQLDataType#LOCALTIME}</li>
     * <li> {@link SQLDataType#LOCALDATETIME}</li>
     * <li> {@link SQLDataType#OFFSETTIME}</li>
     * <li> {@link SQLDataType#OFFSETDATETIME}</li>
     * <li> {@link YearToSecond}</li>
     * <li> {@link YearToMonth}</li>
     * <li> {@link DayToSecond}</li>
     * </ul>
     * <p>
     * This is a combination of {@link #isDateTime()} or {@link #isInterval()}
     */
    boolean isTemporal();

    Whether this data type is any interval type.

This applies to any of these types.

 YearToSecond
 YearToMonth
 DayToSecond

/**
     * Whether this data type is any interval type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li> {@link YearToSecond}</li>
     * <li> {@link YearToMonth}</li>
     * <li> {@link DayToSecond}</li>
     * </ul>
     */
    boolean isInterval();

    Whether this data type is any binary type.

This applies to any of these types.

 SQLDataType.BINARY
 SQLDataType.BLOB
 SQLDataType.LONGVARBINARY
 SQLDataType.VARBINARY

/**
     * Whether this data type is any binary type.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li> {@link SQLDataType#BINARY}</li>
     * <li> {@link SQLDataType#BLOB}</li>
     * <li> {@link SQLDataType#LONGVARBINARY}</li>
     * <li> {@link SQLDataType#VARBINARY}</li>
     * </ul>
     */
    boolean isBinary();

    Whether this data type is best deserialised as a LOB.

This applies to any of these types.

 SQLDataType.BLOB
 SQLDataType.CLOB
 SQLDataType.NCLOB

/**
     * Whether this data type is best deserialised as a <code>LOB</code>.
     * <p>
     * This applies to any of these types.
     * <ul>
     * <li> {@link SQLDataType#BLOB}</li>
     * <li> {@link SQLDataType#CLOB}</li>
     * <li> {@link SQLDataType#NCLOB}</li>
     * </ul>
     */
    boolean isLob();

    Whether this data type is an array type.
/**
     * Whether this data type is an array type.
     */
    boolean isArray();

    Whether this data type is an embeddable type.
/**
     * Whether this data type is an embeddable type.
     */
    boolean isEmbeddable();

    Whether this data type is a UDT type.
/**
     * Whether this data type is a UDT type.
     */
    boolean isUDT();

    Whether this data type is an enum type.
/**
     * Whether this data type is an enum type.
     */
    boolean isEnum();

    Whether this data type is a JSON type.
/**
     * Whether this data type is a JSON type.
     */
    boolean isJSON();

    Whether this data type is an XML type.
/**
     * Whether this data type is an XML type.
     */
    boolean isXML();
}
Author:	Lukas Eder
Type parameters:	<T> – The Java type associated with this SQL data type
Params:	object – The object to be converted
Throws:	DataTypeException – If conversion fails.
Returns:	The converted object
Params:	objects – The objects to be converted
Throws:	DataTypeException – If conversion fails.
Returns:	The converted objects
Params:	nullability – The new nullability
Returns:	The new data type
Params:	nullable – The new nullability
Returns:	The new data type
Params:	identity – The new identity flag
Returns:	The new data type
See Also:	defaultValue(Field)
Returns:	The default value if present, or `null` if no default value is specified for this data type.
Params:	defaulted – The new defaultability
Returns:	The new data type
Deprecated:	- [#3852] - 3.8.0 - Use `defaultValue(Field)` instead.
Params:	precision – The new precision value
Returns:	The new data type
Params:	precision – The new precision value scale – The new scale value
Returns:	The new data type
Params:	scale – The new scale value
Returns:	The new data type
Params:	length – The new length value
Returns:	The new data type
/

org.jooq/ jooq/ 3.14.7/ org/jooq/DataType.java
