Module org.jooq
Package org.jooq

Interface SelectCorrelatedSubqueryStep<R extends Record>

    • Method Detail

      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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