Module org.jooq
Package org.jooq

Interface Condition

All Superinterfaces:
QueryPart, Serializable
All Known Subinterfaces:
False, JSONExistsOnStep, LikeEscapeStep, QOM.And, QOM.CombinedCondition, QOM.CompareCondition<T>, QOM.Contains<T>, QOM.ContainsIgnoreCase<T>, QOM.Deleting, QOM.EndsWith<T>, QOM.EndsWithIgnoreCase<T>, QOM.Eq<T>, QOM.Exists, QOM.FieldCondition, QOM.Ge<T>, QOM.Gt<T>, QOM.In<T>, QOM.InList<T>, QOM.Inserting, QOM.IsDistinctFrom<T>, QOM.IsDocument, QOM.IsJson, QOM.IsNotDistinctFrom<T>, QOM.IsNotDocument, QOM.IsNotJson, QOM.IsNotNull, QOM.IsNull, QOM.Le<T>, QOM.Like, QOM.LikeIgnoreCase, QOM.Lt<T>, QOM.Ne<T>, QOM.Not, QOM.NotIn<T>, QOM.NotInList<T>, QOM.NotLike, QOM.NotLikeIgnoreCase, QOM.NotSimilarTo, QOM.Or, QOM.RegexpLike, QOM.RowIsNotNull, QOM.RowIsNull, QOM.RowOverlaps, QOM.SelectIsNotNull, QOM.SelectIsNull, QOM.SimilarTo, QOM.StartsWith<T>, QOM.StartsWithIgnoreCase<T>, QOM.StContains<T>, QOM.StCrosses, QOM.StDisjoint<T>, QOM.StEquals<T>, QOM.StIntersects<T>, QOM.StIsClosed, QOM.StIsEmpty, QOM.StOverlaps<T>, QOM.StTouches<T>, QOM.StWithin<T>, QOM.TableEq<R>, QOM.TableNe<R>, QOM.Unique, QOM.Updating, QOM.XMLExists, True
All Known Implementing Classes:
CustomCondition

public interface Condition extends QueryPart
A condition or predicate.

Conditions can be used in a variety of SQL clauses. They're mainly used in a Select statement's WHERE clause, but can also appear in (non-exhaustive list):

Example:

 // Assuming import static org.jooq.impl.DSL.*;

 using(configuration)
    .select()
    .from(ACTOR)
    .where(ACTOR.ACTOR_ID.eq(1)) // The eq operator produces a Condition from two Fields
    .fetch();
 

Instances can be created using DSL.condition(Field) and overloads, or by calling a comparison operator method on Field, such as Field.eq(Field).

Author:
Lukas Eder
  • Method Details

    • and

      @NotNull @Support @NotNull Condition and(Field<Boolean> other)
      Combine this condition with another one using the Operator.AND operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • and

      @NotNull @Support @PlainSQL @NotNull Condition and(SQL sql)
      Combine this condition with another one using the Operator.AND operator.

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      Returns:
      The combined condition
      See Also:
      DSL.condition(SQL), SQL
    • and

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      Returns:
      The combined condition
      See Also:
      DSL.condition(String), SQL
    • and

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      bindings - The bindings
      Returns:
      The combined condition
      See Also:
      DSL.condition(String, Object...), DSL.sql(String, Object...), SQL
    • and

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The SQL clause, containing {numbered placeholders} where query parts can be injected
      parts - The QueryPart objects that are rendered at the {numbered placeholder} locations
      Returns:
      The combined condition
      See Also:
      DSL.condition(String, QueryPart...), DSL.sql(String, QueryPart...), SQL
    • andNot

      @NotNull @Support @NotNull Condition andNot(Condition other)
      Combine this condition with a negated other one using the Operator.AND operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • andNot

      @NotNull @Support @NotNull Condition andNot(Field<Boolean> other)
      Combine this condition with a negated other one using the Operator.AND operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • andExists

      @NotNull @Support @NotNull Condition andExists(Select<?> select)
      Combine this condition with an EXISTS clause using the Operator.AND operator.
      Parameters:
      select - The EXISTS's subquery
      Returns:
      The combined condition
    • andNotExists

      @NotNull @Support @NotNull Condition andNotExists(Select<?> select)
      Combine this condition with a NOT EXIST clause using the Operator.AND operator.
      Parameters:
      select - The EXISTS's subquery
      Returns:
      The combined condition
    • or

      @NotNull @Support @NotNull Condition or(Field<Boolean> other)
      Combine this condition with another one using the Operator.OR operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • or

      @NotNull @Support @PlainSQL @NotNull Condition or(SQL sql)
      Combine this condition with another one using the Operator.OR operator.

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      Returns:
      The combined condition
      See Also:
      DSL.condition(SQL), SQL
    • or

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      Returns:
      The combined condition
      See Also:
      DSL.condition(String), SQL
    • or

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The other condition
      bindings - The bindings
      Returns:
      The combined condition
      See Also:
      DSL.condition(String, Object...), DSL.sql(String, Object...), SQL
    • or

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

      NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

      Parameters:
      sql - The SQL clause, containing {numbered placeholders} where query parts can be injected
      parts - The QueryPart objects that are rendered at the {numbered placeholder} locations
      Returns:
      The combined condition
      See Also:
      DSL.condition(String, Object...), DSL.sql(String, QueryPart...), SQL
    • orNot

      @NotNull @Support @NotNull Condition orNot(Condition other)
      Combine this condition with a negated other one using the Operator.OR operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • orNot

      @NotNull @Support @NotNull Condition orNot(Field<Boolean> other)
      Combine this condition with a negated other one using the Operator.OR operator.
      Parameters:
      other - The other condition
      Returns:
      The combined condition
    • orExists

      @NotNull @Support @NotNull Condition orExists(Select<?> select)
      Combine this condition with an EXISTS clause using the Operator.OR operator.
      Parameters:
      select - The EXISTS's subquery
      Returns:
      The combined condition
    • orNotExists

      @NotNull @Support @NotNull Condition orNotExists(Select<?> select)
      Combine this condition with a NOT EXIST clause using the Operator.OR operator.
      Parameters:
      select - The EXISTS's subquery
      Returns:
      The combined condition
    • and

      @NotNull @Support @NotNull Condition and(Condition arg2)
      The AND operator.
    • not

      @NotNull @Support @NotNull Condition not()
      The NOT operator.
    • or

      @NotNull @Support @NotNull Condition or(Condition arg2)
      The OR operator.