Row1 (jOOQ 3.0.1 API)

All Superinterfaces:

QueryPart, Row, Serializable
```
@Generated(value="This class was generated using jOOQ-tools")
public interface Row1<T1>
extends Row
```
A model type for a row value expression with degree 1
Note: Not all databases support row value expressions, but many row value expression operations can be simulated on all databases. See relevant row value expression method Javadocs for details.

Author:

Lukas Eder

Method Summary

Methods
Modifier and Type	Method and Description
`BetweenAndStep1<T1>`	`between(Field<T1> minValue1)` Check if this row value expression is within a range of two other row value expressions
`BetweenAndStep1<T1>`	`between(Record1<T1> minValue)` Check if this row value expression is within a range of two records
`Condition`	`between(Record1<T1> minValue, Record1<T1> maxValue)` Check if this row value expression is within a range of two records This is the same as calling `between(minValue).and(maxValue)`
`BetweenAndStep1<T1>`	`between(Row1<T1> minValue)` Check if this row value expression is within a range of two other row value expressions
`Condition`	`between(Row1<T1> minValue, Row1<T1> maxValue)` Check if this row value expression is within a range of two other row value expressions 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
`BetweenAndStep1<T1>`	`between(T1 minValue1)` Check if this row value expression is within a range of two other row value expressions
`BetweenAndStep1<T1>`	`betweenSymmetric(Field<T1> minValue1)` Check if this row value expression is within a symmetric range of two other row value expressions
`BetweenAndStep1<T1>`	`betweenSymmetric(Record1<T1> minValue)` Check if this row value expression is within a symmetric range of two records
`Condition`	`betweenSymmetric(Record1<T1> minValue, Record1<T1> maxValue)` Check if this row value expression is within a symmetric range of two records This is the same as calling `betweenSymmetric(minValue).and(maxValue)`
`BetweenAndStep1<T1>`	`betweenSymmetric(Row1<T1> minValue)` Check if this row value expression is within a symmetric range of two other row value expressions
`Condition`	`betweenSymmetric(Row1<T1> minValue, Row1<T1> maxValue)` Check if this row value expression is within a symmetric range of two other row value expressions 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
`BetweenAndStep1<T1>`	`betweenSymmetric(T1 minValue1)` Check if this row value expression is within a symmetric range of two other row value expressions
`Condition`	`eq(Field<T1> t1)` Compare this row value expression with another row value expression for equality
`Condition`	`eq(Record1<T1> record)` Compare this row value expression with a record for equality
`Condition`	`eq(Row1<T1> row)` Compare this row value expression with another row value expression for equality
`Condition`	`eq(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for equality
`Condition`	`eq(T1 t1)` Compare this row value expression with another row value expression for equality
`Condition`	`equal(Field<T1> t1)` Compare this row value expression with another row value expression for equality
`Condition`	`equal(Record1<T1> record)` Compare this row value expression with a record for equality
`Condition`	`equal(Row1<T1> row)` Compare this row value expression with another row value expression for equality Row equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) = (1, 2)` is equivalent to `A = 1 AND B = 2`
`Condition`	`equal(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for equality
`Condition`	`equal(T1 t1)` Compare this row value expression with another row value expression for equality
`Field<T1>`	`field1()` Get the first field
`Condition`	`ge(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`ge(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`ge(Row1<T1> row)` Compare this row value expression with another row value expression for order
`Condition`	`ge(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`ge(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`greaterOrEqual(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`greaterOrEqual(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`greaterOrEqual(Row1<T1> row)` Compare this row value expression with another row value expression for order Row order comparison predicates can be simulated 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)`
`Condition`	`greaterOrEqual(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`greaterOrEqual(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`greaterThan(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`greaterThan(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`greaterThan(Row1<T1> row)` Compare this row value expression with another row value expression for order Row order comparison predicates can be simulated 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)`
`Condition`	`greaterThan(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`greaterThan(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`gt(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`gt(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`gt(Row1<T1> row)` Compare this row value expression with another row value expression for order
`Condition`	`gt(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`gt(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`in(Collection<? extends Row1<T1>> rows)` Compare this row value expression with a set of row value expressions for equality Row IN predicates can be simulated 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)`
`Condition`	`in(Record1<T1>... record)` Compare this row value expression with a set of records for equality
`Condition`	`in(Row1<T1>... rows)` Compare this row value expression with a set of row value expressions for equality
`Condition`	`in(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for equality
`Condition`	`le(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`le(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`le(Row1<T1> row)` Compare this row value expression with another row value expression for order
`Condition`	`le(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`le(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`lessOrEqual(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`lessOrEqual(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`lessOrEqual(Row1<T1> row)` Compare this row value expression with another row value expression for order Row order comparison predicates can be simulated 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)`
`Condition`	`lessOrEqual(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`lessOrEqual(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`lessThan(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`lessThan(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`lessThan(Row1<T1> row)` Compare this row value expression with another row value expression for order Row order comparison predicates can be simulated 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)`
`Condition`	`lessThan(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`lessThan(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`lt(Field<T1> t1)` Compare this row value expression with another row value expression for order
`Condition`	`lt(Record1<T1> record)` Compare this row value expression with a record for order
`Condition`	`lt(Row1<T1> row)` Compare this row value expression with another row value expression for order
`Condition`	`lt(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for order
`Condition`	`lt(T1 t1)` Compare this row value expression with another row value expression for order
`Condition`	`ne(Field<T1> t1)` Compare this row value expression with another row value expression for
`Condition`	`ne(Record1<T1> record)` Compare this row value expression with a record for non-equality
`Condition`	`ne(Row1<T1> row)` Compare this row value expression with another row value expression for non-equality
`Condition`	`ne(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for non-equality
`Condition`	`ne(T1 t1)` Compare this row value expression with another row value expression for non-equality
`BetweenAndStep1<T1>`	`notBetween(Field<T1> minValue1)` Check if this row value expression is not within a range of two other row value expressions
`BetweenAndStep1<T1>`	`notBetween(Record1<T1> minValue)` Check if this row value expression is within a range of two records
`Condition`	`notBetween(Record1<T1> minValue, Record1<T1> maxValue)` Check if this row value expression is within a range of two records This is the same as calling `notBetween(minValue).and(maxValue)`
`BetweenAndStep1<T1>`	`notBetween(Row1<T1> minValue)` Check if this row value expression is not within a range of two other row value expressions
`Condition`	`notBetween(Row1<T1> minValue, Row1<T1> maxValue)` Check if this row value expression is not within a range of two other row value expressions 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
`BetweenAndStep1<T1>`	`notBetween(T1 minValue1)` Check if this row value expression is not within a range of two other row value expressions
`BetweenAndStep1<T1>`	`notBetweenSymmetric(Field<T1> minValue1)` Check if this row value expression is not within a symmetric range of two other row value expressions
`BetweenAndStep1<T1>`	`notBetweenSymmetric(Record1<T1> minValue)` Check if this row value expression is not within a symmetric range of two records
`Condition`	`notBetweenSymmetric(Record1<T1> minValue, Record1<T1> maxValue)` Check if this row value expression is not within a symmetric range of two records This is the same as calling `notBetweenSymmetric(minValue).and(maxValue)`
`BetweenAndStep1<T1>`	`notBetweenSymmetric(Row1<T1> minValue)` Check if this row value expression is not within a symmetric range of two other row value expressions
`Condition`	`notBetweenSymmetric(Row1<T1> minValue, Row1<T1> maxValue)` Check if this row value expression is not within a symmetric range of two other row value expressions 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
`BetweenAndStep1<T1>`	`notBetweenSymmetric(T1 minValue1)` Check if this row value expression is not within a symmetric range of two other row value expressions
`Condition`	`notEqual(Field<T1> t1)` Compare this row value expression with another row value expression for non-equality
`Condition`	`notEqual(Record1<T1> record)` Compare this row value expression with a record for non-equality
`Condition`	`notEqual(Row1<T1> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	`notEqual(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for non-equality
`Condition`	`notEqual(T1 t1)` Compare this row value expression with another row value expression for non-equality
`Condition`	`notIn(Collection<? extends Row1<T1>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated 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))`
`Condition`	`notIn(Record1<T1>... record)` Compare this row value expression with a set of records for non-equality
`Condition`	`notIn(Row1<T1>... rows)` Compare this row value expression with a set of row value expressions for equality
`Condition`	`notIn(Select<? extends Record1<T1>> select)` Compare this row value expression with a subselect for non-equality

Methods inherited from interface org.jooq.Row
dataType, dataType, dataTypes, field, field, field, fields, indexOf, indexOf, isNotNull, isNull, size, type, type, types

Methods inherited from interface org.jooq.QueryPart
equals, hashCode, toString

- Method Detail
  - field1
```
Field<T1> field1()
```
    Get the first field
  - equal
```
@Support
Condition equal(Row1<T1> row)
```
    Compare this row value expression with another row value expression for equality
    Row equality comparison predicates can be simulated in those databases that do not support such predicates natively: (A, B) = (1, 2) is equivalent to A = 1 AND B = 2
  - equal
```
@Support
Condition equal(Record1<T1> record)
```
    Compare this row value expression with a record for equality
    
    See Also:
    equal(Row1)
  - equal
```
@Support
Condition equal(T1 t1)
```
    Compare this row value expression with another row value expression for equality
    
    See Also:
    equal(Row1)
  - equal
```
@Support
Condition equal(Field<T1> t1)
```
    Compare this row value expression with another row value expression for equality
    
    See Also:
    equal(Row1)
  - equal
```
@Support(value={HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition equal(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for equality
    
    See Also:
    equal(Row1)
  - eq
```
@Support
Condition eq(Row1<T1> row)
```
    Compare this row value expression with another row value expression for equality
    
    See Also:
    equal(Row1)
  - eq
```
@Support
Condition eq(Record1<T1> record)
```
    Compare this row value expression with a record for equality
    
    See Also:
    equal(Row1)
  - eq
```
@Support
Condition eq(T1 t1)
```
    Compare this row value expression with another row value expression for equality
    
    See Also:
    equal(Row1)
  - eq
```
@Support
Condition eq(Field<T1> t1)
```
    Compare this row value expression with another row value expression for equality
    
    See Also:
    equal(Row1)
  - eq
```
@Support(value={HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition eq(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for equality
    
    See Also:
    equal(Row1)
  - notEqual
```
@Support
Condition notEqual(Row1<T1> row)
```
    Compare this row value expression with another row value expression for non-equality
    Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: (A, B) <> (1, 2) is equivalent to NOT(A = 1 AND B = 2)
  - notEqual
```
@Support
Condition notEqual(Record1<T1> record)
```
    Compare this row value expression with a record for non-equality
    
    See Also:
    notEqual(Row1)
  - notEqual
```
@Support
Condition notEqual(T1 t1)
```
    Compare this row value expression with another row value expression for non-equality
    
    See Also:
    notEqual(Row1)
  - notEqual
```
@Support
Condition notEqual(Field<T1> t1)
```
    Compare this row value expression with another row value expression for non-equality
    
    See Also:
    notEqual(Row1)
  - notEqual
```
@Support(value={HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition notEqual(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for non-equality
    
    See Also:
    notEqual(Row1)
  - ne
```
@Support
Condition ne(Row1<T1> row)
```
    Compare this row value expression with another row value expression for non-equality
    
    See Also:
    notEqual(Row1)
  - ne
```
@Support
Condition ne(Record1<T1> record)
```
    Compare this row value expression with a record for non-equality
    
    See Also:
    notEqual(Row1)
  - ne
```
@Support
Condition ne(T1 t1)
```
    Compare this row value expression with another row value expression for non-equality
    
    See Also:
    notEqual(Row1)
  - ne
```
@Support
Condition ne(Field<T1> t1)
```
    Compare this row value expression with another row value expression for
    
    See Also:
    notEqual(Row1)
  - ne
```
@Support(value={HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition ne(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for non-equality
    
    See Also:
    notEqual(Row1)
  - lessThan
```
@Support
Condition lessThan(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    Row order comparison predicates can be simulated 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)
  - lessThan
```
@Support
Condition lessThan(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    lessThan(Row1)
  - lessThan
```
@Support
Condition lessThan(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessThan(Row1)
  - lessThan
```
@Support
Condition lessThan(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessThan(Row1)
  - lessThan
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition lessThan(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    lessThan(Row1)
  - lt
```
@Support
Condition lt(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessThan(Row1)
  - lt
```
@Support
Condition lt(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    lessThan(Row1)
  - lt
```
@Support
Condition lt(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessThan(Row1)
  - lt
```
@Support
Condition lt(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessThan(Row1)
  - lt
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition lt(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    lessThan(Row1)
  - lessOrEqual
```
@Support
Condition lessOrEqual(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    Row order comparison predicates can be simulated 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)
  - lessOrEqual
```
@Support
Condition lessOrEqual(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    lessOrEqual(Row1)
  - lessOrEqual
```
@Support
Condition lessOrEqual(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessOrEqual(Row1)
  - lessOrEqual
```
@Support
Condition lessOrEqual(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessOrEqual(Row1)
  - lessOrEqual
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition lessOrEqual(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    lessOrEqual(Row1)
  - le
```
@Support
Condition le(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessOrEqual(Row1)
  - le
```
@Support
Condition le(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    lessOrEqual(Row1)
  - le
```
@Support
Condition le(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessOrEqual(Row1)
  - le
```
@Support
Condition le(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    lessOrEqual(Row1)
  - le
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition le(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    lessOrEqual(Row1)
  - greaterThan
```
@Support
Condition greaterThan(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    Row order comparison predicates can be simulated 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)
  - greaterThan
```
@Support
Condition greaterThan(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    greaterThan(Row1)
  - greaterThan
```
@Support
Condition greaterThan(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterThan(Row1)
  - greaterThan
```
@Support
Condition greaterThan(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterThan(Row1)
  - greaterThan
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition greaterThan(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    greaterThan(Row1)
  - gt
```
@Support
Condition gt(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterThan(Row1)
  - gt
```
@Support
Condition gt(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    greaterThan(Row1)
  - gt
```
@Support
Condition gt(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterThan(Row1)
  - gt
```
@Support
Condition gt(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterThan(Row1)
  - gt
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition gt(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    greaterThan(Row1)
  - greaterOrEqual
```
@Support
Condition greaterOrEqual(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    Row order comparison predicates can be simulated 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)
  - greaterOrEqual
```
@Support
Condition greaterOrEqual(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    greaterOrEqual(Row1)
  - greaterOrEqual
```
@Support
Condition greaterOrEqual(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterOrEqual(Row1)
  - greaterOrEqual
```
@Support
Condition greaterOrEqual(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterOrEqual(Row1)
  - greaterOrEqual
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition greaterOrEqual(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    greaterOrEqual(Row1)
  - ge
```
@Support
Condition ge(Row1<T1> row)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterOrEqual(Row1)
  - ge
```
@Support
Condition ge(Record1<T1> record)
```
    Compare this row value expression with a record for order
    
    See Also:
    greaterOrEqual(Row1)
  - ge
```
@Support
Condition ge(T1 t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterOrEqual(Row1)
  - ge
```
@Support
Condition ge(Field<T1> t1)
```
    Compare this row value expression with another row value expression for order
    
    See Also:
    greaterOrEqual(Row1)
  - ge
```
@Support(value={HSQLDB,MYSQL,POSTGRES})
Condition ge(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for order
    
    See Also:
    greaterOrEqual(Row1)
  - between
```
@Support
BetweenAndStep1<T1> between(T1 minValue1)
```
    Check if this row value expression is within a range of two other row value expressions
    
    See Also:
    between(Row1, Row1)
  - between
```
@Support
BetweenAndStep1<T1> between(Field<T1> minValue1)
```
    Check if this row value expression is within a range of two other row value expressions
    
    See Also:
    between(Row1, Row1)
  - between
```
@Support
BetweenAndStep1<T1> between(Row1<T1> minValue)
```
    Check if this row value expression is within a range of two other row value expressions
    
    See Also:
    between(Row1, Row1)
  - between
```
@Support
BetweenAndStep1<T1> between(Record1<T1> minValue)
```
    Check if this row value expression is within a range of two records
    
    See Also:
    between(Row1, Row1)
  - between
```
@Support
Condition between(Row1<T1> minValue,
                        Row1<T1> maxValue)
```
    Check if this row value expression is within a range of two other row value expressions
    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
  - between
```
@Support
Condition between(Record1<T1> minValue,
                        Record1<T1> maxValue)
```
    Check if this row value expression is within a range of two records
    This is the same as calling between(minValue).and(maxValue)
    
    See Also:
    between(Row1, Row1)
  - betweenSymmetric
```
@Support
BetweenAndStep1<T1> betweenSymmetric(T1 minValue1)
```
    Check if this row value expression is within a symmetric range of two other row value expressions
    
    See Also:
    betweenSymmetric(Row1, Row1)
  - betweenSymmetric
```
@Support
BetweenAndStep1<T1> betweenSymmetric(Field<T1> minValue1)
```
    Check if this row value expression is within a symmetric range of two other row value expressions
    
    See Also:
    betweenSymmetric(Row1, Row1)
  - betweenSymmetric
```
@Support
BetweenAndStep1<T1> betweenSymmetric(Row1<T1> minValue)
```
    Check if this row value expression is within a symmetric range of two other row value expressions
    
    See Also:
    betweenSymmetric(Row1, Row1)
  - betweenSymmetric
```
@Support
BetweenAndStep1<T1> betweenSymmetric(Record1<T1> minValue)
```
    Check if this row value expression is within a symmetric range of two records
    
    See Also:
    betweenSymmetric(Row1, Row1)
  - betweenSymmetric
```
@Support
Condition betweenSymmetric(Row1<T1> minValue,
                                 Row1<T1> maxValue)
```
    Check if this row value expression is within a symmetric range of two other row value expressions
    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
  - betweenSymmetric
```
@Support
Condition betweenSymmetric(Record1<T1> minValue,
                                 Record1<T1> maxValue)
```
    Check if this row value expression is within a symmetric range of two records
    This is the same as calling betweenSymmetric(minValue).and(maxValue)
    
    See Also:
    betweenSymmetric(Row1, Row1)
  - notBetween
```
@Support
BetweenAndStep1<T1> notBetween(T1 minValue1)
```
    Check if this row value expression is not within a range of two other row value expressions
    
    See Also:
    between(Row1, Row1)
  - notBetween
```
@Support
BetweenAndStep1<T1> notBetween(Field<T1> minValue1)
```
    Check if this row value expression is not within a range of two other row value expressions
    
    See Also:
    notBetween(Row1, Row1)
  - notBetween
```
@Support
BetweenAndStep1<T1> notBetween(Row1<T1> minValue)
```
    Check if this row value expression is not within a range of two other row value expressions
    
    See Also:
    notBetween(Row1, Row1)
  - notBetween
```
@Support
BetweenAndStep1<T1> notBetween(Record1<T1> minValue)
```
    Check if this row value expression is within a range of two records
    
    See Also:
    notBetween(Row1, Row1)
  - notBetween
```
@Support
Condition notBetween(Row1<T1> minValue,
                           Row1<T1> maxValue)
```
    Check if this row value expression is not within a range of two other row value expressions
    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
  - notBetween
```
@Support
Condition notBetween(Record1<T1> minValue,
                           Record1<T1> maxValue)
```
    Check if this row value expression is within a range of two records
    This is the same as calling notBetween(minValue).and(maxValue)
    
    See Also:
    notBetween(Row1, Row1)
  - notBetweenSymmetric
```
@Support
BetweenAndStep1<T1> notBetweenSymmetric(T1 minValue1)
```
    Check if this row value expression is not within a symmetric range of two other row value expressions
    
    See Also:
    notBetweenSymmetric(Row1, Row1)
  - notBetweenSymmetric
```
@Support
BetweenAndStep1<T1> notBetweenSymmetric(Field<T1> minValue1)
```
    Check if this row value expression is not within a symmetric range of two other row value expressions
    
    See Also:
    notBetweenSymmetric(Row1, Row1)
  - notBetweenSymmetric
```
@Support
BetweenAndStep1<T1> notBetweenSymmetric(Row1<T1> minValue)
```
    Check if this row value expression is not within a symmetric range of two other row value expressions
    
    See Also:
    notBetweenSymmetric(Row1, Row1)
  - notBetweenSymmetric
```
@Support
BetweenAndStep1<T1> notBetweenSymmetric(Record1<T1> minValue)
```
    Check if this row value expression is not within a symmetric range of two records
    
    See Also:
    notBetweenSymmetric(Row1, Row1)
  - notBetweenSymmetric
```
@Support
Condition notBetweenSymmetric(Row1<T1> minValue,
                                    Row1<T1> maxValue)
```
    Check if this row value expression is not within a symmetric range of two other row value expressions
    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
  - notBetweenSymmetric
```
@Support
Condition notBetweenSymmetric(Record1<T1> minValue,
                                    Record1<T1> maxValue)
```
    Check if this row value expression is not within a symmetric range of two records
    This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
    
    See Also:
    notBetweenSymmetric(Row1, Row1)
  - in
```
@Support
Condition in(Collection<? extends Row1<T1>> rows)
```
    Compare this row value expression with a set of row value expressions for equality
    Row IN predicates can be simulated 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)
  - in
```
@Support
Condition in(Row1<T1>... rows)
```
    Compare this row value expression with a set of row value expressions for equality
    
    See Also:
    in(Collection)
  - in
```
@Support
Condition in(Record1<T1>... record)
```
    Compare this row value expression with a set of records for equality
    
    See Also:
    in(Collection)
  - in
```
@Support(value={DB2,HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition in(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for equality
    
    See Also:
    in(Collection)
  - notIn
```
@Support
Condition notIn(Collection<? extends Row1<T1>> rows)
```
    Compare this row value expression with a set of row value expressions for equality
    Row NOT IN predicates can be simulated 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))
  - notIn
```
@Support
Condition notIn(Row1<T1>... rows)
```
    Compare this row value expression with a set of row value expressions for equality
    
    See Also:
    notIn(Collection)
  - notIn
```
@Support
Condition notIn(Record1<T1>... record)
```
    Compare this row value expression with a set of records for non-equality
    
    See Also:
    notIn(Collection)
  - notIn
```
@Support(value={DB2,HSQLDB,MYSQL,ORACLE,POSTGRES})
Condition notIn(Select<? extends Record1<T1>> select)
```
    Compare this row value expression with a subselect for non-equality
    
    See Also:
    notIn(Collection)

Interface Row1<T1>

Method Summary

Methods inherited from interface org.jooq.Row

Methods inherited from interface org.jooq.QueryPart

Method Detail

field1

equal

equal

equal

equal

equal

eq

eq

eq

eq

eq

notEqual

notEqual

notEqual

notEqual

notEqual

ne

ne

ne

ne

ne

lessThan

lessThan

lessThan

lessThan

lessThan

lt

lt

lt

lt

lt

lessOrEqual

lessOrEqual

lessOrEqual

lessOrEqual

lessOrEqual

le

le

le

le

le

greaterThan

greaterThan

greaterThan

greaterThan

greaterThan

gt

gt

gt

gt

gt

greaterOrEqual

greaterOrEqual

greaterOrEqual

greaterOrEqual

greaterOrEqual

ge

ge

ge

ge

ge

between

between

between

between

between

between

betweenSymmetric

betweenSymmetric

betweenSymmetric

betweenSymmetric

betweenSymmetric

betweenSymmetric

notBetween

notBetween