Condition 
Condition.and(Condition other)
Combine this condition with another one using the Operator.AND
operator.

Condition 
BetweenAndStep.and(Field<T> field)
Create a condition to check this field against some bounds

Condition 
Condition.and(String sql)
Combine this condition with another one using the Operator.AND
operator.

Condition 
Condition.and(String sql,
Object... bindings)
Combine this condition with another one using the Operator.AND
operator.

Condition 
Condition.and(String sql,
QueryPart... parts)
Combine this condition with another one using the Operator.AND
operator.

Condition 
BetweenAndStep.and(T value)
Create a condition to check this field against some bounds

Condition 
Condition.andExists(Select<?> select)
Combine this condition with an EXISTS clause using the
Operator.AND operator.

Condition 
Condition.andNot(Condition other)
Combine this condition with a negated other one using the
Operator.AND operator.

Condition 
Condition.andNotExists(Select<?> select)
Combine this condition with a NOT EXIST clause using the
Operator.AND operator.

Condition 
Field.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

Condition 
Field.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

Condition 
Field.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

Condition 
Field.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

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

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

Condition 
Field.contains(Field<T> value)
Convenience method for Field.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.

Condition 
Field.contains(T value)
Convenience method for Field.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.

Condition 
Field.endsWith(Field<T> value)
Convenience method for Field.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)

Condition 
Field.endsWith(T value)
Convenience method for Field.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)

