Field (jOOQ 3.11.12 API)

Type Parameters:

T - The field type

All Superinterfaces:

FieldOrConstraint, FieldOrRow, GroupField, Named, OrderField<T>, QueryPart, SelectField<T>, SelectFieldOrAsterisk, Serializable

All Known Subinterfaces:

AggregateFilterStep<T>, AggregateFunction<T>, ArrayAggOrderByStep<T>, CaseConditionStep<T>, CaseWhenStep<V,T>, GroupConcatOrderByStep, GroupConcatSeparatorStep, Param<T>, TableField<R,T>, UDTField<R,T>, WindowBeforeOverStep<T>, WindowFinalStep<T>, WindowOrderByStep<T>, WindowPartitionByStep<T>, WindowRowsStep<T>

All Known Implementing Classes:

CustomField, Iif, NullIf
```
public interface Field<T>
extends SelectField<T>, GroupField, OrderField<T>, FieldOrRow, FieldOrConstraint
```
A field used in tables and conditions
Note that all fields qualify as GroupField, i.e. they can always be used in GROUP BY clauses

Author:

Lukas Eder

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`Field<T>`	`abs()` Deprecated. - 3.11 - [#7538] - Use `DSL.abs(Field)` instead.
`Field<BigDecimal>`	`acos()` Deprecated. - 3.11 - [#7538] - Use `DSL.acos(Field)` instead.
`Field<T>`	`add(Field<?> value)` An arithmetic expression to add value to this.
`Field<T>`	`add(Number value)` An arithmetic expression adding this to value.
`Field<T>`	`as(Field<?> otherField)` Create an alias for this field based on another field's name.
`Field<T>`	`as(Function<? super Field<T>,? extends String> aliasFunction)` Create an alias for this field.
`Field<T>`	`as(Name alias)` Create an alias for this field.
`Field<T>`	`as(String alias)` Create an alias for this field.
`SortField<T>`	`asc()` Create an ascending sort field from this field.
`Field<Integer>`	`ascii()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	`asin()` Deprecated. - 3.11 - [#7538] - Use `DSL.asin(Field)` instead.
`Field<BigDecimal>`	`atan()` Deprecated. - 3.11 - [#7538] - Use `DSL.atan(Field)` instead.
`Field<BigDecimal>`	`atan2(Field<? extends Number> y)` Deprecated. - 3.11 - [#7538] - Use `DSL.atan2(Field, Field)` instead.
`Field<BigDecimal>`	`atan2(Number y)` Deprecated. - 3.11 - [#7538] - Use `DSL.atan2(Field, Number)` instead.
`Field<BigDecimal>`	`avg()` Deprecated. - 3.11 - [#7538] - Use `DSL.avg(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`avgOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.avg(Field)` instead.
`BetweenAndStep<T>`	`between(Field<T> minValue)` Create a condition to check this field against some bounds.
`Condition`	`between(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`between(T minValue)` Create a condition to check this field against some bounds.
`Condition`	`between(T minValue, T maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`betweenSymmetric(Field<T> minValue)` Create a condition to check this field against some bounds.
`Condition`	`betweenSymmetric(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`betweenSymmetric(T minValue)` Create a condition to check this field against some bounds.
`Condition`	`betweenSymmetric(T minValue, T maxValue)` Create a condition to check this field against some bounds.
`Field<T>`	`bitAnd(Field<T> value)` The bitwise and operator.
`Field<T>`	`bitAnd(T value)` The bitwise and operator.
`Field<Integer>`	`bitLength()` This method is part of the pre-2.0 API.
`Field<T>`	`bitNand(Field<T> value)` The bitwise not and operator.
`Field<T>`	`bitNand(T value)` The bitwise not and operator.
`Field<T>`	`bitNor(Field<T> value)` The bitwise not or operator.
`Field<T>`	`bitNor(T value)` The bitwise not or operator.
`Field<T>`	`bitNot()` The bitwise not operator.
`Field<T>`	`bitOr(Field<T> value)` The bitwise or operator.
`Field<T>`	`bitOr(T value)` The bitwise or operator.
`Field<T>`	`bitXNor(Field<T> value)` The bitwise not xor operator.
`Field<T>`	`bitXNor(T value)` The bitwise not xor operator.
`Field<T>`	`bitXor(Field<T> value)` The bitwise xor operator.
`Field<T>`	`bitXor(T value)` The bitwise xor operator.
`<Z> Field<Z>`	`cast(Class<Z> type)` Cast this field to another type.
`<Z> Field<Z>`	`cast(DataType<Z> type)` Cast this field to a dialect-specific data type.
`<Z> Field<Z>`	`cast(Field<Z> field)` Cast this field to the type of another field.
`Field<T>`	`ceil()` Deprecated. - 3.11 - [#7538] - Use `DSL.ceil(Field)` instead.
`boolean`	`changed(Record record)` The inverse operation of `Record.changed(Field)`.
`Field<Integer>`	`charLength()` This method is part of the pre-2.0 API.
`Field<T>`	`coalesce(Field<T> option, Field<?>... options)` This method is part of the pre-2.0 API.
`Field<T>`	`coalesce(T option, T... options)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`coerce(Class<Z> type)` Coerce this field to another type.
`<Z> Field<Z>`	`coerce(DataType<Z> type)` Coerce this field to a dialect-specific data type.
`<Z> Field<Z>`	`coerce(Field<Z> field)` Coerce this field to the type of another field.
`Field<String>`	`collate(Collation collation)` Apply a collation operator to this column expression.
`Field<String>`	`collate(Name collation)` Apply a collation operator to this column expression.
`Field<String>`	`collate(String collation)` Apply a collation operator to this column expression.
`Condition`	`compare(Comparator comparator, Field<T> field)` Compare this field with another field using a dynamic comparator.
`Condition`	`compare(Comparator comparator, QuantifiedSelect<? extends Record1<T>> query)` Compare this field with a quantified subselect using a dynamic comparator.
`Condition`	`compare(Comparator comparator, Select<? extends Record1<T>> query)` Compare this field with a subselect using a dynamic comparator.
`Condition`	`compare(Comparator comparator, T value)` Compare this field with a value using a dynamic comparator.
`Field<String>`	`concat(char... values)` This method is part of the pre-2.0 API.
`Field<String>`	`concat(Field<?>... fields)` This method is part of the pre-2.0 API.
`Field<String>`	`concat(String... values)` This method is part of the pre-2.0 API.
`Condition`	`contains(Field<T> value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Condition`	`contains(T value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Condition`	`containsIgnoreCase(Field<T> value)` Convenience method for `likeIgnoreCase(String, char)` including proper adding of wildcards and escaping.
`Condition`	`containsIgnoreCase(T value)` Convenience method for `likeIgnoreCase(String, char)` including proper adding of wildcards and escaping.
`Field<BigDecimal>`	`cos()` Deprecated. - 3.11 - [#7538] - Use `DSL.cos(Field)` instead.
`Field<BigDecimal>`	`cosh()` Deprecated. - 3.11 - [#7538] - Use `DSL.cosh(Field)` instead.
`Field<BigDecimal>`	`cot()` Deprecated. - 3.11 - [#7538] - Use `DSL.cot(Field)` instead.
`Field<BigDecimal>`	`coth()` Deprecated. - 3.11 - [#7538] - Use `DSL.coth(Field)` instead.
`Field<Integer>`	`count()` Deprecated. - 3.11 - [#7538] - Use `DSL.count(Field)` instead.
`Field<Integer>`	`countDistinct()` Deprecated. - 3.11 - [#7538] - Use `DSL.countDistinct(Field)` instead.
`WindowPartitionByStep<Integer>`	`countOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.count(Field)` instead.
`<Z> Field<Z>`	`decode(Field<T> search, Field<Z> result)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`decode(Field<T> search, Field<Z> result, Field<?>... more)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`decode(T search, Z result)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`decode(T search, Z result, Object... more)` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	`deg()` Deprecated. - 3.11 - [#7538] - Use `DSL.deg(Field)` instead.
`SortField<T>`	`desc()` Create a descending sort field from this field.
`Field<T>`	`div(Field<? extends Number> value)` An arithmetic expression dividing this by value.
`Field<T>`	`div(Number value)` An arithmetic expression dividing this by value.
`Field<T>`	`divide(Field<? extends Number> value)` An alias for `div(Field)`.
`Field<T>`	`divide(Number value)` An alias for `div(Number)`.
`Condition`	`endsWith(Field<T> value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Condition`	`endsWith(T value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Condition`	`eq(Field<T> field)` `this = field`.
`Condition`	`eq(QuantifiedSelect<? extends Record1<T>> query)` `this = [quantifier] (Select<?`
`Condition`	`eq(Select<? extends Record1<T>> query)` `this = (Select<?`
`Condition`	`eq(T value)` `this = value`.
`Condition`	`equal(Field<T> field)` `this = field`.
`Condition`	`equal(QuantifiedSelect<? extends Record1<T>> query)` `this = [quantifier] (Select<?`
`Condition`	`equal(Select<? extends Record1<T>> query)` `this = (Select<?`
`Condition`	`equal(T value)` `this = value`.
`Condition`	`equalIgnoreCase(Field<String> value)` `lower(this) = lower(value)`.
`Condition`	`equalIgnoreCase(String value)` `lower(this) = lower(value)`.
`boolean`	`equals(Object other)` Check whether this `QueryPart` can be considered equal to another `QueryPart`.
`Field<BigDecimal>`	`exp()` Deprecated. - 3.11 - [#7538] - Use `DSL.exp(Field)` instead.
`Field<Integer>`	`extract(DatePart datePart)` Deprecated. - 3.11 - [#7538] - Use `DSL#extract(DatePart)` instead.
`Field<T>`	`field(Record record)` The inverse operation of `Record.field(Field)`.
`WindowIgnoreNullsStep<T>`	`firstValue()` Deprecated. - 3.11 - [#7538] - Use `DSL.firstValue(Field)` instead.
`Field<T>`	`floor()` Deprecated. - 3.11 - [#7538] - Use `DSL.floor(Field)` instead.
`Record1<T>`	`from(Record record)` The inverse operation of `Record.into(Field)`.
`Condition`	`ge(Field<T> field)` `this >= field`.
`Condition`	`ge(QuantifiedSelect<? extends Record1<T>> query)` `this >= [quantifier] (Select<?`
`Condition`	`ge(Select<? extends Record1<T>> query)` `this >= (Select<?`
`Condition`	`ge(T value)` `this >= value`.
`T`	`get(Record record)` The inverse operation of `Record.get(Field)`.
`Binding<?,T>`	`getBinding()` The field's underlying `Binding`.
`String`	`getComment()` The comment given to the field.
`Converter<?,T>`	`getConverter()` The field's underlying `Converter`.
`DataType<T>`	`getDataType()` The type of this field (might not be dialect-specific).
`DataType<T>`	`getDataType(Configuration configuration)` The dialect-specific type of this field.
`String`	`getName()` The name of the field.
`Class<T>`	`getType()` The Java type of the field.
`T`	`getValue(Record record)` The inverse operation of `Record.getValue(Field)`.
`Condition`	`greaterOrEqual(Field<T> field)` `this >= field`.
`Condition`	`greaterOrEqual(QuantifiedSelect<? extends Record1<T>> query)` `this >= [quantifier] (Select<?`
`Condition`	`greaterOrEqual(Select<? extends Record1<T>> query)` `this >= (Select<?`
`Condition`	`greaterOrEqual(T value)` `this >= value`.
`Condition`	`greaterThan(Field<T> field)` `this > field`.
`Condition`	`greaterThan(QuantifiedSelect<? extends Record1<T>> query)` `this > [quantifier] (Select<?`
`Condition`	`greaterThan(Select<? extends Record1<T>> query)` `this > (Select<?`
`Condition`	`greaterThan(T value)` `this > value`.
`Field<T>`	`greatest(Field<?>... others)` Deprecated. - 3.11 - [#7538] - Use `DSL.greatest(Field, Field...)` instead.
`Field<T>`	`greatest(T... others)` Deprecated. - 3.11 - [#7538] - Use `DSL.greatest(Field, Field...)` instead.
`Condition`	`gt(Field<T> field)` `this > field`.
`Condition`	`gt(QuantifiedSelect<? extends Record1<T>> query)` `this > [quantifier] (Select<?`
`Condition`	`gt(Select<? extends Record1<T>> query)` `this > (Select<?`
`Condition`	`gt(T value)` `this > value`.
`Condition`	`in(Collection<?> values)` Create a condition to check this field against several values.
`Condition`	`in(Field<?>... values)` Create a condition to check this field against several values.
`Condition`	`in(Result<? extends Record1<T>> result)` Create a condition to check this field against several values from a previous query.
`Condition`	`in(Select<? extends Record1<T>> query)` Create a condition to check this field against a subquery.
`Condition`	`in(T... values)` Create a condition to check this field against several values.
`Condition`	`isDistinctFrom(Field<T> field)` Create a condition to check if this field is `DISTINCT` from another field.
`Condition`	`isDistinctFrom(T value)` Create a condition to check if this field is `DISTINCT` from another value.
`Condition`	`isFalse()` Create a condition to check this field against known string literals for `false`.
`Condition`	`isNotDistinctFrom(Field<T> field)` Create a condition to check if this field is `NOT DISTINCT` from another field.
`Condition`	`isNotDistinctFrom(T value)` Create a condition to check if this field is `NOT DISTINCT` from another value.
`Condition`	`isNotNull()` Create a condition to check this field against `null`.
`Condition`	`isNull()` Create a condition to check this field against `null`.
`Condition`	`isTrue()` Create a condition to check this field against known string literals for `true`.
`WindowIgnoreNullsStep<T>`	`lag()` Deprecated. - 3.11 - [#7538] - Use `DSL.lag(Field)` instead.
`WindowIgnoreNullsStep<T>`	`lag(int offset)` Deprecated. - 3.11 - [#7538] - Use `DSL.lag(Field, int)` instead.
`WindowIgnoreNullsStep<T>`	`lag(int offset, Field<T> defaultValue)` Deprecated. - 3.11 - [#7538] - Use `DSL.lag(Field, int, Field)` instead.
`WindowIgnoreNullsStep<T>`	`lag(int offset, T defaultValue)` Deprecated. - 3.11 - [#7538] - Use `DSL.lag(Field, int, Object)` instead.
`WindowIgnoreNullsStep<T>`	`lastValue()` Deprecated. - 3.11 - [#7538] - Use `DSL.lastValue(Field)` instead.
`Condition`	`le(Field<T> field)` `this <= field`.
`Condition`	`le(QuantifiedSelect<? extends Record1<T>> query)` `this <= [quantifier] (Select<?`
`Condition`	`le(Select<? extends Record1<T>> query)` `this <= (Select<?`
`Condition`	`le(T value)` `this <= value`.
`WindowIgnoreNullsStep<T>`	`lead()` Deprecated. - 3.11 - [#7538] - Use `DSL.lead(Field)` instead.
`WindowIgnoreNullsStep<T>`	`lead(int offset)` Deprecated. - 3.11 - [#7538] - Use `DSL.lead(Field, int)` instead.
`WindowIgnoreNullsStep<T>`	`lead(int offset, Field<T> defaultValue)` Deprecated. - 3.11 - [#7538] - Use `DSL.lead(Field, int, Field)` instead.
`WindowIgnoreNullsStep<T>`	`lead(int offset, T defaultValue)` Deprecated. - 3.11 - [#7538] - Use `DSL.lead(Field, int, Object)` instead.
`Field<T>`	`least(Field<?>... others)` Deprecated. - 3.11 - [#7538] - Use `DSL.least(Field, Field...)` instead.
`Field<T>`	`least(T... others)` Deprecated. - 3.11 - [#7538] - Use `DSL.least(Field, Field...)` instead.
`Field<Integer>`	`length()` This method is part of the pre-2.0 API.
`Condition`	`lessOrEqual(Field<T> field)` `this <= field`.
`Condition`	`lessOrEqual(QuantifiedSelect<? extends Record1<T>> query)` `this <= [quantifier] (Select<?`
`Condition`	`lessOrEqual(Select<? extends Record1<T>> query)` `this <= (Select<?`
`Condition`	`lessOrEqual(T value)` `this <= value`.
`Condition`	`lessThan(Field<T> field)` `this < field`.
`Condition`	`lessThan(QuantifiedSelect<? extends Record1<T>> query)` `this < [quantifier] (Select<?`
`Condition`	`lessThan(Select<? extends Record1<T>> query)` `this < (Select<?`
`Condition`	`lessThan(T value)` `this < value`.
`LikeEscapeStep`	`like(Field<String> value)` Create a condition to pattern-check this field against a value.
`Condition`	`like(Field<String> value, char escape)` Create a condition to pattern-check this field against a value.
`LikeEscapeStep`	`like(String value)` Create a condition to pattern-check this field against a value.
`Condition`	`like(String value, char escape)` Create a condition to pattern-check this field against a value.
`LikeEscapeStep`	`likeIgnoreCase(Field<String> field)` Create a condition to case-insensitively pattern-check this field against a field.
`Condition`	`likeIgnoreCase(Field<String> field, char escape)` Create a condition to case-insensitively pattern-check this field against a field.
`LikeEscapeStep`	`likeIgnoreCase(String value)` Create a condition to case-insensitively pattern-check this field against a value.
`Condition`	`likeIgnoreCase(String value, char escape)` Create a condition to case-insensitively pattern-check this field against a value.
`Condition`	`likeRegex(Field<String> pattern)` Create a condition to regex-pattern-check this field against a pattern.
`Condition`	`likeRegex(String pattern)` Create a condition to regex-pattern-check this field against a pattern.
`Field<BigDecimal>`	`ln()` Deprecated. - 3.11 - [#7538] - Use `DSL.ln(Field)` instead.
`Field<BigDecimal>`	`log(int base)` Deprecated. - 3.11 - [#7538] - Use `DSL.log(Field, int)` instead.
`Field<String>`	`lower()` This method is part of the pre-2.0 API.
`Field<String>`	`lpad(Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	`lpad(Field<? extends Number> length, Field<String> character)` This method is part of the pre-2.0 API.
`Field<String>`	`lpad(int length)` This method is part of the pre-2.0 API.
`Field<String>`	`lpad(int length, char character)` This method is part of the pre-2.0 API.
`Condition`	`lt(Field<T> field)` `this < field`.
`Condition`	`lt(QuantifiedSelect<? extends Record1<T>> query)` `this < [quantifier] (Select<?`
`Condition`	`lt(Select<? extends Record1<T>> query)` `this < (Select<?`
`Condition`	`lt(T value)` `this < value`.
`Field<String>`	`ltrim()` This method is part of the pre-2.0 API.
`Field<T>`	`max()` Deprecated. - 3.11 - [#7538] - Use `DSL.max(Field)` instead.
`WindowPartitionByStep<T>`	`maxOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.max(Field)` instead.
`Field<BigDecimal>`	`median()` Deprecated. - 3.11 - [#7538] - Use `DSL.median(Field)` instead.
`Field<T>`	`min()` Deprecated. - 3.11 - [#7538] - Use `DSL.min(Field)` instead.
`WindowPartitionByStep<T>`	`minOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.min(Field)` instead.
`Field<T>`	`minus(Field<?> value)` An alias for `sub(Field)`.
`Field<T>`	`minus(Number value)` An alias for `sub(Number)`.
`Field<T>`	`mod(Field<? extends Number> value)` An arithmetic expression getting the modulo of this divided by value.
`Field<T>`	`mod(Number value)` An arithmetic expression getting the modulo of this divided by value.
`Field<T>`	`modulo(Field<? extends Number> value)` An alias for `mod(Field)`.
`Field<T>`	`modulo(Number value)` An alias for `mod(Number)`.
`Field<T>`	`mul(Field<? extends Number> value)` An arithmetic expression multiplying this with value.
`Field<T>`	`mul(Number value)` An arithmetic expression multiplying this with value.
`Field<T>`	`multiply(Field<? extends Number> value)` An alias for `mul(Field)`.
`Field<T>`	`multiply(Number value)` An alias for `mul(Number)`.
`Condition`	`ne(Field<T> field)` `this !`
`Condition`	`ne(QuantifiedSelect<? extends Record1<T>> query)` `this !`
`Condition`	`ne(Select<? extends Record1<T>> query)` `this !`
`Condition`	`ne(T value)` `this !`
`Field<T>`	`neg()` Negate this field to get its negative value.
`BetweenAndStep<T>`	`notBetween(Field<T> minValue)` Create a condition to check this field against some bounds.
`Condition`	`notBetween(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`notBetween(T minValue)` Create a condition to check this field against some bounds.
`Condition`	`notBetween(T minValue, T maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`notBetweenSymmetric(Field<T> minValue)` Create a condition to check this field against some bounds.
`Condition`	`notBetweenSymmetric(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds.
`BetweenAndStep<T>`	`notBetweenSymmetric(T minValue)` Create a condition to check this field against some bounds.
`Condition`	`notBetweenSymmetric(T minValue, T maxValue)` Create a condition to check this field against some bounds.
`Condition`	`notContains(Field<T> value)` Inverse of `contains(Field)`.
`Condition`	`notContains(T value)` Inverse of `contains(Object)`.
`Condition`	`notContainsIgnoreCase(Field<T> value)` Inverse of `containsIgnoreCase(Field)`
`Condition`	`notContainsIgnoreCase(T value)` Inverse of `containsIgnoreCase(Object)`
`Condition`	`notEqual(Field<T> field)` `this !`
`Condition`	`notEqual(QuantifiedSelect<? extends Record1<T>> query)` `this !`
`Condition`	`notEqual(Select<? extends Record1<T>> query)` `this !`
`Condition`	`notEqual(T value)` `this !`
`Condition`	`notEqualIgnoreCase(Field<String> value)` `lower(this) !`
`Condition`	`notEqualIgnoreCase(String value)` `lower(this) !`
`Condition`	`notIn(Collection<?> values)` Create a condition to check this field against several values.
`Condition`	`notIn(Field<?>... values)` Create a condition to check this field against several values.
`Condition`	`notIn(Result<? extends Record1<T>> result)` Create a condition to check this field against several values from a previous query.
`Condition`	`notIn(Select<? extends Record1<T>> query)` Create a condition to check this field against a subquery.
`Condition`	`notIn(T... values)` Create a condition to check this field against several values.
`LikeEscapeStep`	`notLike(Field<String> field)` Create a condition to pattern-check this field against a field.
`Condition`	`notLike(Field<String> field, char escape)` Create a condition to pattern-check this field against a field.
`LikeEscapeStep`	`notLike(String value)` Create a condition to pattern-check this field against a value.
`Condition`	`notLike(String value, char escape)` Create a condition to pattern-check this field against a value.
`LikeEscapeStep`	`notLikeIgnoreCase(Field<String> field)` Create a condition to case-insensitively pattern-check this field against a field.
`Condition`	`notLikeIgnoreCase(Field<String> field, char escape)` Create a condition to case-insensitively pattern-check this field against a field.
`LikeEscapeStep`	`notLikeIgnoreCase(String value)` Create a condition to case-insensitively pattern-check this field against a value.
`Condition`	`notLikeIgnoreCase(String value, char escape)` Create a condition to case-insensitively pattern-check this field against a value.
`Condition`	`notLikeRegex(Field<String> pattern)` Create a condition to regex-pattern-check this field against a pattern.
`Condition`	`notLikeRegex(String pattern)` Create a condition to regex-pattern-check this field against a pattern.
`Field<T>`	`nullif(Field<T> other)` This method is part of the pre-2.0 API.
`Field<T>`	`nullif(T other)` This method is part of the pre-2.0 API.
`Field<T>`	`nvl(Field<T> defaultValue)` This method is part of the pre-2.0 API.
`Field<T>`	`nvl(T defaultValue)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`nvl2(Field<Z> valueIfNotNull, Field<Z> valueIfNull)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	`nvl2(Z valueIfNotNull, Z valueIfNull)` This method is part of the pre-2.0 API.
`Field<Integer>`	`octetLength()` This method is part of the pre-2.0 API.
`T`	`original(Record record)` The inverse operation of `Record.original(Field)`.
`Field<T>`	`plus()` Turn this field into an Oracle-specific field for use in outer-join predicates.
`Field<T>`	`plus(Field<?> value)` An alias for `add(Field)`.
`Field<T>`	`plus(Number value)` An alias for `add(Number)`.
`Field<Integer>`	`position(Field<String> search)` This method is part of the pre-2.0 API.
`Field<Integer>`	`position(String search)` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	`pow(Field<? extends Number> exponent)` An arithmetic expression getting this value raised to the power of `exponent`.
`Field<BigDecimal>`	`pow(Number exponent)` An arithmetic expression getting this value raised to the power of `exponent`.
`Field<BigDecimal>`	`power(Field<? extends Number> exponent)` An alias for `power(Field)`.
`Field<BigDecimal>`	`power(Number exponent)` An alias for `power(Number)`.
`Field<BigDecimal>`	`rad()` Deprecated. - 3.11 - [#7538] - Use `DSL.rad(Field)` instead.
`Field<T>`	`rem(Field<? extends Number> value)` An alias for `mod(Field)`.
`Field<T>`	`rem(Number value)` An alias for `mod(Number)`.
`Field<String>`	`repeat(Field<? extends Number> count)` This method is part of the pre-2.0 API.
`Field<String>`	`repeat(Number count)` This method is part of the pre-2.0 API.
`Field<String>`	`replace(Field<String> search)` This method is part of the pre-2.0 API.
`Field<String>`	`replace(Field<String> search, Field<String> replace)` This method is part of the pre-2.0 API.
`Field<String>`	`replace(String search)` This method is part of the pre-2.0 API.
`Field<String>`	`replace(String search, String replace)` This method is part of the pre-2.0 API.
`void`	`reset(Record record)` The inverse operation of `Record.reset(Field)`.
`Field<T>`	`round()` Deprecated. - 3.11 - [#7538] - Use `DSL.round(Field)` instead.
`Field<T>`	`round(int decimals)` Deprecated. - 3.11 - [#7538] - Use `DSL.round(Field, int)` instead.
`Field<String>`	`rpad(Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	`rpad(Field<? extends Number> length, Field<String> character)` This method is part of the pre-2.0 API.
`Field<String>`	`rpad(int length)` This method is part of the pre-2.0 API.
`Field<String>`	`rpad(int length, char character)` This method is part of the pre-2.0 API.
`Field<String>`	`rtrim()` This method is part of the pre-2.0 API.
`Field<T>`	`shl(Field<? extends Number> value)` The bitwise left shift operator.
`Field<T>`	`shl(Number value)` The bitwise left shift operator.
`Field<T>`	`shr(Field<? extends Number> value)` The bitwise right shift operator.
`Field<T>`	`shr(Number value)` The bitwise right shift operator.
`Field<Integer>`	`sign()` Deprecated. - 3.11 - [#7538] - Use `DSL.sign(Field)` instead.
`Field<BigDecimal>`	`sin()` Deprecated. - 3.11 - [#7538] - Use `DSL.sin(Field)` instead.
`Field<BigDecimal>`	`sinh()` Deprecated. - 3.11 - [#7538] - Use `DSL.sinh(Field)` instead.
`<Z> SortField<Z>`	`sort(Map<T,Z> sortMap)` Create an indirected sort field.
`SortField<T>`	`sort(SortOrder order)` Create an ascending/descending sort field from this field.
`SortField<Integer>`	`sortAsc(Collection<T> sortList)` Create an indirected sort field.
`SortField<Integer>`	`sortAsc(T... sortList)` Create an indirected sort field.
`SortField<T>`	`sortDefault()` Create a default sorted (implicit `ASC`) from this field.
`SortField<Integer>`	`sortDesc(Collection<T> sortList)` Create an indirected sort field.
`SortField<Integer>`	`sortDesc(T... sortList)` Create an indirected sort field.
`Field<BigDecimal>`	`sqrt()` Deprecated. - 3.11 - [#7538] - Use `DSL.sqrt(Field)` instead.
`Condition`	`startsWith(Field<T> value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Condition`	`startsWith(T value)` Convenience method for `like(String, char)` including proper adding of wildcards and escaping.
`Field<BigDecimal>`	`stddevPop()` Deprecated. - 3.11 - [#7538] - Use `DSL.stddevPop(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`stddevPopOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.stddevPop(Field)` instead.
`Field<BigDecimal>`	`stddevSamp()` Deprecated. - 3.11 - [#7538] - Use `DSL.stddevSamp(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`stddevSampOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.stddevSamp(Field)` instead.
`Field<T>`	`sub(Field<?> value)` An arithmetic expression subtracting value from this.
`Field<T>`	`sub(Number value)` An arithmetic expression subtracting value from this.
`Field<String>`	`substring(Field<? extends Number> startingPosition)` This method is part of the pre-2.0 API.
`Field<String>`	`substring(Field<? extends Number> startingPosition, Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	`substring(int startingPosition)` This method is part of the pre-2.0 API.
`Field<String>`	`substring(int startingPosition, int length)` This method is part of the pre-2.0 API.
`Field<T>`	`subtract(Field<?> value)` An alias for `sub(Field)`.
`Field<T>`	`subtract(Number value)` An alias for `sub(Number)`.
`Field<BigDecimal>`	`sum()` Deprecated. - 3.11 - [#7538] - Use `DSL.sum(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`sumOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.sum(Field)` instead.
`Field<BigDecimal>`	`tan()` Deprecated. - 3.11 - [#7538] - Use `DSL.tan(Field)` instead.
`Field<BigDecimal>`	`tanh()` Deprecated. - 3.11 - [#7538] - Use `DSL.tanh(Field)` instead.
`Field<T>`	`times(Field<? extends Number> value)` An alias for `mul(Field)`.
`Field<T>`	`times(Number value)` An alias for `mul(Number)`.
`Field<String>`	`trim()` This method is part of the pre-2.0 API.
`Field<T>`	`unaryMinus()` Negate this field to get its negative value.
`Field<T>`	`unaryPlus()` Get this field as its positive value (no effect on SQL).
`Field<String>`	`upper()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	`varPop()` Deprecated. - 3.11 - [#7538] - Use `DSL.varPop(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`varPopOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.varPop(Field)` instead.
`Field<BigDecimal>`	`varSamp()` Deprecated. - 3.11 - [#7538] - Use `DSL.varSamp(Field)` instead.
`WindowPartitionByStep<BigDecimal>`	`varSampOver()` Deprecated. - 3.11 - [#7538] - Use `DSL.varSamp(Field)` instead.

Methods inherited from interface org.jooq.Named
getQualifiedName, getUnqualifiedName

Method Detail

getName
```
String getName()
```
The name of the field.
The name is any of these:
- The formal name of the field, if it is a physical table/view field
- The alias of an aliased field
- A generated / unspecified value for any other expression
- The name of a parameter if it is a named Param
Specified by:

getName in interface Named

getComment
```
String getComment()
```
The comment given to the field.
If this Field is a generated field from your database, it may provide its DDL comment through this method. All other column expressions return the empty string "" here, never null.

Specified by:

getComment in interface Named

getConverter
```
Converter<?,T> getConverter()
```
The field's underlying Converter.
By default, all fields reference an identity-converter Converter<T, T>. Custom data types may be obtained by a custom Converter placed on the generated TableField.

Specified by:

getConverter in interface SelectField<T>

getBinding
```
Binding<?,T> getBinding()
```
The field's underlying Binding.

Specified by:

getBinding in interface SelectField<T>

getType
```
Class<T> getType()
```
The Java type of the field.

Specified by:

getType in interface SelectField<T>

getDataType
```
DataType<T> getDataType()
```
The type of this field (might not be dialect-specific).

Specified by:

getDataType in interface SelectField<T>

getDataType
```
DataType<T> getDataType(Configuration configuration)
```
The dialect-specific type of this field.

Specified by:

getDataType in interface SelectField<T>

as
```
@Support
Field<T> as(String alias)
```
Create an alias for this field.
Note that the case-sensitivity of the returned field depends on Settings.getRenderNameStyle(). By default, field aliases are quoted, and thus case-sensitive!

Parameters:

alias - The alias name

Returns:

The field alias

as
```
@Support
Field<T> as(Name alias)
```
Create an alias for this field.
Note that the case-sensitivity of the returned field depends on Settings.getRenderNameStyle() and the Name. By default, field aliases are quoted, and thus case-sensitive - use DSL.unquotedName(String...) for case-insensitive aliases.
If the argument Name.getName() is qualified, then the Name.last() part will be used.

Parameters:

alias - The alias name

Returns:

The field alias

as
```
@Support
Field<T> as(Field<?> otherField)
```
Create an alias for this field based on another field's name.
Note that the case-sensitivity of the returned field depends on Settings.getRenderNameStyle(). By default, field aliases are quoted, and thus case-sensitive!

Parameters:

otherField - The other field whose name this field is aliased with.

Returns:

The field alias.

as
```
@Support
Field<T> as(Function<? super Field<T>,? extends String> aliasFunction)
```
Create an alias for this field.
Note that the case-sensitivity of the returned field depends on Settings.getRenderNameStyle(). By default, field aliases are quoted, and thus case-sensitive!
This works like as(String), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix (on Table.as(String, Function)):
```
 MY_TABLE.as("t1", f -> "prefix_" + f.getName());
 
```
And then to use the same function also for individual fields:
```
 MY_TABLE.MY_COLUMN.as(f -> "prefix_" + f.getName());
 
```

equals
```
boolean equals(Object other)
```
Check whether this QueryPart can be considered equal to another QueryPart.
In general, QueryPart equality is defined in terms of QueryPart.toString() equality. In other words, two query parts are considered equal if their rendered SQL (with inlined bind variables) is equal. This means that the two query parts do not necessarily have to be of the same type.
Some QueryPart implementations may choose to override this behaviour for improved performance, as QueryPart.toString() is an expensive operation, if called many times.
Watch out! This is Object.equals(Object), not a jOOQ DSL feature!

Specified by:

equals in interface QueryPart

Overrides:

equals in class Object

Parameters:

other - The other QueryPart

Returns:

Whether the two query parts are equal

cast
```
@Support
<Z> Field<Z> cast(Field<Z> field)
```
Cast this field to the type of another field.
This results in the same as casting this field to DataType.getCastTypeName()

Type Parameters:

Z - The generic type of the cast field

Parameters:

field - The field whose type is used for the cast

Returns:

The cast field

See Also:

cast(DataType)

cast
```
@Support
<Z> Field<Z> cast(DataType<Z> type)
```
Cast this field to a dialect-specific data type.

Type Parameters:

Z - The generic type of the cast field

Parameters:

type - The data type that is used for the cast

Returns:

The cast field

cast
```
@Support
<Z> Field<Z> cast(Class<Z> type)
```
Cast this field to another type.
The actual cast may not be accurate as the DataType has to be "guessed" from the jOOQ-configured data types. Use cast(DataType) for more accurate casts.

Type Parameters:

Z - The generic type of the cast field

Parameters:

type - The type that is used for the cast

Returns:

The cast field

See Also:

cast(DataType)

coerce

@Support
<Z> Field<Z> coerce(Field<Z> field)

Coerce this field to the type of another field.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: Z - The generic type of the coerced field
Parameters:: field - The field whose type is used for the coercion
Returns:: The coerced field
See Also:: coerce(DataType), cast(Field)

coerce

@Support
<Z> Field<Z> coerce(DataType<Z> type)

Coerce this field to a dialect-specific data type.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: Z - The generic type of the coerced field
Parameters:: type - The data type that is used for the coercion
Returns:: The coerced field
See Also:: cast(DataType)

coerce

@Support
<Z> Field<Z> coerce(Class<Z> type)

Coerce this field to another type.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: Z - The generic type of the coerced field
Parameters:: type - The type that is used for the coercion
Returns:: The coerced field
See Also:: coerce(DataType), cast(Class)

asc
```
@Support
SortField<T> asc()
```
Create an ascending sort field from this field.
This is the same as calling sort(SortOrder) with SortOrder.ASC

Returns:

This field as an ascending sort field

desc
```
@Support
SortField<T> desc()
```
Create a descending sort field from this field.
This is the same as calling sort(SortOrder) with SortOrder.DESC

Returns:

This field as a descending sort field

sortDefault
```
@Support
SortField<T> sortDefault()
```
Create a default sorted (implicit ASC) from this field.
This is the same as calling sort(SortOrder) with SortOrder.DEFAULT

Returns:

This field as a default sorted sort field

sort
```
@Support
SortField<T> sort(SortOrder order)
```
Create an ascending/descending sort field from this field.

Parameters:

order - The sort order

Returns:

This field as an ascending/descending sort field.

sortAsc
```
@Support
SortField<Integer> sortAsc(Collection<T> sortList)
```
Create an indirected sort field.
Create a sort field of the form
```
 CASE [this] WHEN [sortList.get(0)] THEN 0
             WHEN [sortList.get(1)] THEN 1
             ...
             WHEN [sortList.get(n)] THEN n
                                    ELSE null
 END ASC
 
```
Note: You can use this in combination with SortField.nullsFirst() or SortField.nullsLast() to specify whether the default should have highest or lowest priority.
Parameters:

sortList - The list containing sort value preferences

Returns:

The sort field

sortAsc
```
@Support
SortField<Integer> sortAsc(T... sortList)
```
Create an indirected sort field.
Create a sort field of the form
```
 CASE [this] WHEN [sortList[0]] THEN 0
             WHEN [sortList[1]] THEN 1
             ...
             WHEN [sortList[n]] THEN n
                                ELSE null
 END ASC
 
```
Note: You can use this in combination with SortField.nullsFirst() or SortField.nullsLast() to specify whether the default should have highest or lowest priority.
Parameters:

sortList - The list containing sort value preferences

Returns:

The sort field

sortDesc
```
@Support
SortField<Integer> sortDesc(Collection<T> sortList)
```
Create an indirected sort field.
Create a sort field of the form
```
 CASE [this] WHEN [sortList.get(0)] THEN 0
             WHEN [sortList.get(1)] THEN 1
             ...
             WHEN [sortList.get(n)] THEN n
                                    ELSE null
 END DESC
 
```
Note: You can use this in combination with SortField.nullsFirst() or SortField.nullsLast() to specify whether the default should have highest or lowest priority.
Parameters:

sortList - The list containing sort value preferences

Returns:

The sort field

sortDesc
```
@Support
SortField<Integer> sortDesc(T... sortList)
```
Create an indirected sort field.
Create a sort field of the form
```
 CASE [this] WHEN [sortList[0]] THEN 0
             WHEN [sortList[1]] THEN 1
             ...
             WHEN [sortList[n]] THEN n
                                    ELSE null
 END DESC
 
```
Note: You can use this in combination with SortField.nullsFirst() or SortField.nullsLast() to specify whether the default should have highest or lowest priority.
Parameters:

sortList - The list containing sort value preferences

Returns:

The sort field

sort
```
@Support
<Z> SortField<Z> sort(Map<T,Z> sortMap)
```
Create an indirected sort field.
Create a sort field of the form (in pseudo code)
```
 CASE [this] WHEN [sortMap.key(0)] THEN sortMap.value(0)
             WHEN [sortMap.key(1)] THEN sortMap.value(1)
             ...
             WHEN [sortMap.key(n)] THEN sortMap.value(n)
                                   ELSE null
 END DESC
 
```
Note: You can use this in combination with SortField.nullsFirst() or SortField.nullsLast() to specify whether the default should have highest or lowest priority.
Parameters:

sortMap - The list containing sort value preferences

Returns:

The sort field

neg
```
@Support
Field<T> neg()
```
Negate this field to get its negative value.
This renders the same on all dialects:
```
-[this]
```

unaryMinus
```
@Support
Field<T> unaryMinus()
```
Negate this field to get its negative value.
This is an alias for neg(), which can be recognised by the Kotlin language for operator overloading.

unaryPlus
```
@Support
Field<T> unaryPlus()
```
Get this field as its positive value (no effect on SQL).
This can be recognised by the Kotlin language for operator overloading.

add
```
@Support
Field<T> add(Number value)
```
An arithmetic expression adding this to value.

See Also:

add(Field)

add
```
@Support
Field<T> add(Field<?> value)
```
An arithmetic expression to add value to this.
The behaviour of this operation is as follows:

Operand 1 Operand 2 Result Type

Numeric Numeric Numeric

Date / Time Numeric Date / Time

Date / Time Interval Date / Time

Interval Interval Interval

Operand 1	Operand 2	Result Type
Numeric	Numeric	Numeric
Date / Time	Numeric	Date / Time
Date / Time	Interval	Date / Time
Interval	Interval	Interval

plus
```
@Support
Field<T> plus(Number value)
```
An alias for add(Number).

See Also:

add(Number)

plus
```
@Support
Field<T> plus(Field<?> value)
```
An alias for add(Field).

See Also:

add(Field)

sub
```
@Support
Field<T> sub(Number value)
```
An arithmetic expression subtracting value from this.

See Also:

sub(Field)

sub
```
@Support
Field<T> sub(Field<?> value)
```
An arithmetic expression subtracting value from this.

Operand 1 Operand 2 Result Type

Numeric Numeric Numeric

Date / Time Numeric Date / Time

Date / Time Interval Date / Time

Interval Interval Interval

In order to subtract one date time field from another, use any of these methods:
- DSL.dateDiff(Field, Field)
- DSL.timestampDiff(Field, Field)

Operand 1	Operand 2	Result Type
Numeric	Numeric	Numeric
Date / Time	Numeric	Date / Time
Date / Time	Interval	Date / Time
Interval	Interval	Interval

subtract
```
@Support
Field<T> subtract(Number value)
```
An alias for sub(Number).

See Also:

sub(Number)

subtract
```
@Support
Field<T> subtract(Field<?> value)
```
An alias for sub(Field).

See Also:

sub(Field)

minus
```
@Support
Field<T> minus(Number value)
```
An alias for sub(Number).

See Also:

sub(Number)

minus
```
@Support
Field<T> minus(Field<?> value)
```
An alias for sub(Field).

See Also:

sub(Field)

mul
```
@Support
Field<T> mul(Number value)
```
An arithmetic expression multiplying this with value.
- If this is a numeric field, then the result is a number of the same type as this field.
- If this is an INTERVAL field, then the result is also an INTERVAL field (see Interval)

mul
```
@Support
Field<T> mul(Field<? extends Number> value)
```
An arithmetic expression multiplying this with value.
- If this is a numeric field, then the result is a number of the same type as this field.
- If this is an INTERVAL field, then the result is also an INTERVAL field (see Interval)

multiply
```
@Support
Field<T> multiply(Number value)
```
An alias for mul(Number).

See Also:

mul(Number)

multiply

@Support
Field<T> multiply(Field<? extends Number> value)

An alias for mul(Field).

See Also:: mul(Field)

times
```
@Support
Field<T> times(Number value)
```
An alias for mul(Number).

See Also:

mul(Number)

times

@Support
Field<T> times(Field<? extends Number> value)

An alias for mul(Field).

See Also:: mul(Field)

div
```
@Support
Field<T> div(Number value)
```
An arithmetic expression dividing this by value.
- If this is a numeric field, then the result is a number of the same type as this field.
- If this is an INTERVAL field, then the result is also an INTERVAL field (see Interval)

div
```
@Support
Field<T> div(Field<? extends Number> value)
```
An arithmetic expression dividing this by value.
- If this is a numeric field, then the result is a number of the same type as this field.
- If this is an INTERVAL field, then the result is also an INTERVAL field (see Interval)

divide
```
@Support
Field<T> divide(Number value)
```
An alias for div(Number).

See Also:

div(Number)

divide

@Support
Field<T> divide(Field<? extends Number> value)

An alias for div(Field).

See Also:: div(Field)

mod
```
@Support
Field<T> mod(Number value)
```
An arithmetic expression getting the modulo of this divided by value.
This renders the modulo operation where available:
```
[this] % [value]
```
... or the modulo function elsewhere: mod([this], [value])

mod
```
@Support
Field<T> mod(Field<? extends Number> value)
```
An arithmetic expression getting the modulo of this divided by value.
This renders the modulo operation where available:
```
[this] % [value]
```
... or the modulo function elsewhere: mod([this], [value])

modulo
```
@Support
Field<T> modulo(Number value)
```
An alias for mod(Number).

See Also:

mod(Number)

modulo

@Support
Field<T> modulo(Field<? extends Number> value)

An alias for mod(Field).

See Also:: mod(Field)

rem
```
@Support
Field<T> rem(Number value)
```
An alias for mod(Number).

See Also:

mod(Number)

rem

@Support
Field<T> rem(Field<? extends Number> value)

An alias for mod(Field).

See Also:: mod(Field)

pow

@Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> pow(Number exponent)

An arithmetic expression getting this value raised to the power of exponent.

This renders the power operation where available:

[this] ^ [value]

... or the power function elsewhere: power([this], [value])

See Also:: DSL.power(Field, Number)

pow

@Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> pow(Field<? extends Number> exponent)

An arithmetic expression getting this value raised to the power of exponent.

This renders the power operation where available:

[this] ^ [value]

... or the power function elsewhere: power([this], [value])

See Also:: DSL.power(Field, Field)

power

@Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> power(Number exponent)

An alias for power(Number).

See Also:: power(Number)

power

@Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> power(Field<? extends Number> exponent)

An alias for power(Field).

See Also:: power(Field)

bitNot

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitNot()

The bitwise not operator.

See Also:: DSL.bitNot(Field)

bitAnd

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitAnd(T value)

The bitwise and operator.

See Also:: DSL.bitAnd(Field, Field)

bitAnd

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitAnd(Field<T> value)

The bitwise and operator.

See Also:: DSL.bitAnd(Field, Field)

bitNand

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitNand(T value)

The bitwise not and operator.

See Also:: DSL.bitNand(Field, Field), DSL.bitNot(Field)

bitNand

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitNand(Field<T> value)

The bitwise not and operator.

See Also:: DSL.bitNand(Field, Field), DSL.bitNot(Field)

bitOr

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitOr(T value)

The bitwise or operator.

See Also:: DSL.bitOr(Field, Field)

bitOr

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitOr(Field<T> value)

The bitwise or operator.

See Also:: DSL.bitOr(Field, Field)

bitNor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitNor(T value)

The bitwise not or operator.

See Also:: DSL.bitNor(Field, Field), DSL.bitNot(Field)

bitNor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitNor(Field<T> value)

The bitwise not or operator.

See Also:: DSL.bitNor(Field, Field), DSL.bitNot(Field)

bitXor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitXor(T value)

The bitwise xor operator.

See Also:: DSL.bitXor(Field, Field)

bitXor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitXor(Field<T> value)

The bitwise xor operator.

See Also:: DSL.bitXor(Field, Field)

bitXNor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitXNor(T value)

The bitwise not xor operator.

See Also:: DSL.bitXNor(Field, Field), DSL.bitNot(Field)

bitXNor

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> bitXNor(Field<T> value)

The bitwise not xor operator.

See Also:: DSL.bitXNor(Field, Field), DSL.bitNot(Field)

shl

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> shl(Number value)

The bitwise left shift operator.

See Also:: DSL.shl(Field, Field), DSL.power(Field, Number)

shl

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> shl(Field<? extends Number> value)

The bitwise left shift operator.

See Also:: DSL.shl(Field, Field), DSL.power(Field, Number)

shr

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> shr(Number value)

The bitwise right shift operator.

See Also:: DSL.shr(Field, Field), DSL.power(Field, Number)

shr

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<T> shr(Field<? extends Number> value)

The bitwise right shift operator.

See Also:: DSL.shr(Field, Field), DSL.power(Field, Number)

isNull
```
@Support
Condition isNull()
```
Create a condition to check this field against null.
SQL: this is null

isNotNull
```
@Support
Condition isNotNull()
```
Create a condition to check this field against null.
SQL: this is not null

isDistinctFrom

@Support
Condition isDistinctFrom(T value)

Create a condition to check if this field is DISTINCT from another value.

In SQLDialect.MYSQL and SQLDialect.MARIADB, this can be emulated through

not([this] <=> [value])

In SQLDialect.SQLITE, this can be emulated through

[this] IS NOT [value]

In databases that support INTERSECT (see Select.intersect(Select), this predicate can be emulated as follows:

 NOT EXISTS (SELECT [this] INTERSECT SELECT [value])

If this is not supported by the underlying database, jOOQ will render this instead:

 CASE WHEN [this] IS     NULL AND [value] IS     NULL THEN FALSE
      WHEN [this] IS     NULL AND [value] IS NOT NULL THEN TRUE
      WHEN [this] IS NOT NULL AND [value] IS     NULL THEN TRUE
      WHEN [this] =               [value]             THEN FALSE
      ELSE                                                 TRUE
 END

SQL: this is distinct from value

isDistinctFrom

@Support
Condition isDistinctFrom(Field<T> field)

Create a condition to check if this field is DISTINCT from another field.

In SQLDialect.MYSQL and SQLDialect.MARIADB, this can be emulated through

not([this] <=> [value])

In SQLDialect.SQLITE, this can be emulated through

[this] IS NOT [value]

In databases that support INTERSECT (see Select.intersect(Select), this predicate can be emulated as follows:

 NOT EXISTS (SELECT [this] INTERSECT SELECT [value])

If this is not supported by the underlying database, jOOQ will render this instead:

 CASE WHEN [this] IS     NULL AND [field] IS     NULL THEN FALSE
      WHEN [this] IS     NULL AND [field] IS NOT NULL THEN TRUE
      WHEN [this] IS NOT NULL AND [field] IS     NULL THEN TRUE
      WHEN [this] =               [field]             THEN FALSE
      ELSE                                                 TRUE
 END

SQL: this is distinct from field

isNotDistinctFrom

@Support
Condition isNotDistinctFrom(T value)

Create a condition to check if this field is NOT DISTINCT from another value.

In SQLDialect.MYSQL and SQLDialect.MARIADB, this can be emulated through

[this] <=> [value]

In SQLDialect.SQLITE, this can be emulated through

[this] IS [value]

In databases that support INTERSECT (see Select.intersect(Select), this predicate can be emulated as follows:

 EXISTS (SELECT [this] INTERSECT SELECT [value])

If this is not supported by the underlying database, jOOQ will render this instead:

 CASE WHEN [this] IS     NULL AND [value] IS     NULL THEN TRUE
      WHEN [this] IS     NULL AND [value] IS NOT NULL THEN FALSE
      WHEN [this] IS NOT NULL AND [value] IS     NULL THEN FALSE
      WHEN [this] =               [value]             THEN TRUE
      ELSE                                                 FALSE
 END

SQL: this is not distinct from value

isNotDistinctFrom

@Support
Condition isNotDistinctFrom(Field<T> field)

Create a condition to check if this field is NOT DISTINCT from another field.

In SQLDialect.MYSQL and SQLDialect.MARIADB, this can be emulated through

[this] <=> [value]

In SQLDialect.SQLITE, this can be emulated through

[this] IS [value]

In databases that support INTERSECT (see Select.intersect(Select), this predicate can be emulated as follows:

 EXISTS (SELECT [this] INTERSECT SELECT [value])

If this is not supported by the underlying database, jOOQ will render this instead:

 CASE WHEN [this] IS     NULL AND [field] IS     NULL THEN TRUE
      WHEN [this] IS     NULL AND [field] IS NOT NULL THEN FALSE
      WHEN [this] IS NOT NULL AND [field] IS     NULL THEN FALSE
      WHEN [this] =               [value]             THEN TRUE
      ELSE                                                 FALSE
 END

SQL: this is not distinct from field

likeRegex

@Support(value={AURORA_MYSQL,AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE,VERTICA})
Condition likeRegex(String pattern)

Create a condition to regex-pattern-check this field against a pattern.

The SQL:2008 standard specifies a <regex like predicate> of the following form:

 <regex like predicate> ::=
   <row value predicand> <regex like predicate part 2>

 <regex like predicate part 2> ::=
  [ NOT ] LIKE_REGEX <XQuery pattern> [ FLAG <XQuery option flag> ]

This particular LIKE_REGEX operator comes in several flavours for various databases. jOOQ supports regular expressions as follows:

SQL dialect	SQL syntax	Pattern syntax	Documentation
`SQLDialect.ASE`	-	-	-
`SQLDialect.CUBRID`	`[search] REGEXP [pattern]`	POSIX	http://www.cubrid.org/manual/841/en/REGEXP Conditional Expression
`SQLDialect.DB2`	-	-	-
`SQLDialect.DERBY`	-	-	-
`SQLDialect.H2`	`[search] REGEXP [pattern]`	Java	http ://www.h2database.com/html/grammar.html#condition_right_hand_side
`SQLDialect.HSQLDB`	`REGEXP_MATCHES([search], [pattern])`	Java	http://hsqldb.org/doc/guide/builtinfunctions-chapt.html#N13577
`SQLDialect.INGRES`	-	-	-
`SQLDialect.MYSQL`	`[search] REGEXP [pattern]`	POSIX	http://dev .mysql.com/doc/refman/5.6/en/regexp.html
`SQLDialect.ORACLE`	`REGEXP_LIKE([search], [pattern])`	POSIX	http://docs.oracle.com/cd/E14072_01/server.112/e10592/conditions007.htm# sthref1994
`SQLDialect.POSTGRES`	`[search] ~ [pattern]`	POSIX	http://www.postgresql.org/docs/9.1/static/functions-matching.html# FUNCTIONS-POSIX-REGEXP
`SQLDialect.SQLITE`	`[search] REGEXP [pattern]`	? This module has to be loaded explicitly	http://www.sqlite.org/ lang_expr.html
`SQLDialect.SQLSERVER`	-	-	-
`SQLDialect.SYBASE`	`[search] REGEXP [pattern]`	Perl	http://infocenter.sybase.com/help/topic/com.sybase.help.sqlanywhere.12.0 .1/dbreference/like-regexp-similarto.html

See Also:: likeRegex(String)

likeRegex

@Support(value={AURORA_MYSQL,AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE,VERTICA})
Condition likeRegex(Field<String> pattern)

Create a condition to regex-pattern-check this field against a pattern.

See likeRegex(String) for more details

See Also:: likeRegex(String)

notLikeRegex

@Support(value={AURORA_MYSQL,AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE,VERTICA})
Condition notLikeRegex(String pattern)

Create a condition to regex-pattern-check this field against a pattern.

See likeRegex(String) for more details

See Also:: likeRegex(String)

notLikeRegex

@Support(value={AURORA_MYSQL,AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE,VERTICA})
Condition notLikeRegex(Field<String> pattern)

Create a condition to regex-pattern-check this field against a pattern.

See likeRegex(String) for more details

See Also:: likeRegex(Field)

like
```
@Support
LikeEscapeStep like(Field<String> value)
```
Create a condition to pattern-check this field against a value.
SQL: this like value

like

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition like(Field<String> value,
                                                                                                                                                                                                  char escape)

Create a condition to pattern-check this field against a value.

SQL: this like value escape 'e'

See Also:: LikeEscapeStep.escape(char)

like
```
@Support
LikeEscapeStep like(String value)
```
Create a condition to pattern-check this field against a value.
SQL: this like value

like

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition like(String value,
                                                                                                                                                                                                  char escape)

Create a condition to pattern-check this field against a value.

SQL: this like value escape 'e'

See Also:: LikeEscapeStep.escape(char)

likeIgnoreCase
```
@Support
LikeEscapeStep likeIgnoreCase(Field<String> field)
```
Create a condition to case-insensitively pattern-check this field against a field.
This translates to this ilike field in SQLDialect.POSTGRES, or to lower(this) like lower(field) in all other dialects.

likeIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition likeIgnoreCase(Field<String> field,
                                                                                                                                                                                                       char escape)

Create a condition to case-insensitively pattern-check this field against a field.

This translates to this ilike field in SQLDialect.POSTGRES, or to lower(this) like lower(field) in all other dialects.

See Also:: LikeEscapeStep.escape(char)

likeIgnoreCase
```
@Support
LikeEscapeStep likeIgnoreCase(String value)
```
Create a condition to case-insensitively pattern-check this field against a value.
This translates to this ilike value in SQLDialect.POSTGRES, or to lower(this) like lower(value) in all other dialects.

likeIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition likeIgnoreCase(String value,
                                                                                                                                                                                                            char escape)

Create a condition to case-insensitively pattern-check this field against a value.

This translates to this ilike value in SQLDialect.POSTGRES, or to lower(this) like lower(value) in all other dialects.

See Also:: LikeEscapeStep.escape(char)

notLike
```
@Support
LikeEscapeStep notLike(Field<String> field)
```
Create a condition to pattern-check this field against a field.
SQL: this not like field

notLike

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notLike(Field<String> field,
                                                                                                                                                                                                     char escape)

Create a condition to pattern-check this field against a field.

SQL: this not like field escape 'e'

See Also:: LikeEscapeStep.escape(char)

notLike
```
@Support
LikeEscapeStep notLike(String value)
```
Create a condition to pattern-check this field against a value.
SQL: this not like value

notLike

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notLike(String value,
                                                                                                                                                                                                     char escape)

Create a condition to pattern-check this field against a value.

SQL: this not like value escape 'e'

See Also:: LikeEscapeStep.escape(char)

notLikeIgnoreCase
```
@Support
LikeEscapeStep notLikeIgnoreCase(Field<String> field)
```
Create a condition to case-insensitively pattern-check this field against a field.
This translates to this not ilike field in SQLDialect.POSTGRES, or to lower(this) not like lower(field) in all other dialects.

notLikeIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notLikeIgnoreCase(Field<String> field,
                                                                                                                                                                                                          char escape)

Create a condition to case-insensitively pattern-check this field against a field.

This translates to this not ilike field in SQLDialect.POSTGRES, or to lower(this) not like lower(field) in all other dialects.

See Also:: LikeEscapeStep.escape(char)

notLikeIgnoreCase
```
@Support
LikeEscapeStep notLikeIgnoreCase(String value)
```
Create a condition to case-insensitively pattern-check this field against a value.
This translates to this not ilike value in SQLDialect.POSTGRES, or to lower(this) not like lower(value) in all other dialects.

notLikeIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notLikeIgnoreCase(String value,
                                                                                                                                                                                                          char escape)

Create a condition to case-insensitively pattern-check this field against a value.

This translates to this not ilike value in SQLDialect.POSTGRES, or to lower(this) not like lower(value) in all other dialects.

See Also:: LikeEscapeStep.escape(char)

contains
```
@Support
Condition contains(T value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like ('%' || escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance val(1133).contains(13)
If you're using SQLDialect.POSTGRES, then you can use this method also to express the "ARRAY contains" operator. For example:
```
 // Use this expression
 val(new Integer[] { 1, 2, 3 }).contains(new Integer[] { 1, 2 })

 // ... to render this SQL
 ARRAY[1, 2, 3] @> ARRAY[1, 2]
 
```
Note, this does not correspond to the Oracle Text CONTAINS() function. Refer to OracleDSL.contains(Field, String) instead.
See Also:

DSL.escape(String, char), like(String, char)

contains
```
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition contains(Field<T> value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like ('%' || escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance val(1133).contains(13)
If you're using SQLDialect.POSTGRES, then you can use this method also to express the "ARRAY contains" operator. For example:
```
 // Use this expression
 val(new Integer[] { 1, 2, 3 }).contains(new Integer[] { 1, 2 })

 // ... to render this SQL
 ARRAY[1, 2, 3] @> ARRAY[1, 2]
 
```
Note, this does not correspond to the Oracle Text CONTAINS() function. Refer to OracleDSL.contains(Field, String) instead.
See Also:

DSL.escape(Field, char), like(Field, char)

notContains

@Support
Condition notContains(T value)

Inverse of contains(Object).

notContains

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notContains(Field<T> value)

Inverse of contains(Field).

containsIgnoreCase
```
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition containsIgnoreCase(T value)
```
Convenience method for likeIgnoreCase(String, char) including proper adding of wildcards and escaping.
This translates to this ilike ('%' || escape(value, '\') || '%') escape '\' in SQLDialect.POSTGRES, or to lower(this) not like lower(('%' || escape(value, '\') || '%') escape '\') in all other dialects.

See Also:

DSL.escape(Field, char), likeIgnoreCase(String, char), contains(Object)

containsIgnoreCase
```
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition containsIgnoreCase(Field<T> value)
```
Convenience method for likeIgnoreCase(String, char) including proper adding of wildcards and escaping.
This translates to this ilike ('%' || escape(value, '\') || '%') escape '\' in SQLDialect.POSTGRES, or to lower(this) like lower(('%' || escape(value, '\') || '%') escape '\') in all other dialects.

See Also:

DSL.escape(Field, char), likeIgnoreCase(Field, char), contains(Field)

notContainsIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notContainsIgnoreCase(T value)

Inverse of containsIgnoreCase(Object)

notContainsIgnoreCase

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition notContainsIgnoreCase(Field<T> value)

Inverse of containsIgnoreCase(Field)

startsWith
```
@Support
Condition startsWith(T value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like (escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance val(1133).startsWith(11)

See Also:

DSL.escape(String, char), like(String, char)

startsWith
```
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition startsWith(Field<T> value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like (escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance val(1133).startsWith(11)

See Also:

DSL.escape(Field, char), like(Field, char)

endsWith
```
@Support
Condition endsWith(T value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like ('%' || escape(value, '\')) escape '\'
Note: This also works with numbers, for instance val(1133).endsWith(33)

See Also:

DSL.escape(String, char), like(String, char)

endsWith
```
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
Condition endsWith(Field<T> value)
```
Convenience method for like(String, char) including proper adding of wildcards and escaping.
SQL: this like ('%' || escape(value, '\')) escape '\'
Note: This also works with numbers, for instance val(1133).endsWith(33)

See Also:

DSL.escape(Field, char), like(Field, char)

in
```
@Support
Condition in(Collection<?> values)
```
Create a condition to check this field against several values.
SQL: this in (values...)
Note that generating dynamic SQL with arbitrary-length IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- IN predicates on temporary tables
- IN predicates on unnested array bind variables

in
```
Condition in(Result<? extends Record1<T>> result)
```
Create a condition to check this field against several values from a previous query.
SQL: this in (values...)
Note that generating dynamic SQL with arbitrary-length IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- IN predicates on temporary tables
- IN predicates on unnested array bind variables

in
```
@Support
Condition in(T... values)
```
Create a condition to check this field against several values.
SQL: this in (values...)
Note that generating dynamic SQL with arbitrary-length IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- IN predicates on temporary tables
- IN predicates on unnested array bind variables

in
```
@Support
Condition in(Field<?>... values)
```
Create a condition to check this field against several values.
SQL: this in (values...)

in
```
@Support
Condition in(Select<? extends Record1<T>> query)
```
Create a condition to check this field against a subquery.
Note that the subquery must return exactly one field. This is not checked by jOOQ and will result in syntax errors in the database, if not used correctly.
SQL: this in (select...)

notIn
```
@Support
Condition notIn(Collection<?> values)
```
Create a condition to check this field against several values.
Note that if any of the passed values is NULL, then the condition will be NULL (or false, depending on the dialect) as well. This is standard SQL behaviour.
SQL: this not in (values...)
Note that generating dynamic SQL with arbitrary-length NOT IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- NOT IN predicates on temporary tables
- NOT IN predicates on unnested array bind variables

notIn
```
Condition notIn(Result<? extends Record1<T>> result)
```
Create a condition to check this field against several values from a previous query.
Note that if any of the passed values is NULL, then the condition will be NULL (or false, depending on the dialect) as well. This is standard SQL behaviour.
SQL: this in (values...)
Note that generating dynamic SQL with arbitrary-length NOT IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- NOT IN predicates on temporary tables
- NOT IN predicates on unnested array bind variables

notIn
```
@Support
Condition notIn(T... values)
```
Create a condition to check this field against several values.
Note that if any of the passed values is NULL, then the condition will be NULL (or false, depending on the dialect) as well. This is standard SQL behaviour.
SQL: this not in (values...)
Note that generating dynamic SQL with arbitrary-length NOT IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:
- NOT IN predicates on temporary tables
- NOT IN predicates on unnested array bind variables

notIn
```
@Support
Condition notIn(Field<?>... values)
```
Create a condition to check this field against several values.
Note that if any of the passed values is NULL, then the condition will be NULL (or false, depending on the dialect) as well. This is standard SQL behaviour.
SQL: this not in (values...)

notIn
```
@Support
Condition notIn(Select<? extends Record1<T>> query)
```
Create a condition to check this field against a subquery.
Note that the subquery must return exactly one field. This is not checked by jOOQ and will result in syntax errors in the database, if not used correctly.
Note that if any of the passed values is NULL, then the condition will be NULL (or false, depending on the dialect) as well. This is standard SQL behaviour.
SQL: this not in (select...)

between
```
@Support
Condition between(T minValue,
                            T maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling between(minValue).and(maxValue)
SQL: this between minValue and maxValue

between
```
@Support
Condition between(Field<T> minValue,
                            Field<T> maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling between(minValue).and(maxValue)
SQL: this between minValue and maxValue

betweenSymmetric
```
@Support
Condition betweenSymmetric(T minValue,
                                     T maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling betweenSymmetric(minValue).and(maxValue)
SQL: this between symmetric minValue and maxValue

betweenSymmetric
```
@Support
Condition betweenSymmetric(Field<T> minValue,
                                     Field<T> maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling betweenSymmetric(minValue).and(maxValue)
SQL: this between symmetric minValue and maxValue

notBetween
```
@Support
Condition notBetween(T minValue,
                               T maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling notBetween(minValue).and(maxValue)
SQL: this not between minValue and maxValue

notBetween
```
@Support
Condition notBetween(Field<T> minValue,
                               Field<T> maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling notBetween(minValue).and(maxValue)
SQL: this not between minValue and maxValue

notBetweenSymmetric
```
@Support
Condition notBetweenSymmetric(T minValue,
                                        T maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
SQL: this not between symmetric minValue and maxValue

notBetweenSymmetric
```
@Support
Condition notBetweenSymmetric(Field<T> minValue,
                                        Field<T> maxValue)
```
Create a condition to check this field against some bounds.
This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
SQL: this not between symmetric minValue and maxValue

between
```
@Support
BetweenAndStep<T> between(T minValue)
```
Create a condition to check this field against some bounds.
SQL: this between minValue and maxValue

between
```
@Support
BetweenAndStep<T> between(Field<T> minValue)
```
Create a condition to check this field against some bounds.
SQL: this between minValue and maxValue

betweenSymmetric
```
@Support
BetweenAndStep<T> betweenSymmetric(T minValue)
```
Create a condition to check this field against some bounds.
SQL: this between symmetric minValue and maxValue

betweenSymmetric
```
@Support
BetweenAndStep<T> betweenSymmetric(Field<T> minValue)
```
Create a condition to check this field against some bounds.
SQL: this between symmetric minValue and maxValue

notBetween
```
@Support
BetweenAndStep<T> notBetween(T minValue)
```
Create a condition to check this field against some bounds.
SQL: this not between minValue and maxValue

notBetween
```
@Support
BetweenAndStep<T> notBetween(Field<T> minValue)
```
Create a condition to check this field against some bounds.
SQL: this not between minValue and maxValue

notBetweenSymmetric
```
@Support
BetweenAndStep<T> notBetweenSymmetric(T minValue)
```
Create a condition to check this field against some bounds.
SQL: this not between symmetric minValue and maxValue

notBetweenSymmetric
```
@Support
BetweenAndStep<T> notBetweenSymmetric(Field<T> minValue)
```
Create a condition to check this field against some bounds.
SQL: this not between symmetric minValue and maxValue

compare
```
@Support
Condition compare(Comparator comparator,
                            T value)
```
Compare this field with a value using a dynamic comparator.

Parameters:

comparator - The comparator to use for comparing this field with a value

value - The value to compare this field with

Returns:

A comparison predicate

compare
```
@Support
Condition compare(Comparator comparator,
                            Field<T> field)
```
Compare this field with another field using a dynamic comparator.

Parameters:

comparator - The comparator to use for comparing this field with another field

field - The field to compare this field with

Returns:

A comparison predicate

compare
```
@Support
Condition compare(Comparator comparator,
                            Select<? extends Record1<T>> query)
```
Compare this field with a subselect using a dynamic comparator.
Consider Comparator.supportsSubselect() to assess whether a comparator can be used with this method.

Parameters:

comparator - The comparator to use for comparing this field with a subselect

query - The subselect to compare this field with

Returns:

A comparison predicate

compare
```
@Support
Condition compare(Comparator comparator,
                            QuantifiedSelect<? extends Record1<T>> query)
```
Compare this field with a quantified subselect using a dynamic comparator.
Consider Comparator.supportsQuantifier() to assess whether a comparator can be used with this method.

Parameters:

comparator - The comparator to use for comparing this field with a quantified subselect

query - The quantified subselect to compare this field with

Returns:

A comparison predicate

equal
```
@Support
Condition equal(T value)
```
this = value.

equal

@Support
Condition equal(Field<T> field)

this = field.

equal

@Support
Condition equal(Select<? extends Record1<T>> query)

this = (Select<?> ...).

equal

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition equal(QuantifiedSelect<? extends Record1<T>> query)

this = [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

eq
```
@Support
Condition eq(T value)
```
this = value.

See Also:

equal(Object)

eq
```
@Support
Condition eq(Field<T> field)
```
this = field.

See Also:

equal(Field)

eq

@Support
Condition eq(Select<? extends Record1<T>> query)

this = (Select<?> ...).

See Also:: equal(Select)

eq

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition eq(QuantifiedSelect<? extends Record1<T>> query)

this = [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

notEqual
```
@Support
Condition notEqual(T value)
```
this != value.

notEqual

@Support
Condition notEqual(Field<T> field)

this != field.

notEqual

@Support
Condition notEqual(Select<? extends Record1<T>> query)

this != (Select<?> ...).

notEqual

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition notEqual(QuantifiedSelect<? extends Record1<T>> query)

this != [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

ne
```
@Support
Condition ne(T value)
```
this != value.

See Also:

notEqual(Object)

ne
```
@Support
Condition ne(Field<T> field)
```
this != field.

See Also:

notEqual(Field)

ne

@Support
Condition ne(Select<? extends Record1<T>> query)

this != (Select<?> ...).

See Also:: notEqual(Select)

ne

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition ne(QuantifiedSelect<? extends Record1<T>> query)

this != [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

lessThan
```
@Support
Condition lessThan(T value)
```
this < value.

lessThan

@Support
Condition lessThan(Field<T> field)

this < field.

lessThan

@Support
Condition lessThan(Select<? extends Record1<T>> query)

this < (Select<?> ...).

lessThan

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition lessThan(QuantifiedSelect<? extends Record1<T>> query)

this < [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

lt
```
@Support
Condition lt(T value)
```
this < value.

See Also:

lessThan(Object)

lt
```
@Support
Condition lt(Field<T> field)
```
this < field.

See Also:

lessThan(Field)

lt

@Support
Condition lt(Select<? extends Record1<T>> query)

this < (Select<?> ...).

See Also:: lessThan(Select)

lt

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition lt(QuantifiedSelect<? extends Record1<T>> query)

this < [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

lessOrEqual

@Support
Condition lessOrEqual(T value)

this <= value.

lessOrEqual

@Support
Condition lessOrEqual(Field<T> field)

this <= field.

lessOrEqual

@Support
Condition lessOrEqual(Select<? extends Record1<T>> query)

this <= (Select<?> ...).

lessOrEqual

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition lessOrEqual(QuantifiedSelect<? extends Record1<T>> query)

this <= [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

le
```
@Support
Condition le(T value)
```
this <= value.

See Also:

lessOrEqual(Object)

le
```
@Support
Condition le(Field<T> field)
```
this <= field.

See Also:

lessOrEqual(Field)

le

@Support
Condition le(Select<? extends Record1<T>> query)

this <= (Select<?> ...).

See Also:: lessOrEqual(Select)

le

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition le(QuantifiedSelect<? extends Record1<T>> query)

this <= [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

greaterThan

@Support
Condition greaterThan(T value)

this > value.

greaterThan

@Support
Condition greaterThan(Field<T> field)

this > field.

greaterThan

@Support
Condition greaterThan(Select<? extends Record1<T>> query)

this > (Select<?> ...).

greaterThan

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition greaterThan(QuantifiedSelect<? extends Record1<T>> query)

this > [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

gt
```
@Support
Condition gt(T value)
```
this > value.

See Also:

greaterThan(Object)

gt
```
@Support
Condition gt(Field<T> field)
```
this > field.

See Also:

greaterThan(Field)

gt

@Support
Condition gt(Select<? extends Record1<T>> query)

this > (Select<?> ...).

See Also:: greaterThan(Select)

gt

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition gt(QuantifiedSelect<? extends Record1<T>> query)

this > [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

greaterOrEqual

@Support
Condition greaterOrEqual(T value)

this >= value.

greaterOrEqual

@Support
Condition greaterOrEqual(Field<T> field)

this >= field.

greaterOrEqual

@Support
Condition greaterOrEqual(Select<? extends Record1<T>> query)

this >= (Select<?> ...).

greaterOrEqual

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition greaterOrEqual(QuantifiedSelect<? extends Record1<T>> query)

this >= [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

ge
```
@Support
Condition ge(T value)
```
this >= value.

See Also:

greaterOrEqual(Object)

ge
```
@Support
Condition ge(Field<T> field)
```
this >= field.

See Also:

greaterOrEqual(Field)

ge

@Support
Condition ge(Select<? extends Record1<T>> query)

this >= (Select<?> ...).

See Also:: greaterOrEqual(Select)

ge

@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
Condition ge(QuantifiedSelect<? extends Record1<T>> query)

this >= [quantifier] (Select<?> ...).

See Also:: DSL.all(Field), DSL.all(Select), DSL.all(Object...), DSL.any(Field), DSL.any(Select), DSL.any(Object...)

isTrue
```
@Support
Condition isTrue()
```
Create a condition to check this field against known string literals for true.
SQL: lcase(this) in ("1", "y", "yes", "true", "on", "enabled")

isFalse
```
@Support
Condition isFalse()
```
Create a condition to check this field against known string literals for false.
SQL: lcase(this) in ("0", "n", "no", "false", "off", "disabled")

equalIgnoreCase

@Support
Condition equalIgnoreCase(String value)

lower(this) = lower(value).

equalIgnoreCase

@Support
Condition equalIgnoreCase(Field<String> value)

lower(this) = lower(value).

notEqualIgnoreCase

@Support
Condition notEqualIgnoreCase(String value)

lower(this) != lower(value).

notEqualIgnoreCase

@Support
Condition notEqualIgnoreCase(Field<String> value)

lower(this) != lower(value).

sign
```
@Deprecated
 @Support
Field<Integer> sign()
```
Deprecated. - 3.11 - [#7538] - Use DSL.sign(Field) instead.

See Also:

DSL.sign(Field)

abs
```
@Deprecated
 @Support
Field<T> abs()
```
Deprecated. - 3.11 - [#7538] - Use DSL.abs(Field) instead.

See Also:

DSL.abs(Field)

round
```
@Deprecated
 @Support
Field<T> round()
```
Deprecated. - 3.11 - [#7538] - Use DSL.round(Field) instead.

See Also:

DSL.round(Field)

round
```
@Deprecated
 @Support
Field<T> round(int decimals)
```
Deprecated. - 3.11 - [#7538] - Use DSL.round(Field, int) instead.

See Also:

DSL.round(Field, int)

floor
```
@Deprecated
 @Support
Field<T> floor()
```
Deprecated. - 3.11 - [#7538] - Use DSL.floor(Field) instead.

See Also:

DSL.floor(Field)

ceil
```
@Deprecated
 @Support
Field<T> ceil()
```
Deprecated. - 3.11 - [#7538] - Use DSL.ceil(Field) instead.

See Also:

DSL.ceil(Field)

sqrt

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> sqrt()

Deprecated. - 3.11 - [#7538] - Use DSL.sqrt(Field) instead.

See Also:: DSL.sqrt(Field)

exp

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> exp()

Deprecated. - 3.11 - [#7538] - Use DSL.exp(Field) instead.

See Also:: DSL.exp(Field)

ln

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> ln()

Deprecated. - 3.11 - [#7538] - Use DSL.ln(Field) instead.

See Also:: DSL.ln(Field)

log

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> log(int base)

Deprecated. - 3.11 - [#7538] - Use DSL.log(Field, int) instead.

See Also:: DSL.log(Field, int)

acos

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> acos()

Deprecated. - 3.11 - [#7538] - Use DSL.acos(Field) instead.

See Also:: DSL.acos(Field)

asin

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> asin()

Deprecated. - 3.11 - [#7538] - Use DSL.asin(Field) instead.

See Also:: DSL.asin(Field)

atan

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> atan()

Deprecated. - 3.11 - [#7538] - Use DSL.atan(Field) instead.

See Also:: DSL.atan(Field)

atan2

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> atan2(Number y)

Deprecated. - 3.11 - [#7538] - Use DSL.atan2(Field, Number) instead.

See Also:: DSL.atan2(Field, Number)

atan2

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> atan2(Field<? extends Number> y)

Deprecated. - 3.11 - [#7538] - Use DSL.atan2(Field, Field) instead.

See Also:: DSL.atan2(Field, Field)

cos

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> cos()

Deprecated. - 3.11 - [#7538] - Use DSL.cos(Field) instead.

See Also:: DSL.cos(Field)

sin

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> sin()

Deprecated. - 3.11 - [#7538] - Use DSL.sin(Field) instead.

See Also:: DSL.sin(Field)

tan

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> tan()

Deprecated. - 3.11 - [#7538] - Use DSL.tan(Field) instead.

See Also:: DSL.tan(Field)

cot

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> cot()

Deprecated. - 3.11 - [#7538] - Use DSL.cot(Field) instead.

See Also:: DSL.cot(Field)

sinh

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> sinh()

Deprecated. - 3.11 - [#7538] - Use DSL.sinh(Field) instead.

See Also:: DSL.sinh(Field)

cosh

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> cosh()

Deprecated. - 3.11 - [#7538] - Use DSL.cosh(Field) instead.

See Also:: DSL.cosh(Field)

tanh

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> tanh()

Deprecated. - 3.11 - [#7538] - Use DSL.tanh(Field) instead.

See Also:: DSL.tanh(Field)

coth

@Deprecated
 @Support(value={ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> coth()

Deprecated. - 3.11 - [#7538] - Use DSL.coth(Field) instead.

See Also:: DSL.coth(Field)

deg
```
@Deprecated
 @Support
Field<BigDecimal> deg()
```
Deprecated. - 3.11 - [#7538] - Use DSL.deg(Field) instead.

See Also:

DSL.deg(Field)

rad
```
@Deprecated
 @Support
Field<BigDecimal> rad()
```
Deprecated. - 3.11 - [#7538] - Use DSL.rad(Field) instead.

See Also:

DSL.rad(Field)

count
```
@Deprecated
 @Support
Field<Integer> count()
```
Deprecated. - 3.11 - [#7538] - Use DSL.count(Field) instead.

See Also:

DSL.count(Field)

countDistinct
```
@Deprecated
 @Support
Field<Integer> countDistinct()
```
Deprecated. - 3.11 - [#7538] - Use DSL.countDistinct(Field) instead.

See Also:

DSL.countDistinct(Field)

max
```
@Deprecated
 @Support
Field<T> max()
```
Deprecated. - 3.11 - [#7538] - Use DSL.max(Field) instead.

See Also:

DSL.max(Field)

min
```
@Deprecated
 @Support
Field<T> min()
```
Deprecated. - 3.11 - [#7538] - Use DSL.min(Field) instead.

See Also:

DSL.min(Field)

sum
```
@Deprecated
 @Support
Field<BigDecimal> sum()
```
Deprecated. - 3.11 - [#7538] - Use DSL.sum(Field) instead.

See Also:

DSL.sum(Field)

avg
```
@Deprecated
 @Support
Field<BigDecimal> avg()
```
Deprecated. - 3.11 - [#7538] - Use DSL.avg(Field) instead.

See Also:

DSL.avg(Field)

median

@Deprecated
 @Support(value={CUBRID,HSQLDB,ORACLE,SYBASE,TERADATA})
Field<BigDecimal> median()

Deprecated. - 3.11 - [#7538] - Use DSL.median(Field) instead.

See Also:: DSL.median(Field)

stddevPop

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> stddevPop()

Deprecated. - 3.11 - [#7538] - Use DSL.stddevPop(Field) instead.

See Also:: DSL.stddevPop(Field)

stddevSamp

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> stddevSamp()

Deprecated. - 3.11 - [#7538] - Use DSL.stddevSamp(Field) instead.

See Also:: DSL.stddevSamp(Field)

varPop

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> varPop()

Deprecated. - 3.11 - [#7538] - Use DSL.varPop(Field) instead.

See Also:: DSL.varPop(Field)

varSamp

@Deprecated
 @Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
Field<BigDecimal> varSamp()

Deprecated. - 3.11 - [#7538] - Use DSL.varSamp(Field) instead.

See Also:: DSL.varSamp(Field)

countOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<Integer> countOver()

Deprecated. - 3.11 - [#7538] - Use DSL.count(Field) instead.

See Also:: DSL.count(Field), WindowOverStep.over()

maxOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<T> maxOver()

Deprecated. - 3.11 - [#7538] - Use DSL.max(Field) instead.

See Also:: DSL.max(Field), WindowOverStep.over()

minOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<T> minOver()

Deprecated. - 3.11 - [#7538] - Use DSL.min(Field) instead.

See Also:: DSL.min(Field), WindowOverStep.over()

sumOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> sumOver()

Deprecated. - 3.11 - [#7538] - Use DSL.sum(Field) instead.

See Also:: DSL.sum(Field), WindowOverStep.over()

avgOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> avgOver()

Deprecated. - 3.11 - [#7538] - Use DSL.avg(Field) instead.

See Also:: DSL.avg(Field), WindowOverStep.over()

firstValue

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA})
WindowIgnoreNullsStep<T> firstValue()

Deprecated. - 3.11 - [#7538] - Use DSL.firstValue(Field) instead.

See Also:: DSL.firstValue(Field), WindowOverStep.over()

lastValue

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA})
WindowIgnoreNullsStep<T> lastValue()

Deprecated. - 3.11 - [#7538] - Use DSL.lastValue(Field) instead.

See Also:: DSL.lastValue(Field), WindowOverStep.over()

lead

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lead()

Deprecated. - 3.11 - [#7538] - Use DSL.lead(Field) instead.

See Also:: DSL.lead(Field), WindowOverStep.over()

lead

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lead(int offset)

Deprecated. - 3.11 - [#7538] - Use DSL.lead(Field, int) instead.

See Also:: DSL.lead(Field, int), WindowOverStep.over()

lead

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lead(int offset,
                                                                                                                                                            T defaultValue)

Deprecated. - 3.11 - [#7538] - Use DSL.lead(Field, int, Object) instead.

See Also:: DSL.lead(Field, int, Object), WindowOverStep.over()

lead

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lead(int offset,
                                                                                                                                                            Field<T> defaultValue)

Deprecated. - 3.11 - [#7538] - Use DSL.lead(Field, int, Field) instead.

See Also:: DSL.lead(Field, int, Field), WindowOverStep.over()

lag

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lag()

Deprecated. - 3.11 - [#7538] - Use DSL.lag(Field) instead.

See Also:: DSL.lag(Field), WindowOverStep.over()

lag

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lag(int offset)

Deprecated. - 3.11 - [#7538] - Use DSL.lag(Field, int) instead.

See Also:: DSL.lag(Field, int), WindowOverStep.over()

lag

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lag(int offset,
                                                                                                                                                           T defaultValue)

Deprecated. - 3.11 - [#7538] - Use DSL.lag(Field, int, Object) instead.

See Also:: DSL.lag(Field, int, Object), WindowOverStep.over()

lag

@Deprecated
 @Support(value={AURORA_POSTGRES,DB2,FIREBIRD_3_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA,VERTICA})
WindowIgnoreNullsStep<T> lag(int offset,
                                                                                                                                                           Field<T> defaultValue)

Deprecated. - 3.11 - [#7538] - Use DSL.lag(Field, int, Field) instead.

See Also:: DSL.lag(Field, int, Field), WindowOverStep.over()

stddevPopOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> stddevPopOver()

Deprecated. - 3.11 - [#7538] - Use DSL.stddevPop(Field) instead.

See Also:: DSL.stddevPop(Field), WindowOverStep.over()

stddevSampOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> stddevSampOver()

Deprecated. - 3.11 - [#7538] - Use DSL.stddevSamp(Field) instead.

See Also:: DSL.stddevSamp(Field), WindowOverStep.over()

varPopOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> varPopOver()

Deprecated. - 3.11 - [#7538] - Use DSL.varPop(Field) instead.

See Also:: DSL.varPop(Field), WindowOverStep.over()

varSampOver

@Deprecated
 @Support(value={AURORA_POSTGRES,CUBRID,DB2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
WindowPartitionByStep<BigDecimal> varSampOver()

Deprecated. - 3.11 - [#7538] - Use DSL.varSamp(Field) instead.

See Also:: DSL.varSamp(Field), WindowOverStep.over()

upper
```
@Support
Field<String> upper()
```
This method is part of the pre-2.0 API. This API is maintained for backwards-compatibility. It may be removed in the future. Consider using equivalent methods from DSLContext

See Also:

DSL.upper(Field)

lower
```
@Support
Field<String> lower()
```
This method is part of the pre-2.0 API. This API is maintained for backwards-compatibility. It may be removed in the future. Consider using equivalent methods from DSLContext

See Also:

DSL.lower(Field)

trim
```
@Support
Field<String> trim()
```
This method is part of the pre-2.0 API. This API is maintained for backwards-compatibility. It may be removed in the future. Consider using equivalent methods from DSLContext

See Also:

DSL.trim(Field)

rtrim
```
@Support
Field<String> rtrim()
```
This method is part of the pre-2.0 API. This API is maintained for backwards-compatibility. It may be removed in the future. Consider using equivalent methods from DSLContext

See Also:

DSL.rtrim(Field)

ltrim
```
@Support
Field<String> ltrim()
```
This method is part of the pre-2.0 API. This API is maintained for backwards-compatibility. It may be removed in the future. Consider using equivalent methods from DSLContext

See Also:

DSL.ltrim(Field)