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.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.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.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.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.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.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.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.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 Condition.not()
          Invert this 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.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 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.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
 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(Table<R> table, Condition condition)
          Delete records from a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>,T>
int
FactoryOperations.executeDeleteOne(Table<R> table, Condition condition)
          Delete one record in a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>,T>
int
FactoryOperations.executeUpdate(Table<R> table, R record, Condition condition)
          Update a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends TableRecord<R>,T>
int
FactoryOperations.executeUpdateOne(Table<R> table, R record, Condition condition)
          Update one record in a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends Record>
Result<R>
FactoryOperations.fetch(Table<R> table, Condition condition)
          Execute and return all records for SELECT * FROM [table] WHERE [condition]
<R extends Record>
R
FactoryOperations.fetchOne(Table<R> table, Condition condition)
          Execute and return zero or one record for SELECT * FROM [table] WHERE [condition]
 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.exists(Select<?> query)
          Create an exists condition.
static Condition Factory.falseCondition()
          Return a Condition that will always evaluate to false
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
Factory.executeDelete(Table<R> table, Condition condition)
          Delete records from a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>,T>
int
Factory.executeDeleteOne(Table<R> table, Condition condition)
          Delete one record in a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>,T>
int
Factory.executeUpdate(Table<R> table, R record, Condition condition)
          Update a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends TableRecord<R>,T>
int
Factory.executeUpdateOne(Table<R> table, R record, Condition condition)
          Update one record in a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends Record>
Result<R>
Factory.fetch(Table<R> table, Condition condition)
          Execute and return all records for SELECT * FROM [table] WHERE [condition]
<R extends Record>
R
Factory.fetchOne(Table<R> table, Condition condition)
          Execute and return zero or one record for SELECT * FROM [table] WHERE [condition]
 

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