Module org.jooq

Package org.jooq

Interface SelectCorrelatedSubqueryStep<R extends Record>

All Superinterfaces:

Attachable, AutoCloseable, FieldLike, Flow.Publisher<R>, Iterable<R>, org.reactivestreams.Publisher<R>, Query, QueryPart, ResultQuery<R>, Select<R>, SelectFinalStep<R>, Serializable, Statement, TableLike<R>

All Known Subinterfaces:

SelectConditionStep<R>, SelectConnectByAfterStartWithConditionStep<R>, SelectConnectByConditionStep<R>, SelectConnectByStep<R>, SelectDistinctOnStep<R>, SelectForJSONCommonDirectivesStep<R>, SelectForStep<R>, SelectForUpdateOfStep<R>, SelectForUpdateStep<R>, SelectForUpdateWaitStep<R>, SelectForXMLCommonDirectivesStep<R>, SelectForXMLPathDirectivesStep<R>, SelectForXMLRawDirectivesStep<R>, SelectFromStep<R>, SelectGroupByStep<R>, SelectHavingConditionStep<R>, SelectHavingStep<R>, SelectIntoStep<R>, SelectJoinStep<R>, SelectLimitAfterOffsetStep<R>, SelectLimitPercentAfterOffsetStep<R>, SelectLimitPercentStep<R>, SelectLimitStep<R>, SelectOffsetStep<R>, SelectOnConditionStep<R>, SelectOptionalOnStep<R>, SelectOptionStep<R>, SelectOrderByStep<R>, SelectQualifyConditionStep<R>, SelectQualifyStep<R>, SelectSeekLimitStep<R>, SelectSeekStep1<R,T1>, SelectSeekStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>, SelectSeekStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>, SelectSeekStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>, SelectSeekStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>, SelectSeekStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>, SelectSeekStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>, SelectSeekStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>, SelectSeekStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>, SelectSeekStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>, SelectSeekStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>, SelectSeekStep2<R,T1,T2>, SelectSeekStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>, SelectSeekStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>, SelectSeekStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>, SelectSeekStep3<R,T1,T2,T3>, SelectSeekStep4<R,T1,T2,T3,T4>, SelectSeekStep5<R,T1,T2,T3,T4,T5>, SelectSeekStep6<R,T1,T2,T3,T4,T5,T6>, SelectSeekStep7<R,T1,T2,T3,T4,T5,T6,T7>, SelectSeekStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>, SelectSeekStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>, SelectSeekStepN<R>, SelectSelectStep<R>, SelectStartWithStep<R>, SelectUnionStep<R>, SelectWhereStep<R>, SelectWindowStep<R>, SelectWithTiesAfterOffsetStep<R>, SelectWithTiesStep<R>

public interface SelectCorrelatedSubqueryStep<R extends Record>
extends SelectFinalStep<R>

This type is used for the Select's DSL API when selecting generic Record types.

Example:

 -- get all authors' first and last names, and the number
 -- of books they've written in German, if they have written
 -- more than five books in German in the last three years
 -- (from 2011), and sort those authors by last names
 -- limiting results to the second and third row

   SELECT T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME, COUNT(*)
     FROM T_AUTHOR
     JOIN T_BOOK ON T_AUTHOR.ID = T_BOOK.AUTHOR_ID
    WHERE T_BOOK.LANGUAGE = 'DE'
      AND T_BOOK.PUBLISHED > '2008-01-01'
 GROUP BY T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME
   HAVING COUNT(*) > 5
 ORDER BY T_AUTHOR.LAST_NAME ASC NULLS FIRST
    LIMIT 2
   OFFSET 1
      FOR UPDATE
       OF FIRST_NAME, LAST_NAME
       NO WAIT
 

