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

Uses of Interface
org.jooq.Select

Packages that use Select
org.jooq   
org.jooq.impl   
 

Uses of Select in org.jooq
 

Subinterfaces of Select in org.jooq
 interface SelectConditionStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectConnectByConditionStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectConnectByStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectFinalStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectForUpdateOfStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectForUpdateStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectForUpdateWaitStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectFromStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectGroupByStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectHavingConditionStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectHavingStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectJoinStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectLimitStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectOffsetStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectOnConditionStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectOrderByStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectQuery
          A query for data selection
 interface SelectSelectStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectStartWithStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SelectWhereStep
          This type is used for the Select's DSL API when selecting generic Record types.
 interface SimpleSelectConditionStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectFinalStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectForUpdateOfStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectForUpdateStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectForUpdateWaitStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectLimitStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectOffsetStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectOrderByStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 interface SimpleSelectQuery<R extends Record>
          A simple select query that provides Records from a single table, with no joins allowed.
 interface SimpleSelectWhereStep<R extends Record>
          This type is used for the Select's DSL API when selecting specific Record types.
 

Methods in org.jooq that return Select
 Select<R> Select.except(Select<R> select)
          Combine with other selects
 Select<R> Select.intersect(Select<R> select)
          Combine with other selects
 Select<R> Select.union(Select<R> select)
          Combine with other selects
 Select<R> Select.unionAll(Select<R> select)
          Combine with other selects
 

