@Generated(value="This class was generated using jOOQ-tools") public interface RowN extends Row
N > 22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
Modifier and Type | Method and Description |
---|---|
BetweenAndStepN |
between(Field<?>... minValues)
Check if this row value expression is within a range of two other row
value expressions.
|
BetweenAndStepN |
between(Object... minValues)
Check if this row value expression is within a range of two other row
value expressions.
|
BetweenAndStepN |
between(Record minValue)
Check if this row value expression is within a range of two records.
|
Condition |
between(Record minValue,
Record maxValue)
Check if this row value expression is within a range of two records.
|
BetweenAndStepN |
between(RowN minValue)
Check if this row value expression is within a range of two other row
value expressions.
|
Condition |
between(RowN minValue,
RowN maxValue)
Check if this row value expression is within a range of two other row
value expressions.
|
BetweenAndStepN |
betweenSymmetric(Field<?>... minValues)
Check if this row value expression is within a symmetric range of two
other row value expressions.
|
BetweenAndStepN |
betweenSymmetric(Object... minValues)
Check if this row value expression is within a symmetric range of two
other row value expressions.
|
BetweenAndStepN |
betweenSymmetric(Record minValue)
Check if this row value expression is within a symmetric range of two
records.
|
Condition |
betweenSymmetric(Record minValue,
Record maxValue)
Check if this row value expression is within a symmetric range of two
records.
|
BetweenAndStepN |
betweenSymmetric(RowN minValue)
Check if this row value expression is within a symmetric range of two
other row value expressions.
|
Condition |
betweenSymmetric(RowN minValue,
RowN maxValue)
Check if this row value expression is within a symmetric range of two
other row value expressions.
|
Condition |
compare(Comparator comparator,
Field<?>... values)
Compare this row value expression with another row value expression
using a dynamic comparator.
|
Condition |
compare(Comparator comparator,
Object... values)
Compare this row value expression with another row value expression
using a dynamic comparator.
|
Condition |
compare(Comparator comparator,
QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect
using a dynamic comparator.
|
Condition |
compare(Comparator comparator,
Record record)
Compare this row value expression with a record
using a dynamic comparator.
|
Condition |
compare(Comparator comparator,
RowN row)
Compare this row value expression with another row value expression
using a dynamic comparator.
|
Condition |
compare(Comparator comparator,
Select<? extends Record> select)
Compare this row value expression with a subselect
using a dynamic comparator.
|
Condition |
eq(Field<?>... values)
Compare this row value expression with another row value expression for
equality.
|
Condition |
eq(Object... values)
Compare this row value expression with another row value expression for
equality.
|
Condition |
eq(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for equality.
|
Condition |
eq(Record record)
Compare this row value expression with a record for equality.
|
Condition |
eq(RowN row)
Compare this row value expression with another row value expression for
equality.
|
Condition |
eq(Select<? extends Record> select)
Compare this row value expression with a subselect for equality.
|
Condition |
equal(Field<?>... values)
Compare this row value expression with another row value expression for
equality.
|
Condition |
equal(Object... values)
Compare this row value expression with another row value expression for
equality.
|
Condition |
equal(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for equality.
|
Condition |
equal(Record record)
Compare this row value expression with a record for equality.
|
Condition |
equal(RowN row)
Compare this row value expression with another row value expression for
equality.
|
Condition |
equal(Select<? extends Record> select)
Compare this row value expression with a subselect for equality.
|
Condition |
ge(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
ge(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
ge(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
ge(Record record)
Compare this row value expression with a record for order.
|
Condition |
ge(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
ge(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
greaterOrEqual(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterOrEqual(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterOrEqual(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
greaterOrEqual(Record record)
Compare this row value expression with a record for order.
|
Condition |
greaterOrEqual(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterOrEqual(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
greaterThan(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterThan(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterThan(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
greaterThan(Record record)
Compare this row value expression with a record for order.
|
Condition |
greaterThan(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
greaterThan(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
gt(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
gt(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
gt(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
gt(Record record)
Compare this row value expression with a record for order.
|
Condition |
gt(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
gt(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
in(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality.
|
Condition |
in(Record... record)
Compare this row value expression with a set of records for equality.
|
Condition |
in(Result<? extends Record> result)
Compare this row value expression with a set of records for
equality.
|
Condition |
in(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality.
|
Condition |
in(Select<? extends Record> select)
Compare this row value expression with a subselect for equality.
|
Condition |
isDistinctFrom(Field<?>... values)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isDistinctFrom(Object... values)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isDistinctFrom(Record record)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isDistinctFrom(RowN row)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isNotDistinctFrom(Field<?>... values)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isNotDistinctFrom(Object... values)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isNotDistinctFrom(Record record)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
isNotDistinctFrom(RowN row)
Compare this row value expression with another row value expression for
distinctness.
|
Condition |
le(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
le(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
le(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
le(Record record)
Compare this row value expression with a record for order.
|
Condition |
le(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
le(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lessOrEqual(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessOrEqual(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessOrEqual(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lessOrEqual(Record record)
Compare this row value expression with a record for order.
|
Condition |
lessOrEqual(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessOrEqual(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lessThan(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessThan(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessThan(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lessThan(Record record)
Compare this row value expression with a record for order.
|
Condition |
lessThan(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
lessThan(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lt(Field<?>... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lt(Object... values)
Compare this row value expression with another row value expression for
order.
|
Condition |
lt(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
lt(Record record)
Compare this row value expression with a record for order.
|
Condition |
lt(RowN row)
Compare this row value expression with another row value expression for
order.
|
Condition |
lt(Select<? extends Record> select)
Compare this row value expression with a subselect for order.
|
Condition |
ne(Field<?>... values)
Compare this row value expression with another row value expression for
non-equality.
|
Condition |
ne(Object... values)
Compare this row value expression with another row value expression for
non-equality.
|
Condition |
ne(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for non-equality.
|
Condition |
ne(Record record)
Compare this row value expression with a record for non-equality.
|
Condition |
ne(RowN row)
Compare this row value expression with another row value expression for
non-equality.
|
Condition |
ne(Select<? extends Record> select)
Compare this row value expression with a subselect for non-equality.
|
BetweenAndStepN |
notBetween(Field<?>... minValues)
Check if this row value expression is not within a range of two other
row value expressions.
|
BetweenAndStepN |
notBetween(Object... minValues)
Check if this row value expression is not within a range of two other
row value expressions.
|
BetweenAndStepN |
notBetween(Record minValue)
Check if this row value expression is within a range of two records.
|
Condition |
notBetween(Record minValue,
Record maxValue)
Check if this row value expression is within a range of two records.
|
BetweenAndStepN |
notBetween(RowN minValue)
Check if this row value expression is not within a range of two other
row value expressions.
|
Condition |
notBetween(RowN minValue,
RowN maxValue)
Check if this row value expression is not within a range of two other
row value expressions.
|
BetweenAndStepN |
notBetweenSymmetric(Field<?>... minValues)
Check if this row value expression is not within a symmetric range of two
other row value expressions.
|
BetweenAndStepN |
notBetweenSymmetric(Object... minValues)
Check if this row value expression is not within a symmetric range of two
other row value expressions.
|
BetweenAndStepN |
notBetweenSymmetric(Record minValue)
Check if this row value expression is not within a symmetric range of two
records.
|
Condition |
notBetweenSymmetric(Record minValue,
Record maxValue)
Check if this row value expression is not within a symmetric range of two
records.
|
BetweenAndStepN |
notBetweenSymmetric(RowN minValue)
Check if this row value expression is not within a symmetric range of two
other row value expressions.
|
Condition |
notBetweenSymmetric(RowN minValue,
RowN maxValue)
Check if this row value expression is not within a symmetric range of two
other row value expressions.
|
Condition |
notEqual(Field<?>... values)
Compare this row value expression with another row value expression for
non-equality.
|
Condition |
notEqual(Object... values)
Compare this row value expression with another row value expression for.
|
Condition |
notEqual(QuantifiedSelect<? extends Record> select)
Compare this row value expression with a subselect for non-equality.
|
Condition |
notEqual(Record record)
Compare this row value expression with a record for non-equality
|
Condition |
notEqual(RowN row)
Compare this row value expression with another row value expression for
non-equality.
|
Condition |
notEqual(Select<? extends Record> select)
Compare this row value expression with a subselect for non-equality.
|
Condition |
notIn(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality.
|
Condition |
notIn(Record... record)
Compare this row value expression with a set of records for non-equality.
|
Condition |
notIn(Result<? extends Record> result)
Compare this row value expression with a set of records for
equality.
|
Condition |
notIn(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality.
|
Condition |
notIn(Select<? extends Record> select)
Compare this row value expression with a subselect for non-equality.
|
@Support Condition compare(Comparator comparator, RowN row)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition compare(Comparator comparator, Record record)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition compare(Comparator comparator, Object... values)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition compare(Comparator comparator, Field<?>... values)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition compare(Comparator comparator, Select<? extends Record> select)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition compare(Comparator comparator, QuantifiedSelect<? extends Record> select)
See the explicit comparison methods for details. Note, not all
Comparator
types are supported
@Support Condition equal(RowN row)
Row equality comparison predicates can be emulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2)
is equivalent to
A = 1 AND B = 2
@Support Condition equal(Record record)
equal(RowN)
@Support Condition equal(Object... values)
equal(RowN)
@Support Condition equal(Field<?>... values)
equal(RowN)
@Support Condition equal(Select<? extends Record> select)
equal(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA}) Condition equal(QuantifiedSelect<? extends Record> select)
@Support Condition eq(RowN row)
equal(RowN)
@Support Condition eq(Record record)
equal(RowN)
@Support Condition eq(Object... values)
equal(RowN)
@Support Condition eq(Field<?>... values)
equal(RowN)
@Support Condition eq(Select<? extends Record> select)
equal(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA}) Condition eq(QuantifiedSelect<? extends Record> select)
@Support Condition notEqual(RowN row)
Row non-equality comparison predicates can be emulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2)
is equivalent to
NOT(A = 1 AND B = 2)
@Support Condition notEqual(Record record)
notEqual(RowN)
@Support Condition notEqual(Object... values)
notEqual(RowN)
@Support Condition notEqual(Field<?>... values)
notEqual(RowN)
@Support Condition notEqual(Select<? extends Record> select)
notEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA}) Condition notEqual(QuantifiedSelect<? extends Record> select)
@Support Condition ne(RowN row)
notEqual(RowN)
@Support Condition ne(Record record)
notEqual(RowN)
@Support Condition ne(Object... values)
notEqual(RowN)
@Support Condition ne(Field<?>... values)
notEqual(RowN)
@Support Condition ne(Select<? extends Record> select)
notEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA}) Condition ne(QuantifiedSelect<? extends Record> select)
@Support Condition isDistinctFrom(RowN row)
@Support Condition isDistinctFrom(Record record)
@Support Condition isDistinctFrom(Object... values)
@Support Condition isDistinctFrom(Field<?>... values)
@Support Condition isNotDistinctFrom(RowN row)
@Support Condition isNotDistinctFrom(Record record)
@Support Condition isNotDistinctFrom(Object... values)
@Support Condition isNotDistinctFrom(Field<?>... values)
@Support Condition lessThan(RowN row)
Row order comparison predicates can be emulated in those
databases that do not support such predicates natively:
(A, B, C) < (1, 2, 3)
is equivalent to
A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
@Support Condition lessThan(Record record)
lessThan(RowN)
@Support Condition lessThan(Object... values)
lessThan(RowN)
@Support Condition lessThan(Field<?>... values)
lessThan(RowN)
@Support Condition lessThan(Select<? extends Record> select)
lessThan(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition lessThan(QuantifiedSelect<? extends Record> select)
@Support Condition lt(RowN row)
lessThan(RowN)
@Support Condition lt(Record record)
lessThan(RowN)
@Support Condition lt(Object... values)
lessThan(RowN)
@Support Condition lt(Field<?>... values)
lessThan(RowN)
@Support Condition lt(Select<? extends Record> select)
lessThan(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition lt(QuantifiedSelect<? extends Record> select)
@Support Condition lessOrEqual(RowN row)
Row order comparison predicates can be emulated in those
databases that do not support such predicates natively:
(A, B) <= (1, 2)
is equivalent to
A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
@Support Condition lessOrEqual(Record record)
lessOrEqual(RowN)
@Support Condition lessOrEqual(Object... values)
lessOrEqual(RowN)
@Support Condition lessOrEqual(Field<?>... values)
lessOrEqual(RowN)
@Support Condition lessOrEqual(Select<? extends Record> select)
lessOrEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition lessOrEqual(QuantifiedSelect<? extends Record> select)
@Support Condition le(RowN row)
lessOrEqual(RowN)
@Support Condition le(Record record)
lessOrEqual(RowN)
@Support Condition le(Object... values)
lessOrEqual(RowN)
@Support Condition le(Field<?>... values)
lessOrEqual(RowN)
@Support Condition le(Select<? extends Record> select)
lessOrEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition le(QuantifiedSelect<? extends Record> select)
@Support Condition greaterThan(RowN row)
Row order comparison predicates can be emulated in those
databases that do not support such predicates natively:
(A, B, C) > (1, 2, 3)
is equivalent to
A > 1 OR (A = 1 AND B > 2) OR (A = 1 AND B = 2 AND C > 3)
@Support Condition greaterThan(Record record)
greaterThan(RowN)
@Support Condition greaterThan(Object... values)
greaterThan(RowN)
@Support Condition greaterThan(Field<?>... values)
greaterThan(RowN)
@Support Condition greaterThan(Select<? extends Record> select)
greaterThan(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition greaterThan(QuantifiedSelect<? extends Record> select)
@Support Condition gt(RowN row)
greaterThan(RowN)
@Support Condition gt(Record record)
greaterThan(RowN)
@Support Condition gt(Object... values)
greaterThan(RowN)
@Support Condition gt(Field<?>... values)
greaterThan(RowN)
@Support Condition gt(Select<? extends Record> select)
greaterThan(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition gt(QuantifiedSelect<? extends Record> select)
@Support Condition greaterOrEqual(RowN row)
Row order comparison predicates can be emulated in those
databases that do not support such predicates natively:
(A, B) >= (1, 2)
is equivalent to
A > 1 OR (A = 1 AND B > 2) OR (A = 1 AND B = 2)
@Support Condition greaterOrEqual(Record record)
greaterOrEqual(RowN)
@Support Condition greaterOrEqual(Object... values)
greaterOrEqual(RowN)
@Support Condition greaterOrEqual(Field<?>... values)
greaterOrEqual(RowN)
@Support Condition greaterOrEqual(Select<? extends Record> select)
greaterOrEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition greaterOrEqual(QuantifiedSelect<? extends Record> select)
@Support Condition ge(RowN row)
greaterOrEqual(RowN)
@Support Condition ge(Record record)
greaterOrEqual(RowN)
@Support Condition ge(Object... values)
greaterOrEqual(RowN)
@Support Condition ge(Field<?>... values)
greaterOrEqual(RowN)
@Support Condition ge(Select<? extends Record> select)
greaterOrEqual(RowN)
@Support(value={ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE}) Condition ge(QuantifiedSelect<? extends Record> select)
@Support BetweenAndStepN between(Object... minValues)
between(RowN, RowN)
@Support BetweenAndStepN between(Field<?>... minValues)
between(RowN, RowN)
@Support BetweenAndStepN between(RowN minValue)
between(RowN, RowN)
@Support BetweenAndStepN between(Record minValue)
between(RowN, RowN)
@Support Condition between(RowN minValue, RowN maxValue)
This is the same as calling between(minValue).and(maxValue)
The expression A BETWEEN B AND C
is equivalent to the
expression A >= B AND A <= C
for those SQL dialects that do
not properly support the BETWEEN
predicate for row value
expressions
@Support Condition between(Record minValue, Record maxValue)
This is the same as calling between(minValue).and(maxValue)
between(RowN, RowN)
@Support BetweenAndStepN betweenSymmetric(Object... minValues)
betweenSymmetric(RowN, RowN)
@Support BetweenAndStepN betweenSymmetric(Field<?>... minValues)
betweenSymmetric(RowN, RowN)
@Support BetweenAndStepN betweenSymmetric(RowN minValue)
betweenSymmetric(RowN, RowN)
@Support BetweenAndStepN betweenSymmetric(Record minValue)
betweenSymmetric(RowN, RowN)
@Support Condition betweenSymmetric(RowN minValue, RowN maxValue)
This is the same as calling betweenSymmetric(minValue).and(maxValue)
The expression A BETWEEN SYMMETRIC B AND C
is equivalent to
the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
for those SQL dialects that do not properly support the
BETWEEN
predicate for row value expressions
@Support Condition betweenSymmetric(Record minValue, Record maxValue)
This is the same as calling betweenSymmetric(minValue).and(maxValue)
betweenSymmetric(RowN, RowN)
@Support BetweenAndStepN notBetween(Object... minValues)
between(RowN, RowN)
@Support BetweenAndStepN notBetween(Field<?>... minValues)
notBetween(RowN, RowN)
@Support BetweenAndStepN notBetween(RowN minValue)
notBetween(RowN, RowN)
@Support BetweenAndStepN notBetween(Record minValue)
notBetween(RowN, RowN)
@Support Condition notBetween(RowN minValue, RowN maxValue)
This is the same as calling notBetween(minValue).and(maxValue)
The expression A NOT BETWEEN B AND C
is equivalent to the
expression A < B OR A > C
for those SQL dialects that do
not properly support the BETWEEN
predicate for row value
expressions
@Support Condition notBetween(Record minValue, Record maxValue)
This is the same as calling notBetween(minValue).and(maxValue)
notBetween(RowN, RowN)
@Support BetweenAndStepN notBetweenSymmetric(Object... minValues)
notBetweenSymmetric(RowN, RowN)
@Support BetweenAndStepN notBetweenSymmetric(Field<?>... minValues)
notBetweenSymmetric(RowN, RowN)
@Support BetweenAndStepN notBetweenSymmetric(RowN minValue)
notBetweenSymmetric(RowN, RowN)
@Support BetweenAndStepN notBetweenSymmetric(Record minValue)
notBetweenSymmetric(RowN, RowN)
@Support Condition notBetweenSymmetric(RowN minValue, RowN maxValue)
This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
The expression A NOT BETWEEN SYMMETRIC B AND C
is equivalent
to the expression (A < B OR A > C) AND (A < C OR A > B)
for
those SQL dialects that do not properly support the BETWEEN
predicate for row value expressions
@Support Condition notBetweenSymmetric(Record minValue, Record maxValue)
This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
notBetweenSymmetric(RowN, RowN)
@Support Condition in(Collection<? extends RowN> rows)
Row IN predicates can be emulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4))
is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4))
, which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
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 tablesIN
predicates on unnested array bind variables@Support Condition in(Result<? extends Record> result)
Row IN predicates can be emulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4))
is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4))
, which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
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 tablesIN
predicates on unnested array bind variables@Support Condition in(RowN... rows)
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 tablesIN
predicates on unnested array bind variablesin(Collection)
@Support Condition in(Record... record)
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 tablesIN
predicates on unnested array bind variablesin(Collection)
@Support Condition in(Select<? extends Record> select)
in(Collection)
@Support Condition notIn(Collection<? extends RowN> rows)
Row NOT IN predicates can be emulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4))
is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))
, which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
Note that generating dynamic SQL with arbitrary-length
NOT 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:
NOT IN
predicates on temporary tablesNOT IN
predicates on unnested array bind variables@Support Condition notIn(Result<? extends Record> result)
Row NOT IN predicates can be emulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4))
is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))
, which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
Note that generating dynamic SQL with arbitrary-length
NOT 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:
NOT IN
predicates on temporary tablesNOT IN
predicates on unnested array bind variables@Support Condition notIn(RowN... rows)
Note that generating dynamic SQL with arbitrary-length
NOT 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:
NOT IN
predicates on temporary tablesNOT IN
predicates on unnested array bind variablesnotIn(Collection)
@Support Condition notIn(Record... record)
Note that generating dynamic SQL with arbitrary-length
NOT 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:
NOT IN
predicates on temporary tablesNOT IN
predicates on unnested array bind variablesnotIn(Collection)
@Support Condition notIn(Select<? extends Record> select)
notIn(Collection)
Copyright © 2019. All rights reserved.