Its equivalent in jOOQ

 create.select(TAuthor.FIRST_NAME, TAuthor.LAST_NAME, create.count())
       .from(T_AUTHOR)
       .join(T_BOOK).on(TBook.AUTHOR_ID.equal(TAuthor.ID))
       .where(TBook.LANGUAGE.equal("DE"))
       .and(TBook.PUBLISHED.greaterThan(parseDate('2008-01-01')))
       .groupBy(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
       .having(create.count().greaterThan(5))
       .orderBy(TAuthor.LAST_NAME.asc().nullsFirst())
       .limit(2)
       .offset(1)
       .forUpdate()
       .of(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
       .noWait();
 

Refer to the manual for more details

Referencing XYZ*Step types directly from client code

It is usually not recommended to reference any XYZ*Step types directly from client code, or assign them to local variables. When writing dynamic SQL, creating a statement's components dynamically, and passing them to the DSL API statically is usually a better choice. See the manual's section about dynamic SQL for details: https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql.

Drawbacks of referencing the XYZ*Step types directly:

• They're operating on mutable implementations (as of jOOQ 3.x)
• They're less composable and not easy to get right when dynamic SQL gets complex
• They're less readable
• They might have binary incompatible changes between minor releases

Author:

Lukas Eder

Method Summary

Modifier and Type	Method	Description
@NotNull BetweenAndStep<R>	between(Select<? extends R> minValue)	Check if this subquery is within a range of two subqueries.
@NotNull Condition	between(Select<? extends R> minValue, Select<? extends R> maxValue)	Check if this subquery is within a range of two subqueries.
@NotNull BetweenAndStep<R>	between(R minValue)	Check if this subquery is within a range of two records.
@NotNull Condition	between(R minValue, R maxValue)	Check if this subquery is within a range of two records.
@NotNull BetweenAndStepR<R>	betweenSymmetric(Select<? extends R> minValue)	Check if this subquery is within a symmetric range of two subqueries.
@NotNull Condition	betweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue)	Check if this subquery is within a symmetric range of two subqueries.
@NotNull BetweenAndStepR<R>	betweenSymmetric(R minValue)	Check if this subquery is within a symmetric range of two records.
@NotNull Condition	betweenSymmetric(R minValue, R maxValue)	Check if this subquery is within a symmetric range of two records.
@NotNull Condition	compare(Comparator comparator, QuantifiedSelect<? extends R> select)	Compare this subquery with a quantified subquery using a dynamic comparator.
@NotNull Condition	compare(Comparator comparator, Select<? extends R> select)	Compare this subquery with a subquery using a dynamic comparator.
@NotNull Condition	compare(Comparator comparator, R record)	Compare this subquery with a record using a dynamic comparator.
@NotNull Condition	eq(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for equality.
@NotNull Condition	eq(Select<? extends R> select)	Compare this subquery with another record for equality.
@NotNull Condition	eq(R record)	Compare this subquery with a record for equality.
@NotNull Condition	equal(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for equality.
@NotNull Condition	equal(Select<? extends R> select)	Compare this subquery with another record for equality.
@NotNull Condition	equal(R record)	Compare this subquery with a record for equality.
@NotNull Condition	ge(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	ge(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	ge(R record)	Compare this subquery with a record for order.
@NotNull Condition	greaterOrEqual(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	greaterOrEqual(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	greaterOrEqual(R record)	Compare this subquery with a record for order.
@NotNull Condition	greaterThan(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	greaterThan(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	greaterThan(R record)	Compare this subquery with a record for order.
@NotNull Condition	gt(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	gt(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	gt(R record)	Compare this subquery with a record for order.
@NotNull Condition	in(Select<? extends R> select)	Compare this subquery with another subquery for equality.
@NotNull Condition	in(R... records)	Compare this subquery with a set of records for equality.
@NotNull Condition	isDistinctFrom(QuantifiedSelect<? extends R> select)	Compare this subquery with another record for distinctness.
@NotNull Condition	isDistinctFrom(Select<? extends R> select)	Compare this subquery with another record for distinctness.
@NotNull Condition	isDistinctFrom(R record)	Compare this subquery with another record for distinctness.
@NotNull Condition	isNotDistinctFrom(QuantifiedSelect<? extends R> select)	Compare this subquery with another record for distinctness.
@NotNull Condition	isNotDistinctFrom(Select<? extends R> select)	Compare this subquery with another record for distinctness.
@NotNull Condition	isNotDistinctFrom(R record)	Compare this subquery with another record for distinctness.
@NotNull Condition	isNotNull()	Check if the result of this subquery IS NOT NULL
@NotNull Condition	isNull()	Check if the result of this subquery IS NULL
@NotNull Condition	le(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	le(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	le(R record)	Compare this subquery with a record for order.
@NotNull Condition	lessOrEqual(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	lessOrEqual(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	lessOrEqual(R record)	Compare this subquery with a record for order.
@NotNull Condition	lessThan(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	lessThan(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	lessThan(R record)	Compare this subquery with a record for order.
@NotNull Condition	lt(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for order.
@NotNull Condition	lt(Select<? extends R> select)	Compare this subquery with another record for order.
@NotNull Condition	lt(R record)	Compare this subquery with a record for order.
@NotNull Condition	ne(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for non-equality.
@NotNull Condition	ne(Select<? extends R> select)	Compare this subquery with another record for non-equality.
@NotNull Condition	ne(R record)	Compare this subquery with a record for non-equality.
@NotNull BetweenAndStepR<R>	notBetween(Select<? extends R> minValue)	Check if this subquery is not within a range of two subqueries.
@NotNull Condition	notBetween(Select<? extends R> minValue, Select<? extends R> maxValue)	Check if this subquery is not within a range of two subqueries.
@NotNull BetweenAndStepR<R>	notBetween(R minValue)	Check if this subquery is not within a range of two records.
@NotNull Condition	notBetween(R minValue, R maxValue)	Check if this subquery is not within a range of two records.
@NotNull BetweenAndStepR<R>	notBetweenSymmetric(Select<? extends R> minValue)	Check if this subquery is not within a symmetric range of two subqueries.
@NotNull Condition	notBetweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue)	Check if this subquery is not within a symmetric range of two subqueries.
@NotNull BetweenAndStepR<R>	notBetweenSymmetric(R minValue)	Check if this subquery is not within a symmetric range of two records.
@NotNull Condition	notBetweenSymmetric(R minValue, R maxValue)	Check if this subquery is not within a symmetric range of two records.
@NotNull Condition	notEqual(QuantifiedSelect<? extends R> select)	Compare this subquery with a quanitified subquery for non-equality.
@NotNull Condition	notEqual(Select<? extends R> select)	Compare this subquery with another record for non-equality.
@NotNull Condition	notEqual(R record)	Compare this subquery with a record for non-equality.
@NotNull Condition	notIn(Select<? extends R> select)	Compare this subquery with another subquery for non-equality.
@NotNull Condition	notIn(R... records)	Compare this subquery with a set of records for non-equality.

Methods inherited from interface org.jooq.Attachable

attach, configuration, detach

Methods inherited from interface org.jooq.FieldLike

asField, asField, asField

Methods inherited from interface java.util.concurrent.Flow.Publisher

subscribe

Methods inherited from interface org.reactivestreams.Publisher

subscribe

Methods inherited from interface org.jooq.Query

cancel, close, execute, executeAsync, executeAsync, getBindValues, getParam, getParams, getSQL, getSQL, getSQL, isExecutable

Methods inherited from interface org.jooq.QueryPart

equals, hashCode, toString

Methods inherited from interface org.jooq.ResultQuery

bind, bind, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, collect, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAnyArray, fetchAnyInto, fetchAnyInto, fetchAnyMap, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArrays, fetchAsync, fetchAsync, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchInto, fetchInto, fetchInto, fetchLater, fetchLater, fetchLazy, fetchLazy, fetchMany, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMaps, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOneArray, fetchOneInto, fetchOneInto, fetchOneMap, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptionalArray, fetchOptionalInto, fetchOptionalInto, fetchOptionalMap, fetchResultSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingleArray, fetchSingleInto, fetchSingleInto, fetchSingleMap, fetchSize, fetchStream, fetchStreamInto, fetchStreamInto, forEach, getRecordType, getResult, intern, intern, intern, intern, iterator, keepStatement, maxRows, poolable, queryTimeout, resultSetConcurrency, resultSetHoldability, resultSetType, spliterator, stream

Methods inherited from interface org.jooq.Select

except, exceptAll, fetchCount, getSelect, intersect, intersectAll, union, unionAll

Methods inherited from interface org.jooq.SelectFinalStep

getQuery

Methods inherited from interface org.jooq.TableLike

asTable, asTable, asTable, asTable, asTable, asTable, asTable, asTable, asTable, field, field, field, field, field, field, field, field, field, field, fields, fields, fields, fields, fields, fieldsRow, fieldStream, indexOf, indexOf, indexOf

Method Detail

compare

@NotNull
@Support
@NotNull Condition compare(Comparator comparator,
                           R record)

Compare this subquery with a record using a dynamic comparator.

See the explicit comparison methods for details. Note, not all Comparator types are supported

See Also:

eq(Record), ne(Record), lt(Record), le(Record), gt(Record), ge(Record)

compare

@NotNull
@Support
@NotNull Condition compare(Comparator comparator,
                           Select<? extends R> select)

Compare this subquery with a subquery using a dynamic comparator.

See the explicit comparison methods for details. Note, not all Comparator types are supported

See Also:

eq(Record), ne(Record), lt(Record), le(Record), gt(Record), ge(Record)

compare

@NotNull
@Support
@NotNull Condition compare(Comparator comparator,
                           QuantifiedSelect<? extends R> select)

Compare this subquery with a quantified subquery using a dynamic comparator.

See the explicit comparison methods for details. Note, not all Comparator types are supported

See Also:

eq(Record), ne(Record), lt(Record), le(Record), gt(Record), ge(Record)

eq

@NotNull
@Support
@NotNull Condition eq(R record)

Compare this subquery with a record for equality.

eq

@NotNull
@Support
@NotNull Condition eq(Select<? extends R> select)

Compare this subquery with another record for equality.

eq

@NotNull
@Support
@NotNull Condition eq(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for equality.

equal

@NotNull
@Support
@NotNull Condition equal(R record)

Compare this subquery with a record for equality.

equal

@NotNull
@Support
@NotNull Condition equal(Select<? extends R> select)

Compare this subquery with another record for equality.

equal

@NotNull
@Support
@NotNull Condition equal(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for equality.

ne

@NotNull
@Support
@NotNull Condition ne(R record)

Compare this subquery with a record for non-equality.

ne

@NotNull
@Support
@NotNull Condition ne(Select<? extends R> select)

Compare this subquery with another record for non-equality.

ne

@NotNull
@Support
@NotNull Condition ne(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for non-equality.

notEqual

@NotNull
@Support
@NotNull Condition notEqual(R record)

Compare this subquery with a record for non-equality.

notEqual

@NotNull
@Support
@NotNull Condition notEqual(Select<? extends R> select)

Compare this subquery with another record for non-equality.

notEqual

@NotNull
@Support
@NotNull Condition notEqual(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for non-equality.

lt

@NotNull
@Support
@NotNull Condition lt(R record)

Compare this subquery with a record for order.

lt

@NotNull
@Support
@NotNull Condition lt(Select<? extends R> select)

Compare this subquery with another record for order.

lt

@NotNull
@Support
@NotNull Condition lt(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

lessThan

@NotNull
@Support
@NotNull Condition lessThan(R record)

Compare this subquery with a record for order.

lessThan

@NotNull
@Support
@NotNull Condition lessThan(Select<? extends R> select)

Compare this subquery with another record for order.

lessThan

@NotNull
@Support
@NotNull Condition lessThan(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

le

@NotNull
@Support
@NotNull Condition le(R record)

Compare this subquery with a record for order.

le

@NotNull
@Support
@NotNull Condition le(Select<? extends R> select)

Compare this subquery with another record for order.

le

@NotNull
@Support
@NotNull Condition le(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

lessOrEqual

@NotNull
@Support
@NotNull Condition lessOrEqual(R record)

Compare this subquery with a record for order.

lessOrEqual

@NotNull
@Support
@NotNull Condition lessOrEqual(Select<? extends R> select)

Compare this subquery with another record for order.

lessOrEqual

@NotNull
@Support
@NotNull Condition lessOrEqual(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

gt

@NotNull
@Support
@NotNull Condition gt(R record)

Compare this subquery with a record for order.

gt

@NotNull
@Support
@NotNull Condition gt(Select<? extends R> select)

Compare this subquery with another record for order.

gt

@NotNull
@Support
@NotNull Condition gt(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

greaterThan

@NotNull
@Support
@NotNull Condition greaterThan(R record)

Compare this subquery with a record for order.

greaterThan

@NotNull
@Support
@NotNull Condition greaterThan(Select<? extends R> select)

Compare this subquery with another record for order.

greaterThan

@NotNull
@Support
@NotNull Condition greaterThan(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

ge

@NotNull
@Support
@NotNull Condition ge(R record)

Compare this subquery with a record for order.

ge

@NotNull
@Support
@NotNull Condition ge(Select<? extends R> select)

Compare this subquery with another record for order.

ge

@NotNull
@Support
@NotNull Condition ge(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

greaterOrEqual

@NotNull
@Support
@NotNull Condition greaterOrEqual(R record)

Compare this subquery with a record for order.

greaterOrEqual

@NotNull
@Support
@NotNull Condition greaterOrEqual(Select<? extends R> select)

Compare this subquery with another record for order.

greaterOrEqual

@NotNull
@Support
@NotNull Condition greaterOrEqual(QuantifiedSelect<? extends R> select)

Compare this subquery with a quanitified subquery for order.

in

@NotNull
@Support
@NotNull Condition in(R... records)

Compare this subquery with a set of records for equality.

Note that generating dynamic SQL with arbitrary-length IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:

• IN predicates on temporary tables
• IN predicates on unnested array bind variables

in

@NotNull
@Support
@NotNull Condition in(Select<? extends R> select)

Compare this subquery with another subquery for equality.

notIn

@NotNull
@Support
@NotNull Condition notIn(R... records)

Compare this subquery with a set of records for non-equality.

Note that generating dynamic SQL with arbitrary-length IN predicates can cause cursor cache contention in some databases that use unique SQL strings as a statement identifier (e.g. SQLDialect.ORACLE). In order to prevent such problems, you could use Settings.isInListPadding() to produce less distinct SQL strings (see also [#5600]), or you could avoid IN lists, and replace them with:

• IN predicates on temporary tables
• IN predicates on unnested array bind variables

notIn

@NotNull
@Support
@NotNull Condition notIn(Select<? extends R> select)

Compare this subquery with another subquery for non-equality.

isDistinctFrom

@NotNull
@Support
@NotNull Condition isDistinctFrom(R record)

Compare this subquery with another record for distinctness.

isDistinctFrom

@NotNull
@Support
@NotNull Condition isDistinctFrom(Select<? extends R> select)

Compare this subquery with another record for distinctness.

isDistinctFrom

@NotNull
@Support
@NotNull Condition isDistinctFrom(QuantifiedSelect<? extends R> select)

Compare this subquery with another record for distinctness.

isNotDistinctFrom

@NotNull
@Support
@NotNull Condition isNotDistinctFrom(R record)

Compare this subquery with another record for distinctness.

isNotDistinctFrom

@NotNull
@Support
@NotNull Condition isNotDistinctFrom(Select<? extends R> select)

Compare this subquery with another record for distinctness.

isNotDistinctFrom

@NotNull
@Support
@NotNull Condition isNotDistinctFrom(QuantifiedSelect<? extends R> select)

Compare this subquery with another record for distinctness.

between

@NotNull
@Support
@NotNull BetweenAndStep<R> between(R minValue)

Check if this subquery is within a range of two records.

This is the same as calling between(minValue).and(maxValue)

between

@NotNull
@Support
@NotNull Condition between(R minValue,
                           R maxValue)

Check if this subquery is within a range of two records.

This is the same as calling between(minValue).and(maxValue)

between

@NotNull
@Support
@NotNull BetweenAndStep<R> between(Select<? extends R> minValue)

Check if this subquery is within a range of two subqueries.

This is the same as calling between(minValue).and(maxValue)

between

@NotNull
@Support
@NotNull Condition between(Select<? extends R> minValue,
                           Select<? extends R> maxValue)

Check if this subquery is within a range of two subqueries.

This is the same as calling between(minValue).and(maxValue)

betweenSymmetric

@NotNull
@Support
@NotNull BetweenAndStepR<R> betweenSymmetric(R minValue)

Check if this subquery is within a symmetric range of two records.

betweenSymmetric

@NotNull
@Support
@NotNull Condition betweenSymmetric(R minValue,
                                    R maxValue)

Check if this subquery is within a symmetric range of two records.

This is the same as calling between(minValue).and(maxValue)

betweenSymmetric

@NotNull
@Support
@NotNull BetweenAndStepR<R> betweenSymmetric(Select<? extends R> minValue)

Check if this subquery is within a symmetric range of two subqueries.

betweenSymmetric

@NotNull
@Support
@NotNull Condition betweenSymmetric(Select<? extends R> minValue,
                                    Select<? extends R> maxValue)

Check if this subquery is within a symmetric range of two subqueries.

This is the same as calling between(minValue).and(maxValue)

notBetween

@NotNull
@Support
@NotNull BetweenAndStepR<R> notBetween(R minValue)

Check if this subquery is not within a range of two records.

notBetween

@NotNull
@Support
@NotNull Condition notBetween(R minValue,
                              R maxValue)

Check if this subquery is not within a range of two records.

This is the same as calling between(minValue).and(maxValue)

notBetween

@NotNull
@Support
@NotNull BetweenAndStepR<R> notBetween(Select<? extends R> minValue)

Check if this subquery is not within a range of two subqueries.

notBetween

@NotNull
@Support
@NotNull Condition notBetween(Select<? extends R> minValue,
                              Select<? extends R> maxValue)

Check if this subquery is not within a range of two subqueries.

This is the same as calling between(minValue).and(maxValue)

notBetweenSymmetric

@NotNull
@Support
@NotNull BetweenAndStepR<R> notBetweenSymmetric(R minValue)

Check if this subquery is not within a symmetric range of two records.

notBetweenSymmetric

@NotNull
@Support
@NotNull Condition notBetweenSymmetric(R minValue,
                                       R maxValue)

Check if this subquery is not within a symmetric range of two records.

This is the same as calling between(minValue).and(maxValue)

notBetweenSymmetric

@NotNull
@Support
@NotNull BetweenAndStepR<R> notBetweenSymmetric(Select<? extends R> minValue)

Check if this subquery is not within a symmetric range of two subqueries.

notBetweenSymmetric

@NotNull
@Support
@NotNull Condition notBetweenSymmetric(Select<? extends R> minValue,
                                       Select<? extends R> maxValue)

Check if this subquery is not within a symmetric range of two subqueries.

This is the same as calling between(minValue).and(maxValue)

isNull

@NotNull
@Support
@NotNull Condition isNull()

Check if the result of this subquery IS NULL

isNotNull

@NotNull
@Support
@NotNull Condition isNotNull()

Check if the result of this subquery IS NOT NULL