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 pattern-check this field against a value
SQL: this like value
|
Condition |
Field.like(Field<String> value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this like value escape 'e'
|
Condition |
Field.like(String value)
Create a condition to pattern-check this field against a value
SQL: this like value
|
Condition |
Field.like(String value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this like value escape 'e'
|
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.likeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See Field.likeRegex(String) for more details |
Condition |
Field.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]
?
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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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
non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
Row non-equality 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 non-equality
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 pattern-check this field against a field
SQL: this not like field
|
Condition |
Field.notLike(Field<String> field,
char escape)
Create a condition to pattern-check this field against a field
SQL: this not like field escape 'e'
|
Condition |
Field.notLike(String value)
Create a condition to pattern-check this field against a value
SQL: this not like value
|
Condition |
Field.notLike(String value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this not like value escape 'e'
|
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.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. |
Condition |
Field.notLikeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See Field.likeRegex(String) for more details |
Condition |
Field.notLikeRegex(String pattern)
Create a condition to regex-pattern-check 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 2-degree 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 2-degree 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 2-degree 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 Oracle-specific CONNECT BY clause to the query
|
void |
SelectQuery.addConnectByNoCycle(Condition condition)
Add an Oracle-specific 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 Oracle-specific CONNECT BY clause to the query
|
SelectConnectByConditionStep |
SelectConnectByStep.connectByNoCycle(Condition condition)
Add an Oracle-specific 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 Oracle-specific START WITH clause to the query's
CONNECT BY clause
|
SelectGroupByStep |
SelectStartWithStep.startWith(Condition condition)
Add an Oracle-specific 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.
|