Methods in org.jooq with parameters of type Select
 UpdateConditionStep<R> UpdateConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator
 TableOnConditionStep TableOnConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator.
 SimpleSelectConditionStep<R> SimpleSelectConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectOnConditionStep SelectOnConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectHavingConditionStep SelectHavingConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectConditionStep SelectConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.
 MergeOnConditionStep<R> MergeOnConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.
 DivideByOnConditionStep DivideByOnConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator.
 DeleteConditionStep<R> DeleteConditionStep.andExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator
 Condition Condition.andExists(Select<?> select)
          Combine this condition with an EXISTS clause using the Operator.AND operator.
 UpdateConditionStep<R> UpdateConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator
 TableOnConditionStep TableOnConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator.
 SimpleSelectConditionStep<R> SimpleSelectConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectOnConditionStep SelectOnConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectHavingConditionStep SelectHavingConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.
 SelectConditionStep SelectConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.
 MergeOnConditionStep<R> MergeOnConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.
 DivideByOnConditionStep DivideByOnConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator.
 DeleteConditionStep<R> DeleteConditionStep.andNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause 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.eq(Select<?> query)
          this = (Select
 Condition Field.equal(Select<?> query)
          this = (Select
 Condition Field.equalAll(Select<?> query)
          this = all (Select
 Condition Field.equalAny(Select<?> query)
          this = any (Select
 Condition Field.equalSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.equalAny(Select) instead
 Select<R> Select.except(Select<R> select)
          Combine with other selects
 Condition Field.ge(Select<?> query)
          this >= (Select
 Condition Field.greaterOrEqual(Select<?> query)
          this >= (Select
 Condition Field.greaterOrEqualAll(Select<?> query)
          this >= all (Select
 Condition Field.greaterOrEqualAny(Select<?> query)
          this >= any (Select
 Condition Field.greaterOrEqualSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.greaterOrEqualAny(Select) instead
 Condition Field.greaterThan(Select<?> query)
          this > (Select
 Condition Field.greaterThanAll(Select<?> query)
          this > all (Select
 Condition Field.greaterThanAny(Select<?> query)
          this > any (Select
 Condition Field.greaterThanSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.greaterThanAny(Select) instead
 Condition Field.gt(Select<?> query)
          this > (Select
 Condition Field.in(Select<?> query)
          Create a condition to check this field against a subquery Note that the subquery must return exactly one field.
<R extends Record>
Insert<R>
FactoryOperations.insertInto(Table<R> into, Select<?> select)
          Deprecated. - 2.0.3 - Use any of these methods instead:
 Select<R> Select.intersect(Select<R> select)
          Combine with other selects
 Condition Field.le(Select<?> query)
          this <= (Select
 Condition Field.lessOrEqual(Select<?> query)
          this <= (Select
 Condition Field.lessOrEqualAll(Select<?> query)
          this <= all (Select
 Condition Field.lessOrEqualAny(Select<?> query)
          this <= any (Select
 Condition Field.lessOrEqualSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.lessOrEqualAny(Select) instead
 Condition Field.lessThan(Select<?> query)
          this < (Select
 Condition Field.lessThanAll(Select<?> query)
          this < all (Select
 Condition Field.lessThanAny(Select<?> query)
          this < any (Select
 Condition Field.lessThanSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.lessThanAny(Select) instead
 Condition Field.lt(Select<?> query)
          this < (Select
 Condition Field.ne(Select<?> query)
          this !
 Condition Field.notEqual(Select<?> query)
          this !
 Condition Field.notEqualAll(Select<?> query)
          this !
 Condition Field.notEqualAny(Select<?> query)
          this !
 Condition Field.notEqualSome(Select<?> query)
          Deprecated. - 2.0.2 - Use Field.notEqualAny(Select) instead
 Condition Field.notIn(Select<?> query)
          Create a condition to check this field against a subquery Note that the subquery must return exactly one field.
 UpdateConditionStep<R> UpdateConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator
 TableOnConditionStep TableOnConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator.
 SimpleSelectConditionStep<R> SimpleSelectConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectOnConditionStep SelectOnConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectHavingConditionStep SelectHavingConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectConditionStep SelectConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator and proceed to the next step.
 MergeOnConditionStep<R> MergeOnConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator and proceed to the next step.
 DivideByOnConditionStep DivideByOnConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator.
 DeleteConditionStep<R> DeleteConditionStep.orExists(Select<?> select)
          Combine the currently assembled conditions with an EXISTS clause using the Operator.OR operator
 Condition Condition.orExists(Select<?> select)
          Combine this condition with an EXISTS clause using the Operator.OR operator.
 UpdateConditionStep<R> UpdateConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator
 TableOnConditionStep TableOnConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator.
 SimpleSelectConditionStep<R> SimpleSelectConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectOnConditionStep SelectOnConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectHavingConditionStep SelectHavingConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator and proceed to the next step.
 SelectConditionStep SelectConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator and proceed to the next step.
 MergeOnConditionStep<R> MergeOnConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator and proceed to the next step.
 DivideByOnConditionStep DivideByOnConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator.
 DeleteConditionStep<R> DeleteConditionStep.orNotExists(Select<?> select)
          Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.OR operator
 Condition Condition.orNotExists(Select<?> select)
          Combine this condition with a NOT EXIST clause using the Operator.OR operator.
 Merge<R> MergeValuesStep.select(Select<?> select)
          Use a SELECT statement as the source of values for the MERGE statement This variant of the MERGE ..
 Insert<R> InsertValuesStep.select(Select<?> select)
          Use a SELECT statement as the source of values for the INSERT statement This variant of the INSERT ..
 Insert<R> InsertSetStep.select(Select<?> select)
          Use a SELECT statement as the source of values for the INSERT statement This variant of the INSERT ..
 Select<R> Select.union(Select<R> select)
          Combine with other selects
 Select<R> Select.unionAll(Select<R> select)
          Combine with other selects
 UpdateConditionStep<R> UpdateWhereStep.whereExists(Select<?> select)
          Add an EXISTS clause to the query
 SimpleSelectConditionStep<R> SimpleSelectWhereStep.whereExists(Select<?> select)
          Add a WHERE EXISTS clause to the query
 SelectConditionStep SelectWhereStep.whereExists(Select<?> select)
          Add a WHERE EXISTS clause to the query
 DeleteConditionStep<R> DeleteWhereStep.whereExists(Select<?> select)
          Add an EXISTS clause to the query
 UpdateConditionStep<R> UpdateWhereStep.whereNotExists(Select<?> select)
          Add a NOT EXISTS clause to the query
 SimpleSelectConditionStep<R> SimpleSelectWhereStep.whereNotExists(Select<?> select)
          Add a WHERE NOT EXISTS clause to the query
 SelectConditionStep SelectWhereStep.whereNotExists(Select<?> select)
          Add a WHERE NOT EXISTS clause to the query
 DeleteConditionStep<R> DeleteWhereStep.whereNotExists(Select<?> select)
          Add a NOT EXISTS clause to the query
 

Uses of Select in org.jooq.impl
 

Methods in org.jooq.impl with parameters of type Select
static Condition Factory.exists(Select<?> query)
          Create an exists condition.
<R extends Record>
Insert<R>
FactoryProxy.insertInto(Table<R> into, Select<?> select)
          Deprecated. 
<R extends Record>
Insert<R>
Factory.insertInto(Table<R> into, Select<?> select)
          Deprecated. 
static Condition Factory.notExists(Select<?> query)
          Create a not exists condition.
static
<R extends Record>
Table<R>
Factory.table(Select<R> select)
          A synonym for TableLike.asTable().
 

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