Condition 
RowN.eq(Field<?>... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

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

Condition 
Row1.eq(Field<T1> t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.eq(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
RowN.eq(Object... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row1.eq(Row1<T1> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.eq(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.eq(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.eq(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.eq(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.eq(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.eq(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.eq(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
RowN.eq(RowN row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Field.eq(Select<?> query)
this = (Select

Condition 
Field.eq(T value)
this = value
If value == null , then this will return a condition
equivalent to Field.isNull() for convenience.

Condition 
Row1.eq(T1 t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.eq(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.eq(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
RowN.equal(Field<?>... fields)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Field.equal(Field<T> field)
this = field

Condition 
Row1.equal(Field<T1> t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.equal(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
RowN.equal(Object... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row1.equal(Row1<T1> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.equal(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.equal(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.equal(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.equal(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.equal(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.equal(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.equal(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
RowN.equal(RowN row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Field.equal(Select<?> query)
this = (Select

Condition 
Field.equal(T value)
this = value
If value == null , then this will return a condition
equivalent to Field.isNull() for convenience.

Condition 
Row1.equal(T1 t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row2.equal(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row3.equal(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row4.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row5.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row6.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row7.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Row8.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2

Condition 
Field.equalAll(Field<T[]> array)

Condition 
Field.equalAll(Select<?> query)
this = all (Select

Condition 
Field.equalAll(T... array)

Condition 
Field.equalAny(Field<T[]> array)

Condition 
Field.equalAny(Select<?> query)
this = any (Select

Condition 
Field.equalAny(T... array)

Condition 
Field.equalIgnoreCase(Field<String> value)
lower(this) = lower(value)

Condition 
Field.equalIgnoreCase(String value)
lower(this) = lower(value)

Condition 
Field.equalSome(Select<?> query)

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

Condition 
Field.ge(Select<?> query)
this >= (Select

Condition 
Field.ge(T value)
this >= value

Condition 
Field.greaterOrEqual(Field<T> field)
this >= field

Condition 
Field.greaterOrEqual(Select<?> query)
this >= (Select

Condition 
Field.greaterOrEqual(T value)
this >= value

Condition 
Field.greaterOrEqualAll(Field<T[]> array)

Condition 
Field.greaterOrEqualAll(Select<?> query)
this >= all (Select

Condition 
Field.greaterOrEqualAll(T... array)

Condition 
Field.greaterOrEqualAny(Field<T[]> array)

Condition 
Field.greaterOrEqualAny(Select<?> query)
this >= any (Select

Condition 
Field.greaterOrEqualAny(T... array)

Condition 
Field.greaterOrEqualSome(Select<?> query)

Condition 
Field.greaterThan(Field<T> field)
this > field

Condition 
Field.greaterThan(Select<?> query)
this > (Select

Condition 
Field.greaterThan(T value)
this > value

Condition 
Field.greaterThanAll(Field<T[]> array)

Condition 
Field.greaterThanAll(Select<?> query)
this > all (Select

Condition 
Field.greaterThanAll(T... array)

Condition 
Field.greaterThanAny(Field<T[]> array)

Condition 
Field.greaterThanAny(Select<?> query)
this > any (Select

Condition 
Field.greaterThanAny(T... array)

Condition 
Field.greaterThanSome(Select<?> query)

Condition 
Field.gt(Field<T> field)
this > field

Condition 
Field.gt(Select<?> query)
this > (Select

Condition 
Field.gt(T value)
this > value

Condition 
Row1.in(Collection<? extends Row1<T1>> row)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row2.in(Collection<? extends Row2<T1,T2>> rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row3.in(Collection<? extends Row3<T1,T2,T3>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row4.in(Collection<? extends Row4<T1,T2,T3,T4>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row5.in(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row6.in(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row7.in(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row8.in(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
RowN.in(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Field.in(Collection<T> values)
Create a condition to check this field against several values
SQL: this in (values...)

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

Condition 
Row1.in(Row1<T1>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row2.in(Row2<T1,T2>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row3.in(Row3<T1,T2,T3>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row4.in(Row4<T1,T2,T3,T4>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row5.in(Row5<T1,T2,T3,T4,T5>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row6.in(Row6<T1,T2,T3,T4,T5,T6>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row7.in(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row8.in(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
RowN.in(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition 
Row.in(Select<?> select)
Compare this row value expression with a subselect for equality
Note that the subquery must return a table of the same degree as this row
value expression.

Condition 
Field.in(Select<?> query)
Create a condition to check this field against a subquery
Note that the subquery must return exactly one field.

Condition 
Field.in(T... values)
Create a condition to check this field against several values
SQL: this in (values...)

Condition 
Field.isDistinctFrom(Field<T> field)
Create a condition to check if this field is DISTINCT from
another field
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

Condition 
Field.isDistinctFrom(T value)
Create a condition to check if this field is DISTINCT from
another 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

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

Condition 
Field.isNotDistinctFrom(Field<T> field)
Create a condition to check if this field is NOT DISTINCT
from another field
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

Condition 
Field.isNotDistinctFrom(T value)
Create a condition to check if this field is NOT DISTINCT
from another 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

Condition 
Field.isNotNull()
Create a condition to check this field against null .

Condition 
Field.isNull()
Create a condition to check this field against null .

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

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

Condition 
Field.le(Select<?> query)
this <= (Select

Condition 
Field.le(T value)
this <= value

Condition 
Field.lessOrEqual(Field<T> field)
this <= field

Condition 
Field.lessOrEqual(Select<?> query)
this <= (Select

Condition 
Field.lessOrEqual(T value)
this <= value

Condition 
Field.lessOrEqualAll(Field<T[]> array)

Condition 
Field.lessOrEqualAll(Select<?> query)
this <= all (Select

Condition 
Field.lessOrEqualAll(T... array)

Condition 
Field.lessOrEqualAny(Field<T[]> array)

Condition 
Field.lessOrEqualAny(Select<?> query)
this <= any (Select

Condition 
Field.lessOrEqualAny(T... array)

Condition 
Field.lessOrEqualSome(Select<?> query)

Condition 
Field.lessThan(Field<T> field)
this < field

Condition 
Field.lessThan(Select<?> query)
this < (Select

Condition 
Field.lessThan(T value)
this < value

Condition 
Field.lessThanAll(Field<T[]> array)

Condition 
Field.lessThanAll(Select<?> query)
this < all (Select

Condition 
Field.lessThanAll(T... array)

Condition 
Field.lessThanAny(Field<T[]> array)

Condition 
Field.lessThanAny(Select<?> query)
this < any (Select

Condition 
Field.lessThanAny(T... array)

Condition 
Field.lessThanSome(Select<?> query)

Condition 
Field.like(Field<String> value)
Create a condition to patterncheck this field against a value
SQL: this like value

Condition 
Field.like(Field<String> value,
char escape)
Create a condition to patterncheck this field against a value
SQL: this like value escape 'e'

Condition 
Field.like(String value)
Create a condition to patterncheck this field against a value
SQL: this like value

Condition 
Field.like(String value,
char escape)
Create a condition to patterncheck this field against a value
SQL: this like value escape 'e'

Condition 
Field.likeIgnoreCase(Field<String> field)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.likeIgnoreCase(Field<String> field,
char escape)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.likeIgnoreCase(String value)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.likeIgnoreCase(String value,
char escape)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.likeRegex(Field<String> pattern)
Create a condition to regexpatterncheck this field against a pattern
See Field.likeRegex(String) for more details

Condition 
Field.likeRegex(String pattern)
Create a condition to regexpatterncheck 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 ExpressionSQLDialect.DB2



SQLDialect.DERBY



SQLDialect.H2 [search] REGEXP [pattern]
Java
http
://www.h2database.com/html/grammar.html#condition_right_hand_sideSQLDialect.HSQLDB REGEXP_MATCHES([search], [pattern])
Java
http://hsqldb.org/doc/guide/builtinfunctionschapt.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/functionsmatching.html#
FUNCTIONSPOSIXREGEXP
SQLDialect.SQLITE
[search] REGEXP [pattern]
?
Condition 
Field.lt(Field<T> field)
this < field

Condition 
Field.lt(Select<?> query)
this < (Select

Condition 
Field.lt(T value)
this < value

Condition 
RowN.ne(Field<?>... values)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Field.ne(Field<T> field)
this !

Condition 
Row1.ne(Field<T1> t1)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.ne(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
RowN.ne(Object... values)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row1.ne(Row1<T1> row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.ne(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.ne(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.ne(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.ne(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.ne(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.ne(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.ne(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
RowN.ne(RowN row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Field.ne(Select<?> query)
this !

Condition 
Field.ne(T value)
this !

Condition 
Row1.ne(T1 t1)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.ne(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.ne(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Condition.not()

Condition 
Field.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

Condition 
Field.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

Condition 
Field.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

Condition 
Field.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

Condition 
RowN.notEqual(Field<?>... values)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Field.notEqual(Field<T> field)
this !

Condition 
Row1.notEqual(Field<T1> t1)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.notEqual(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
RowN.notEqual(Object... values)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row1.notEqual(Row1<T1> row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.notEqual(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.notEqual(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.notEqual(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.notEqual(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.notEqual(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.notEqual(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.notEqual(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
RowN.notEqual(RowN row)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Field.notEqual(Select<?> query)
this !

Condition 
Field.notEqual(T value)
this !

Condition 
Row1.notEqual(T1 t1)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row2.notEqual(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row3.notEqual(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row4.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row5.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row6.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row7.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Row8.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for nonequality
Row nonequality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)

Condition 
Field.notEqualAll(Field<T[]> array)
this !

Condition 
Field.notEqualAll(Select<?> query)
this !

Condition 
Field.notEqualAll(T... array)
this !

Condition 
Field.notEqualAny(Field<T[]> array)
this !

Condition 
Field.notEqualAny(Select<?> query)
this !

Condition 
Field.notEqualAny(T... array)
this !

Condition 
Field.notEqualIgnoreCase(Field<String> value)
lower(this) !

Condition 
Field.notEqualIgnoreCase(String value)
lower(this) !

Condition 
Field.notEqualSome(Select<?> query)

Condition 
Row1.notIn(Collection<? extends Row1<T1>> row)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row2.notIn(Collection<? extends Row2<T1,T2>> rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row3.notIn(Collection<? extends Row3<T1,T2,T3>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row4.notIn(Collection<? extends Row4<T1,T2,T3,T4>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row5.notIn(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row6.notIn(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row7.notIn(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row8.notIn(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
RowN.notIn(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Field.notIn(Collection<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.

Condition 
Field.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.

Condition 
Row1.notIn(Row1<T1>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row2.notIn(Row2<T1,T2>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row3.notIn(Row3<T1,T2,T3>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row4.notIn(Row4<T1,T2,T3,T4>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row5.notIn(Row5<T1,T2,T3,T4,T5>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row6.notIn(Row6<T1,T2,T3,T4,T5,T6>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row7.notIn(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row8.notIn(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
RowN.notIn(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))

Condition 
Row.notIn(Select<?> select)
Compare this row value expression with a subselect for nonequality
Note that the subquery must return a table of the same degree as this row
value expression.

Condition 
Field.notIn(Select<?> query)
Create a condition to check this field against a subquery
Note that the subquery must return exactly one field.

Condition 
Field.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.

Condition 
Field.notLike(Field<String> field)
Create a condition to patterncheck this field against a field
SQL: this not like field

Condition 
Field.notLike(Field<String> field,
char escape)
Create a condition to patterncheck this field against a field
SQL: this not like field escape 'e'

Condition 
Field.notLike(String value)
Create a condition to patterncheck this field against a value
SQL: this not like value

Condition 
Field.notLike(String value,
char escape)
Create a condition to patterncheck this field against a value
SQL: this not like value escape 'e'

Condition 
Field.notLikeIgnoreCase(Field<String> field)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.notLikeIgnoreCase(Field<String> field,
char escape)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.notLikeIgnoreCase(String value)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.notLikeIgnoreCase(String value,
char escape)
Create a condition to caseinsensitively patterncheck 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.

Condition 
Field.notLikeRegex(Field<String> pattern)
Create a condition to regexpatterncheck this field against a pattern
See Field.likeRegex(String) for more details

Condition 
Field.notLikeRegex(String pattern)
Create a condition to regexpatterncheck this field against a pattern
See Field.likeRegex(String) for more details

Condition 
Condition.or(Condition other)
Combine this condition with another one using the Operator.OR
operator.

Condition 
Condition.or(String sql)
Combine this condition with another one using the Operator.OR
operator.

Condition 
Condition.or(String sql,
Object... bindings)
Combine this condition with another one using the Operator.OR
operator.

Condition 
Condition.or(String sql,
QueryPart... parts)
Combine this condition with another one using the Operator.OR
operator.

Condition 
Condition.orExists(Select<?> select)
Combine this condition with an EXISTS clause using the
Operator.OR operator.

Condition 
Condition.orNot(Condition other)
Combine this condition with a negated other one using the
Operator.OR operator.

Condition 
Condition.orNotExists(Select<?> select)
Combine this condition with a NOT EXIST clause using the
Operator.OR operator.

Condition 
Row2.overlaps(Field<T1> t1,
Field<T2> t2)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2degree row value expression comparisons,
by simulating them as such
 This predicate
(A, B) OVERLAPS (C, D)
 can be simulated as such
(C <= B) AND (A <= D)

Condition 
Row2.overlaps(Row2<T1,T2> row)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2degree row value expression comparisons,
by simulating them as such
 This predicate
(A, B) OVERLAPS (C, D)
 can be simulated as such
(C <= B) AND (A <= D)

Condition 
Row2.overlaps(T1 t1,
T2 t2)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2degree row value expression comparisons,
by simulating them as such
 This predicate
(A, B) OVERLAPS (C, D)
 can be simulated as such
(C <= B) AND (A <= D)

Condition 
Field.startsWith(Field<T> value)
Convenience method for Field.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)

Condition 
Field.startsWith(T value)
Convenience method for Field.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)

Methods in org.jooq with parameters of type Condition
Modifier and Type 
Method and Description 
void 
UpdateQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
SimpleSelectQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
SelectQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
DeleteQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
ConditionProvider.addConditions(Condition... conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
UpdateQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SimpleSelectQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SelectQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
DeleteQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
ConditionProvider.addConditions(Operator operator,
Condition... conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SelectQuery.addConnectBy(Condition condition)
Add an Oraclespecific CONNECT BY clause to the query

void 
SelectQuery.addConnectByNoCycle(Condition condition)
Add an Oraclespecific CONNECT BY NOCYCLE clause to the
query

void 
SelectQuery.addHaving(Condition... conditions)
Adds new conditions to the having clause of the query, connecting it to
existing conditions with the and operator.

void 
SelectQuery.addHaving(Operator operator,
Condition... conditions)
Adds new conditions to the having clause of query, connecting them to
existing conditions with the provided operator

void 
SelectQuery.addJoin(TableLike<?> table,
Condition... conditions)
Joins the existing table product to a new table using a condition

void 
SelectQuery.addJoin(TableLike<?> table,
JoinType type,
Condition... conditions)
Joins the existing table product to a new table using a condition

void 
SelectQuery.addJoin(TableLike<?> table,
JoinType type,
Condition[] conditions,
Field<?>[] partitionBy)
Joins the existing table product to a new table using a condition
This adds a PARTITION BY clause to the right hand side of a
OUTER JOIN expression.

UpdateConditionStep<R> 
UpdateConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator

TableOnConditionStep 
TableOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator.

SimpleSelectConditionStep<R> 
SimpleSelectConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

SelectOnConditionStep 
SelectOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

SelectHavingConditionStep 
SelectHavingConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

SelectConnectByConditionStep 
SelectConnectByConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

SelectConditionStep 
SelectConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R> 
MergeOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.

DivideByOnConditionStep 
DivideByOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator.

DeleteConditionStep<R> 
DeleteConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator

Condition 
Condition.and(Condition other)
Combine this condition with another one using the Operator.AND
operator.

UpdateConditionStep<R> 
UpdateConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator

TableOnConditionStep 
TableOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator.

SimpleSelectConditionStep<R> 
SimpleSelectConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.

SelectOnConditionStep 
SelectOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep 
SelectHavingConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.

SelectConditionStep 
SelectConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R> 
MergeOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep 
DivideByOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator.

DeleteConditionStep<R> 
DeleteConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator

Condition 
Condition.andNot(Condition other)
Combine this condition with a negated other one using the
Operator.AND operator.

SelectConnectByConditionStep 
SelectConnectByStep.connectBy(Condition condition)
Add an Oraclespecific CONNECT BY clause to the query

SelectConnectByConditionStep 
SelectConnectByStep.connectByNoCycle(Condition condition)
Add an Oraclespecific CONNECT BY NOCYCLE clause to the
query

MergeNotMatchedStep<R> 
MergeMatchedDeleteStep.deleteWhere(Condition condition)
Add an additional DELETE WHERE clause to the preceding
WHEN MATCHED THEN UPDATE clause.

<R extends TableRecord<R>,T> int 
FactoryOperations.executeDelete(R record,
Condition condition)
Delete a record from a table
DELETE FROM [table] WHERE [condition]

<R extends TableRecord<R>,T> int 
FactoryOperations.executeDelete(Table<R> table,
Condition condition)

<R extends TableRecord<R>,T> int 
FactoryOperations.executeDeleteOne(Table<R> table,
Condition condition)

<R extends TableRecord<R>,T> int 
FactoryOperations.executeUpdate(R record,
Condition condition)
Update a table
UPDATE [table] SET [modified values in record] WHERE [condition]

<R extends TableRecord<R>,T> int 
FactoryOperations.executeUpdate(Table<R> table,
R record,
Condition condition)

<R extends TableRecord<R>,T> int 
FactoryOperations.executeUpdateOne(Table<R> table,
R record,
Condition condition)

<R extends Record> Result<R> 
FactoryOperations.fetch(Table<R> table,
Condition condition)
Execute and return all records for
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default.

<R extends Record> R 
FactoryOperations.fetchOne(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition]
The resulting record is attached to this Configuration by
default.

SelectHavingConditionStep 
SelectHavingStep.having(Condition... conditions)
Add a HAVING clause to the query

TableOnConditionStep 
TableOnStep.on(Condition... conditions)
Add an ON clause to the JOIN

SelectOnConditionStep 
SelectOnStep.on(Condition... conditions)
Add an ON clause to the previous JOIN

MergeOnConditionStep<R> 
MergeOnStep.on(Condition... conditions)
Provide join conditions and proceed to the next step

DivideByOnConditionStep 
DivideByOnStep.on(Condition... conditions)
Add a division condition to the DIVIDE BY clause

UpdateConditionStep<R> 
UpdateConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator

TableOnConditionStep 
TableOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator.

SimpleSelectConditionStep<R> 
SimpleSelectConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.

SelectOnConditionStep 
SelectOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.

SelectHavingConditionStep 
SelectHavingConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.

SelectConditionStep 
SelectConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.

MergeOnConditionStep<R> 
MergeOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.

DivideByOnConditionStep 
DivideByOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator.

DeleteConditionStep<R> 
DeleteConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator

Condition 
Condition.or(Condition other)
Combine this condition with another one using the Operator.OR
operator.

UpdateConditionStep<R> 
UpdateConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator

TableOnConditionStep 
TableOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator.

SimpleSelectConditionStep<R> 
SimpleSelectConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.

SelectOnConditionStep 
SelectOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.

SelectHavingConditionStep 
SelectHavingConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.

SelectConditionStep 
SelectConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.

MergeOnConditionStep<R> 
MergeOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.

DivideByOnConditionStep 
DivideByOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator.

DeleteConditionStep<R> 
DeleteConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator

Condition 
Condition.orNot(Condition other)
Combine this condition with a negated other one using the
Operator.OR operator.

void 
SelectQuery.setConnectByStartWith(Condition condition)
Add an Oraclespecific START WITH clause to the query's
CONNECT BY clause

SelectGroupByStep 
SelectStartWithStep.startWith(Condition condition)
Add an Oraclespecific START WITH clause to the query's
CONNECT BY clause

CaseConditionStep<T> 
CaseConditionStep.when(Condition condition,
Field<T> result)
Compare a condition to the already constructed case statement, return
result if the condition holds true

<T> CaseConditionStep<T> 
Case.when(Condition condition,
Field<T> result)
This construct can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Instances of Case are created through the

CaseConditionStep<T> 
CaseConditionStep.when(Condition condition,
T result)
Compare a condition to the already constructed case statement, return
result if the condition holds true

<T> CaseConditionStep<T> 
Case.when(Condition condition,
T result)
This construct can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Instances of Case are created through the

UpdateConditionStep<R> 
UpdateWhereStep.where(Condition... conditions)
Add conditions to the query

SimpleSelectConditionStep<R> 
SimpleSelectWhereStep.where(Condition... conditions)
Add a WHERE clause to the query

SelectConditionStep 
SelectWhereStep.where(Condition... conditions)
Add a WHERE clause to the query

DeleteConditionStep<R> 
DeleteWhereStep.where(Condition... conditions)
Add conditions to the query

MergeFinalStep<R> 
MergeNotMatchedWhereStep.where(Condition condition)
Add an additional WHERE clause to the preceding
WHEN NOT MATCHED THEN INSERT clause.

MergeMatchedDeleteStep<R> 
MergeMatchedWhereStep.where(Condition condition)
Add an additional WHERE clause to the preceding
WHEN MATCHED THEN UPDATE clause.

Method parameters in org.jooq with type arguments of type Condition
Modifier and Type 
Method and Description 
void 
UpdateQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
SimpleSelectQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
SelectQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
DeleteQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
ConditionProvider.addConditions(Collection<Condition> conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND

void 
UpdateQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SimpleSelectQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SelectQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
DeleteQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
ConditionProvider.addConditions(Operator operator,
Collection<Condition> conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with the provided operator

void 
SelectQuery.addHaving(Collection<Condition> conditions)
Adds new conditions to the having clause of the query, connecting it to
existing conditions with the and operator.

void 
SelectQuery.addHaving(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the having clause of query, connecting them to
existing conditions with the provided operator

SelectHavingConditionStep 
SelectHavingStep.having(Collection<Condition> conditions)
Add a HAVING clause to the query

UpdateConditionStep<R> 
UpdateWhereStep.where(Collection<Condition> conditions)
Add conditions to the query

SimpleSelectConditionStep<R> 
SimpleSelectWhereStep.where(Collection<Condition> conditions)
Add a WHERE clause to the query

SelectConditionStep 
SelectWhereStep.where(Collection<Condition> conditions)
Add a WHERE clause to the query

DeleteConditionStep<R> 
DeleteWhereStep.where(Collection<Condition> conditions)
Add conditions to the query

Methods in org.jooq.impl with parameters of type Condition
Modifier and Type 
Method and Description 
<R extends TableRecord<R>,T> int 
FactoryProxy.executeDelete(R record,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeDelete(R record,
Condition condition)
Delete a record from a table
DELETE FROM [table] WHERE [condition]

<R extends TableRecord<R>,T> int 
FactoryProxy.executeDelete(Table<R> table,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeDelete(Table<R> table,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
FactoryProxy.executeDeleteOne(Table<R> table,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeDeleteOne(Table<R> table,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
FactoryProxy.executeUpdate(R record,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeUpdate(R record,
Condition condition)
Update a table
UPDATE [table] SET [modified values in record] WHERE [condition]

<R extends TableRecord<R>,T> int 
FactoryProxy.executeUpdate(Table<R> table,
R record,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeUpdate(Table<R> table,
R record,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
FactoryProxy.executeUpdateOne(Table<R> table,
R record,
Condition condition)
Deprecated.

<R extends TableRecord<R>,T> int 
Factory.executeUpdateOne(Table<R> table,
R record,
Condition condition)
Deprecated.

<R extends Record> Result<R> 
FactoryProxy.fetch(Table<R> table,
Condition condition)
Deprecated.

<R extends Record> Result<R> 
Factory.fetch(Table<R> table,
Condition condition)
Execute and return all records for
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default.

<R extends Record> R 
FactoryProxy.fetchOne(Table<R> table,
Condition condition)
Deprecated.

<R extends Record> R 
Factory.fetchOne(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition]
The resulting record is attached to this Configuration by
default.

static Condition 
Factory.not(Condition condition)
Invert a condition
This is the same as calling not()

Copyright © 2013. All Rights Reserved.
