Overview  Package  Class   Use  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Interface
org.jooq.Condition

Packages that use Condition
org.jooq   
org.jooq.impl   
 

Uses of Condition in org.jooq
 

Methods in org.jooq that return Condition
 Condition Condition.and(Condition other)
          Combine this condition with another one using the Operator.AND operator.
 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 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 SQL: this between minValue and maxValue
 Condition Field.between(T minValue, T maxValue)
          Create a condition to check this field against some bounds 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 SQL: this between symmetric minValue and maxValue
 Condition Field.betweenSymmetric(T minValue, T maxValue)
          Create a condition to check this field against some bounds SQL: this between symmetric minValue and maxValue
 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 Field.eq(Field<T> field)
          this = field
 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 Field.equal(Field<T> field)
          this = field
 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 Field.equalAll(Field<T[]> array)
          this = all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.equalAll(Select<?> query)
          this = all (Select
 Condition Field.equalAll(T... array)
          this = all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.equalAny(Field<T[]> array)
          this = any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.equalAny(Select<?> query)
          this = any (Select
 Condition Field.equalAny(T... array)
          this = any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.equalIgnoreCase(Field<String> value)
          lower(this) = lower(value)
 Condition Field.equalIgnoreCase(String value)
          lower(this) = lower(value)
 Condition Field.equalSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.equalAny(Select) instead
 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)
          this >= all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterOrEqualAll(Select<?> query)
          this >= all (Select
 Condition Field.greaterOrEqualAll(T... array)
          this >= all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterOrEqualAny(Field<T[]> array)
          this >= any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterOrEqualAny(Select<?> query)
          this >= any (Select
 Condition Field.greaterOrEqualAny(T... array)
          this >= any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterOrEqualSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.greaterOrEqualAny(Select) instead
 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)
          this > all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterThanAll(Select<?> query)
          this > all (Select
 Condition Field.greaterThanAll(T... array)
          this > all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterThanAny(Field<T[]> array)
          this > any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterThanAny(Select<?> query)
          this > any (Select
 Condition Field.greaterThanAny(T... array)
          this > any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.greaterThanSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.greaterThanAny(Select) instead
 Condition Field.gt(Field<T> field)
          this > field
 Condition Field.gt(Select<?> query)
          this > (Select
 Condition Field.gt(T value)
          this > value
 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 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)
          this <= all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessOrEqualAll(Select<?> query)
          this <= all (Select
 Condition Field.lessOrEqualAll(T... array)
          this <= all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessOrEqualAny(Field<T[]> array)
          this <= any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessOrEqualAny(Select<?> query)
          this <= any (Select
 Condition Field.lessOrEqualAny(T... array)
          this <= any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessOrEqualSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.lessOrEqualAny(Select) instead
 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)
          this < all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessThanAll(Select<?> query)
          this < all (Select
 Condition Field.lessThanAll(T... array)
          this < all (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessThanAny(Field<T[]> array)
          this < any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessThanAny(Select<?> query)
          this < any (Select
 Condition Field.lessThanAny(T... array)
          this < any (array) This is natively supported by SQLDialect.POSTGRES.
 Condition Field.lessThanSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.lessThanAny(Select) instead
 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> 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(Field<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.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 ExpressionSQLDialect.DB2 - - - SQLDialect.DERBY - - - SQLDialect.H2[search] REGEXP [pattern] Java http ://www.h2database.com/html/grammar.html#condition_right_hand_sideSQLDialect.HSQLDBREGEXP_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 Field.ne(Field<T> field)
          this !
 Condition Field.ne(Select<?> query)
          this !
 Condition Field.ne(T value)
          this !
 Condition Condition.not()
          Invert this condition This is the same as calling Factory.not(Condition)
 Condition Field.notBetween(Field<T> minValue, Field<T> maxValue)
          Create a condition to check this field against some bounds SQL: this not between minValue and maxValue
 Condition Field.notBetween(T minValue, T maxValue)
          Create a condition to check this field against some bounds 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 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 SQL: this not between symmetric minValue and maxValue
 Condition Field.notEqual(Field<T> field)
          this !
 Condition Field.notEqual(Select<?> query)
          this !
 Condition Field.notEqual(T value)
          this !
 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)
          Deprecated. - 2.0.2 - Use Field.notEqualAny(Select) instead
 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 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> value)
          Create a condition to pattern-check this field against a value SQL: this not like value
 Condition Field.notLike(Field<String> value, char escape)
          Create a condition to pattern-check this field against a value SQL: this not like value 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> 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(Field<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.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 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
 void ConditionProvider.addConditions(Condition... conditions)
          Adds new conditions to the query, connecting them to existing conditions with Operator.AND
 void ConditionProvider.addConditions(Operator operator, Condition... conditions)
          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)
          Deprecated. - 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.
<R extends TableRecord<R>,T>
int
FactoryOperations.executeDeleteOne(Table<R> table, Condition condition)
          Deprecated. - 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.
<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)
          Deprecated. - 2.5.0 [#1692] - Use FactoryOperations.executeUpdate(TableRecord, Condition) instead
<R extends TableRecord<R>,T>
int
FactoryOperations.executeUpdateOne(Table<R> table, R record, Condition condition)
          Deprecated. - 2.5.0 [#1692] - The semantics of FactoryOperations.executeUpdate(TableRecord, Condition) has changed. This method here is no longer necessary.
<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
 void ConditionProvider.addConditions(Collection<Condition> conditions)
          Adds new conditions to the query, connecting them to existing conditions with Operator.AND
 void ConditionProvider.addConditions(Operator operator, Collection<Condition> conditions)
          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
 

Uses of Condition in org.jooq.impl
 

Classes in org.jooq.impl that implement Condition
 class CustomCondition
          A base class for custom Condition implementations in client code.
 

Methods in org.jooq.impl that return Condition
static Condition Factory.condition(String sql)
          Create a new condition holding plain SQL.
static Condition Factory.condition(String sql, Object... bindings)
          Create a new condition holding plain SQL.
static Condition Factory.condition(String sql, QueryPart... parts)
          A custom SQL clause that can render arbitrary SQL elements.
static Condition Factory.exists(Select<?> query)
          Create an exists condition.
static Condition Factory.falseCondition()
          Return a Condition that will always evaluate to false
static Condition Factory.not(Condition condition)
          Invert a condition This is the same as calling not()
static Condition Factory.notExists(Select<?> query)
          Create a not exists condition.
static Condition Factory.trueCondition()
          Return a Condition that will always evaluate to true
 

Methods in org.jooq.impl with parameters of type Condition
<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()
 

Overview  Package  Class   Use  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    
Copyright © 2012. All Rights Reserved.