http://www.jooq.org/jooq: jOOQ effectively combines complex SQL, typesafety, source code generation, active records, stored procedures, advanced data types, and Java in a fluent, intuitive DSL. 
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Other licenses:
 * -----------------------------------------------------------------------------
 * Commercial licenses for this work are available. These replace the above
 * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
 * database integrations.
 *
 * For more information, please visit: http://www.jooq.org/licenses
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package org.jooq;

import java.util.Collection;

import org.jooq.conf.Settings;
import org.jooq.impl.DSL;

import org.jetbrains.annotations.NotNull;


A row value expression.


Row value expressions are mainly useful for use in predicates, when comparing
several values in one go, which can be more elegant than expanding the row
value expression predicate in other equivalent syntaxes. This is especially
true for non-equality predicates. For instance, the following two predicates
are equivalent in SQL:



(A, B) > (X, Y)
(A > X) OR (A = X AND B > Y)




Example:



// Assuming import static org.jooq.impl.DSL.*;
using(configuration)
   .select()
   .from(CUSTOMER)
   .where(row(CUSTOMER.FIRST_NAME, CUSTOMER.LAST_NAME).in(
       select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME).from(ACTOR)
   ))
   .fetch();




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.

 Instances can be created using DSL.row(Object...) and overloads. 
Author:Lukas Eder
/**
 * A row value expression.
 * <p>
 * Row value expressions are mainly useful for use in predicates, when comparing
 * several values in one go, which can be more elegant than expanding the row
 * value expression predicate in other equivalent syntaxes. This is especially
 * true for non-equality predicates. For instance, the following two predicates
 * are equivalent in SQL:
 * <p>
 * <code><pre>
 * (A, B) &gt; (X, Y)
 * (A &gt; X) OR (A = X AND B &gt; Y)
 * </pre></code>
 * <p>
 * <strong>Example:</strong>
 * <p>
 * <code><pre>
 * // Assuming import static org.jooq.impl.DSL.*;
 *
 * using(configuration)
 *    .select()
 *    .from(CUSTOMER)
 *    .where(row(CUSTOMER.FIRST_NAME, CUSTOMER.LAST_NAME).in(
 *        select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME).from(ACTOR)
 *    ))
 *    .fetch();
 * </pre></code>
 * <p>
 * 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.
 * <p>
 * Instances can be created using {@link DSL#row(Object...)} and overloads.
 *
 * @author Lukas Eder
 */
public interface Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> extends Row {

    // ------------------------------------------------------------------------
    // Field accessors
    // ------------------------------------------------------------------------

    
Get the first field.

/**
     * Get the first field.
     */
    @NotNull
    Field<T1> field1();

    
Get the second field.

/**
     * Get the second field.
     */
    @NotNull
    Field<T2> field2();

    
Get the third field.

/**
     * Get the third field.
     */
    @NotNull
    Field<T3> field3();

    
Get the fourth field.

/**
     * Get the fourth field.
     */
    @NotNull
    Field<T4> field4();

    
Get the fifth field.

/**
     * Get the fifth field.
     */
    @NotNull
    Field<T5> field5();

    
Get the sixth field.

/**
     * Get the sixth field.
     */
    @NotNull
    Field<T6> field6();

    
Get the seventh field.

/**
     * Get the seventh field.
     */
    @NotNull
    Field<T7> field7();

    
Get the eighth field.

/**
     * Get the eighth field.
     */
    @NotNull
    Field<T8> field8();

    
Get the ninth field.

/**
     * Get the ninth field.
     */
    @NotNull
    Field<T9> field9();

    
Get the tenth field.

/**
     * Get the tenth field.
     */
    @NotNull
    Field<T10> field10();

    
Get the eleventh field.

/**
     * Get the eleventh field.
     */
    @NotNull
    Field<T11> field11();

    
Get the twelfth field.

/**
     * Get the twelfth field.
     */
    @NotNull
    Field<T12> field12();

    
Get the thirteenth field.

/**
     * Get the thirteenth field.
     */
    @NotNull
    Field<T13> field13();

    
Get the fourteenth field.

/**
     * Get the fourteenth field.
     */
    @NotNull
    Field<T14> field14();

    
Get the fifteenth field.

/**
     * Get the fifteenth field.
     */
    @NotNull
    Field<T15> field15();

    
Get the sixteenth field.

/**
     * Get the sixteenth field.
     */
    @NotNull
    Field<T16> field16();

    
Get the seventeenth field.

/**
     * Get the seventeenth field.
     */
    @NotNull
    Field<T17> field17();

    
Get the eighteenth field.

/**
     * Get the eighteenth field.
     */
    @NotNull
    Field<T18> field18();

    // ------------------------------------------------------------------------
    // Generic comparison predicates
    // ------------------------------------------------------------------------

    
Compare this row value expression with another row value expression
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with another row value expression
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Row18)
     * @see #notEqual(Row18)
     * @see #lessThan(Row18)
     * @see #lessOrEqual(Row18)
     * @see #greaterThan(Row18)
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with a record
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Record18)
     * @see #notEqual(Record18)
     * @see #lessThan(Record18)
     * @see #lessOrEqual(Record18)
     * @see #greaterThan(Record18)
     * @see #greaterOrEqual(Record18)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with another row value expression
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Row18)
     * @see #notEqual(Row18)
     * @see #lessThan(Row18)
     * @see #lessOrEqual(Row18)
     * @see #greaterThan(Row18)
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with another row value expression
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Row18)
     * @see #notEqual(Row18)
     * @see #lessThan(Row18)
     * @see #lessOrEqual(Row18)
     * @see #greaterThan(Row18)
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with a subselect
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Select)
     * @see #notEqual(Select)
     * @see #lessThan(Select)
     * @see #lessOrEqual(Select)
     * @see #greaterThan(Select)
     * @see #greaterOrEqual(Select)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect
using a dynamic comparator.

 See the explicit comparison methods for details. Note, not all Comparator types are supported 
See Also:
/**
     * Compare this row value expression with a subselect
     * using a dynamic comparator.
     * <p>
     * See the explicit comparison methods for details. Note, not all
     * {@link Comparator} types are supported
     *
     * @see #equal(Select)
     * @see #notEqual(Select)
     * @see #lessThan(Select)
     * @see #lessOrEqual(Select)
     * @see #greaterThan(Select)
     * @see #greaterOrEqual(Select)
     */
    @NotNull
    @Support
    Condition compare(Comparator comparator, QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    // ------------------------------------------------------------------------
    // Equal / Not equal comparison predicates
    // ------------------------------------------------------------------------

    
Compare this row value expression with another row value expression for
equality.


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

/**
     * Compare this row value expression with another row value expression for
     * equality.
     * <p>
     * Row equality comparison predicates can be emulated in those databases
     * that do not support such predicates natively:
     * <code>(A, B) = (1, 2)</code> is equivalent to
     * <code>A = 1 AND B = 2</code>
     */
    @NotNull
    @Support
    Condition equal(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with a record for equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition equal(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with another row value expression for
     * equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition equal(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with another row value expression for
     * equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition equal(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with a subselect for equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition equal(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for equality.

See Also:
/**
     * Compare this row value expression with a subselect for equality.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition equal(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with another row value expression for
     * equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition eq(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with a record for equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition eq(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with another row value expression for
     * equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition eq(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with another row value expression for
     * equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition eq(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for equality.

See Also:
  • equal(Row18)
/**
     * Compare this row value expression with a subselect for equality.
     *
     * @see #equal(Row18)
     */
    @NotNull
    @Support
    Condition eq(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for equality.

See Also:
/**
     * Compare this row value expression with a subselect for equality.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition eq(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
non-equality.


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)

/**
     * Compare this row value expression with another row value expression for
     * non-equality.
     * <p>
     * Row non-equality comparison predicates can be emulated in those
     * databases that do not support such predicates natively:
     * <code>(A, B) &lt;&gt; (1, 2)</code> is equivalent to
     * <code>NOT(A = 1 AND B = 2)</code>
     */
    @NotNull
    @Support
    Condition notEqual(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for non-equality

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with a record for non-equality
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition notEqual(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for.
non-equality

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with another row value expression for.
     * non-equality
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition notEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with a subselect for non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition notEqual(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for non-equality.

See Also:
/**
     * Compare this row value expression with a subselect for non-equality.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition notEqual(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition ne(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with a record for non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition ne(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition ne(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for non-equality.

See Also:
  • notEqual(Row18)
/**
     * Compare this row value expression with a subselect for non-equality.
     *
     * @see #notEqual(Row18)
     */
    @NotNull
    @Support
    Condition ne(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for non-equality.

See Also:
/**
     * Compare this row value expression with a subselect for non-equality.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition ne(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    // ------------------------------------------------------------------------
    // [NOT] DISTINCT predicates
    // ------------------------------------------------------------------------

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isDistinctFrom(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isDistinctFrom(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isDistinctFrom(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isDistinctFrom(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isDistinctFrom(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isNotDistinctFrom(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isNotDistinctFrom(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isNotDistinctFrom(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isNotDistinctFrom(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with another row value expression for
distinctness.

/**
     * Compare this row value expression with another row value expression for
     * distinctness.
     */
    @NotNull
    @Support
    Condition isNotDistinctFrom(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    // ------------------------------------------------------------------------
    // Ordering comparison predicates
    // ------------------------------------------------------------------------

    
Compare this row value expression with another row value expression for
order.


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)

/**
     * Compare this row value expression with another row value expression for
     * order.
     * <p>
     * Row order comparison predicates can be emulated in those
     * databases that do not support such predicates natively:
     * <code>(A, B, C) &lt; (1, 2, 3)</code> is equivalent to
     * <code>A &lt; 1 OR (A = 1 AND B &lt; 2) OR (A = 1 AND B = 2 AND C &lt; 3)</code>
     */
    @NotNull
    @Support
    Condition lessThan(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lessThan(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lessThan(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lessThan(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lessThan(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition lessThan(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lt(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lt(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lt(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lt(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • lessThan(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #lessThan(Row18)
     */
    @NotNull
    @Support
    Condition lt(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition lt(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.


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)

/**
     * Compare this row value expression with another row value expression for
     * order.
     * <p>
     * Row order comparison predicates can be emulated in those
     * databases that do not support such predicates natively:
     * <code>(A, B) &lt;= (1, 2)</code> is equivalent to
     * <code>A &lt; 1 OR (A = 1 AND B &lt; 2) OR (A = 1 AND B = 2)</code>
     */
    @NotNull
    @Support
    Condition lessOrEqual(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition lessOrEqual(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition lessOrEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition lessOrEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition lessOrEqual(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition lessOrEqual(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition le(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition le(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition le(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition le(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • lessOrEqual(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #lessOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition le(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition le(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.


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)

/**
     * Compare this row value expression with another row value expression for
     * order.
     * <p>
     * Row order comparison predicates can be emulated in those
     * databases that do not support such predicates natively:
     * <code>(A, B, C) &gt; (1, 2, 3)</code> is equivalent to
     * <code>A &gt; 1 OR (A = 1 AND B &gt; 2) OR (A = 1 AND B = 2 AND C &gt; 3)</code>
     */
    @NotNull
    @Support
    Condition greaterThan(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition greaterThan(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition greaterThan(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition greaterThan(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition greaterThan(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition greaterThan(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition gt(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition gt(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition gt(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition gt(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • greaterThan(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #greaterThan(Row18)
     */
    @NotNull
    @Support
    Condition gt(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition gt(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.


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)

/**
     * Compare this row value expression with another row value expression for
     * order.
     * <p>
     * Row order comparison predicates can be emulated in those
     * databases that do not support such predicates natively:
     * <code>(A, B) &gt;= (1, 2)</code> is equivalent to
     * <code>A &gt; 1 OR (A = 1 AND B &gt; 2) OR (A = 1 AND B = 2)</code>
     */
    @NotNull
    @Support
    Condition greaterOrEqual(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition greaterOrEqual(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition greaterOrEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition greaterOrEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition greaterOrEqual(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition greaterOrEqual(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition ge(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> row);

    
Compare this row value expression with a record for order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with a record for order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition ge(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> record);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition ge(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);

    
Compare this row value expression with another row value expression for
order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with another row value expression for
     * order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition ge(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16, Field<T17> t17, Field<T18> t18);

    
Compare this row value expression with a subselect for order.

See Also:
  • greaterOrEqual(Row18)
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see #greaterOrEqual(Row18)
     */
    @NotNull
    @Support
    Condition ge(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a subselect for order.

See Also:
/**
     * Compare this row value expression with a subselect for order.
     *
     * @see DSL#all(Field)
     * @see DSL#all(Select)
     * @see DSL#all(Object...)
     * @see DSL#any(Field)
     * @see DSL#any(Select)
     * @see DSL#any(Object...)
     */
    @NotNull
    @Support
    Condition ge(QuantifiedSelect<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    // ------------------------------------------------------------------------
    // [NOT] BETWEEN predicates
    // ------------------------------------------------------------------------

    
Check if this row value expression is within a range of two other row
value expressions.

See Also:
  • between(Row18, Row18)
/**
     * Check if this row value expression is within a range of two other row
     * value expressions.
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> between(T1 minValue1, T2 minValue2, T3 minValue3, T4 minValue4, T5 minValue5, T6 minValue6, T7 minValue7, T8 minValue8, T9 minValue9, T10 minValue10, T11 minValue11, T12 minValue12, T13 minValue13, T14 minValue14, T15 minValue15, T16 minValue16, T17 minValue17, T18 minValue18);

    
Check if this row value expression is within a range of two other row
value expressions.

See Also:
  • between(Row18, Row18)
/**
     * Check if this row value expression is within a range of two other row
     * value expressions.
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> between(Field<T1> minValue1, Field<T2> minValue2, Field<T3> minValue3, Field<T4> minValue4, Field<T5> minValue5, Field<T6> minValue6, Field<T7> minValue7, Field<T8> minValue8, Field<T9> minValue9, Field<T10> minValue10, Field<T11> minValue11, Field<T12> minValue12, Field<T13> minValue13, Field<T14> minValue14, Field<T15> minValue15, Field<T16> minValue16, Field<T17> minValue17, Field<T18> minValue18);

    
Check if this row value expression is within a range of two other row
value expressions.

See Also:
  • between(Row18, Row18)
/**
     * Check if this row value expression is within a range of two other row
     * value expressions.
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> between(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
Check if this row value expression is within a range of two records.

See Also:
  • between(Row18, Row18)
/**
     * Check if this row value expression is within a range of two records.
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> between(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
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

/**
     * Check if this row value expression is within a range of two other row
     * value expressions.
     * <p>
     * This is the same as calling <code>between(minValue).and(maxValue)</code>
     * <p>
     * The expression <code>A BETWEEN B AND C</code> is equivalent to the
     * expression <code>A &gt;= B AND A &lt;= C</code> for those SQL dialects that do
     * not properly support the <code>BETWEEN</code> predicate for row value
     * expressions
     */
    @NotNull
    @Support
    Condition between(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                      Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> 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(Row18, Row18)
/**
     * Check if this row value expression is within a range of two records.
     * <p>
     * This is the same as calling <code>between(minValue).and(maxValue)</code>
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    Condition between(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                      Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> maxValue);

    
Check if this row value expression is within a symmetric range of two
other row value expressions.

See Also:
  • betweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is within a symmetric range of two
     * other row value expressions.
     *
     * @see #betweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> betweenSymmetric(T1 minValue1, T2 minValue2, T3 minValue3, T4 minValue4, T5 minValue5, T6 minValue6, T7 minValue7, T8 minValue8, T9 minValue9, T10 minValue10, T11 minValue11, T12 minValue12, T13 minValue13, T14 minValue14, T15 minValue15, T16 minValue16, T17 minValue17, T18 minValue18);

    
Check if this row value expression is within a symmetric range of two
other row value expressions.

See Also:
  • betweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is within a symmetric range of two
     * other row value expressions.
     *
     * @see #betweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> betweenSymmetric(Field<T1> minValue1, Field<T2> minValue2, Field<T3> minValue3, Field<T4> minValue4, Field<T5> minValue5, Field<T6> minValue6, Field<T7> minValue7, Field<T8> minValue8, Field<T9> minValue9, Field<T10> minValue10, Field<T11> minValue11, Field<T12> minValue12, Field<T13> minValue13, Field<T14> minValue14, Field<T15> minValue15, Field<T16> minValue16, Field<T17> minValue17, Field<T18> minValue18);

    
Check if this row value expression is within a symmetric range of two
other row value expressions.

See Also:
  • betweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is within a symmetric range of two
     * other row value expressions.
     *
     * @see #betweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> betweenSymmetric(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
Check if this row value expression is within a symmetric range of two
records.

See Also:
  • betweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is within a symmetric range of two
     * records.
     *
     * @see #betweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> betweenSymmetric(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
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

/**
     * Check if this row value expression is within a symmetric range of two
     * other row value expressions.
     * <p>
     * This is the same as calling <code>betweenSymmetric(minValue).and(maxValue)</code>
     * <p>
     * The expression <code>A BETWEEN SYMMETRIC B AND C</code> is equivalent to
     * the expression <code>(A &gt;= B AND A &lt;= C) OR (A &gt;= C AND A &lt;= B)</code>
     * for those SQL dialects that do not properly support the
     * <code>BETWEEN</code> predicate for row value expressions
     */
    @NotNull
    @Support
    Condition betweenSymmetric(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                               Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> 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(Row18, Row18)
/**
     * Check if this row value expression is within a symmetric range of two
     * records.
     * <p>
     * This is the same as calling <code>betweenSymmetric(minValue).and(maxValue)</code>
     *
     * @see #betweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    Condition betweenSymmetric(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                               Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> maxValue);

    
Check if this row value expression is not within a range of two other
row value expressions.

See Also:
  • between(Row18, Row18)
/**
     * Check if this row value expression is not within a range of two other
     * row value expressions.
     *
     * @see #between(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetween(T1 minValue1, T2 minValue2, T3 minValue3, T4 minValue4, T5 minValue5, T6 minValue6, T7 minValue7, T8 minValue8, T9 minValue9, T10 minValue10, T11 minValue11, T12 minValue12, T13 minValue13, T14 minValue14, T15 minValue15, T16 minValue16, T17 minValue17, T18 minValue18);

    
Check if this row value expression is not within a range of two other
row value expressions.

See Also:
  • notBetween(Row18, Row18)
/**
     * Check if this row value expression is not within a range of two other
     * row value expressions.
     *
     * @see #notBetween(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetween(Field<T1> minValue1, Field<T2> minValue2, Field<T3> minValue3, Field<T4> minValue4, Field<T5> minValue5, Field<T6> minValue6, Field<T7> minValue7, Field<T8> minValue8, Field<T9> minValue9, Field<T10> minValue10, Field<T11> minValue11, Field<T12> minValue12, Field<T13> minValue13, Field<T14> minValue14, Field<T15> minValue15, Field<T16> minValue16, Field<T17> minValue17, Field<T18> minValue18);

    
Check if this row value expression is not within a range of two other
row value expressions.

See Also:
  • notBetween(Row18, Row18)
/**
     * Check if this row value expression is not within a range of two other
     * row value expressions.
     *
     * @see #notBetween(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetween(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
Check if this row value expression is within a range of two records.

See Also:
  • notBetween(Row18, Row18)
/**
     * Check if this row value expression is within a range of two records.
     *
     * @see #notBetween(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetween(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
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

/**
     * Check if this row value expression is not within a range of two other
     * row value expressions.
     * <p>
     * This is the same as calling <code>notBetween(minValue).and(maxValue)</code>
     * <p>
     * The expression <code>A NOT BETWEEN B AND C</code> is equivalent to the
     * expression <code>A &lt; B OR A &gt; C</code> for those SQL dialects that do
     * not properly support the <code>BETWEEN</code> predicate for row value
     * expressions
     */
    @NotNull
    @Support
    Condition notBetween(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                         Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> 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(Row18, Row18)
/**
     * Check if this row value expression is within a range of two records.
     * <p>
     * This is the same as calling <code>notBetween(minValue).and(maxValue)</code>
     *
     * @see #notBetween(Row18, Row18)
     */
    @NotNull
    @Support
    Condition notBetween(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                         Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> maxValue);

    
Check if this row value expression is not within a symmetric range of two
other row value expressions.

See Also:
  • notBetweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is not within a symmetric range of two
     * other row value expressions.
     *
     * @see #notBetweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetweenSymmetric(T1 minValue1, T2 minValue2, T3 minValue3, T4 minValue4, T5 minValue5, T6 minValue6, T7 minValue7, T8 minValue8, T9 minValue9, T10 minValue10, T11 minValue11, T12 minValue12, T13 minValue13, T14 minValue14, T15 minValue15, T16 minValue16, T17 minValue17, T18 minValue18);

    
Check if this row value expression is not within a symmetric range of two
other row value expressions.

See Also:
  • notBetweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is not within a symmetric range of two
     * other row value expressions.
     *
     * @see #notBetweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetweenSymmetric(Field<T1> minValue1, Field<T2> minValue2, Field<T3> minValue3, Field<T4> minValue4, Field<T5> minValue5, Field<T6> minValue6, Field<T7> minValue7, Field<T8> minValue8, Field<T9> minValue9, Field<T10> minValue10, Field<T11> minValue11, Field<T12> minValue12, Field<T13> minValue13, Field<T14> minValue14, Field<T15> minValue15, Field<T16> minValue16, Field<T17> minValue17, Field<T18> minValue18);

    
Check if this row value expression is not within a symmetric range of two
other row value expressions.

See Also:
  • notBetweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is not within a symmetric range of two
     * other row value expressions.
     *
     * @see #notBetweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetweenSymmetric(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
Check if this row value expression is not within a symmetric range of two
records.

See Also:
  • notBetweenSymmetric(Row18, Row18)
/**
     * Check if this row value expression is not within a symmetric range of two
     * records.
     *
     * @see #notBetweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    BetweenAndStep18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> notBetweenSymmetric(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue);

    
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

/**
     * Check if this row value expression is not within a symmetric range of two
     * other row value expressions.
     * <p>
     * This is the same as calling <code>notBetweenSymmetric(minValue).and(maxValue)</code>
     * <p>
     * The expression <code>A NOT BETWEEN SYMMETRIC B AND C</code> is equivalent
     * to the expression <code>(A &lt; B OR A &gt; C) AND (A &lt; C OR A &gt; B)</code> for
     * those SQL dialects that do not properly support the <code>BETWEEN</code>
     * predicate for row value expressions
     */
    @NotNull
    @Support
    Condition notBetweenSymmetric(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                                  Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> 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(Row18, Row18)
/**
     * Check if this row value expression is not within a symmetric range of two
     * records.
     * <p>
     * This is the same as calling <code>notBetweenSymmetric(minValue).and(maxValue)</code>
     *
     * @see #notBetweenSymmetric(Row18, Row18)
     */
    @NotNull
    @Support
    Condition notBetweenSymmetric(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> minValue,
                                  Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> maxValue);

    // ------------------------------------------------------------------------
    // [NOT] DISTINCT predicates
    // ------------------------------------------------------------------------


    // ------------------------------------------------------------------------
    // [NOT] IN predicates
    // ------------------------------------------------------------------------

    
Compare this row value expression with a set of row value expressions for
equality.


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

  • IN predicates on unnested array bind variables
    • 



/**
     * Compare this row value expression with a set of row value expressions for
     * equality.
     * <p>
     * Row IN predicates can be emulated in those databases that do not support
     * such predicates natively: <code>(A, B) IN ((1, 2), (3, 4))</code> is
     * equivalent to <code>((A, B) = (1, 2)) OR ((A, B) = (3, 4))</code>, which
     * is equivalent to <code>(A = 1 AND B = 2) OR (A = 3 AND B = 4)</code>
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>IN</code> predicates on temporary tables</li>
     * <li><code>IN</code> predicates on unnested array bind variables</li>
     * </ul>
     */
    @NotNull
    @Support
    Condition in(Collection<? extends Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> rows);

    
Compare this row value expression with a set of records for
equality.


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

  • IN predicates on unnested array bind variables
    • 



/**
     * Compare this row value expression with a set of records for
     * equality.
     * <p>
     * Row IN predicates can be emulated in those databases that do not support
     * such predicates natively: <code>(A, B) IN ((1, 2), (3, 4))</code> is
     * equivalent to <code>((A, B) = (1, 2)) OR ((A, B) = (3, 4))</code>, which
     * is equivalent to <code>(A = 1 AND B = 2) OR (A = 3 AND B = 4)</code>
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>IN</code> predicates on temporary tables</li>
     * <li><code>IN</code> predicates on unnested array bind variables</li>
     * </ul>
     */
    @NotNull
    @Support
    Condition in(Result<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> result);

    
Compare this row value expression with a set of row value expressions 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
    • 



See Also:
/**
     * Compare this row value expression with a set of row value expressions for
     * equality.
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>IN</code> predicates on temporary tables</li>
     * <li><code>IN</code> predicates on unnested array bind variables</li>
     * </ul>
     *
     * @see #in(Collection)
     */
    @SuppressWarnings("unchecked")
    @NotNull
    @Support
    Condition in(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>... rows);

    
Compare this row value expression 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
    • 



See Also:
/**
     * Compare this row value expression with a set of records for equality.
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>IN</code> predicates on temporary tables</li>
     * <li><code>IN</code> predicates on unnested array bind variables</li>
     * </ul>
     *
     * @see #in(Collection)
     */
    @SuppressWarnings("unchecked")
    @NotNull
    @Support
    Condition in(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>... record);

    
Compare this row value expression with a subselect for equality.

See Also:
  • in(Collection)
/**
     * Compare this row value expression with a subselect for equality.
     *
     * @see #in(Collection)
     */
    @NotNull
    @Support
    Condition in(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

    
Compare this row value expression with a set of row value expressions for
equality.


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

  • NOT IN predicates on unnested array bind variables
    • 



/**
     * Compare this row value expression with a set of row value expressions for
     * equality.
     * <p>
     * Row NOT IN predicates can be emulated in those databases that do not
     * support such predicates natively:
     * <code>(A, B) NOT IN ((1, 2), (3, 4))</code> is equivalent to
     * <code>NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))</code>, which is
     * equivalent to <code>NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))</code>
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>NOT IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>NOT IN</code> predicates on temporary tables</li>
     * <li><code>NOT IN</code> predicates on unnested array bind variables</li>
     * </ul>
     */
    @NotNull
    @Support
    Condition notIn(Collection<? extends Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> rows);

    
Compare this row value expression with a set of records for
equality.


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

  • NOT IN predicates on unnested array bind variables
    • 



/**
     * Compare this row value expression with a set of records for
     * equality.
     * <p>
     * Row NOT IN predicates can be emulated in those databases that do not
     * support such predicates natively:
     * <code>(A, B) NOT IN ((1, 2), (3, 4))</code> is equivalent to
     * <code>NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))</code>, which is
     * equivalent to <code>NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))</code>
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>NOT IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>NOT IN</code> predicates on temporary tables</li>
     * <li><code>NOT IN</code> predicates on unnested array bind variables</li>
     * </ul>
     */
    @NotNull
    @Support
    Condition notIn(Result<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> result);

    
Compare this row value expression with a set of row value expressions for
equality.


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

  • NOT IN predicates on unnested array bind variables
    • 



See Also:
/**
     * Compare this row value expression with a set of row value expressions for
     * equality.
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>NOT IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>NOT IN</code> predicates on temporary tables</li>
     * <li><code>NOT IN</code> predicates on unnested array bind variables</li>
     * </ul>
     *
     * @see #notIn(Collection)
     */
    @SuppressWarnings("unchecked")
    @NotNull
    @Support
    Condition notIn(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>... rows);

    
Compare this row value expression with a set of records for non-equality.


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

  • NOT IN predicates on unnested array bind variables
    • 



See Also:
/**
     * Compare this row value expression with a set of records for non-equality.
     * <p>
     * Note that generating dynamic SQL with arbitrary-length
     * <code>NOT IN</code> predicates can cause cursor cache contention in some
     * databases that use unique SQL strings as a statement identifier (e.g.
     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
     * use {@link Settings#isInListPadding()} to produce less distinct SQL
     * strings (see also
     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
     * could avoid <code>IN</code> lists, and replace them with:
     * <ul>
     * <li><code>NOT IN</code> predicates on temporary tables</li>
     * <li><code>NOT IN</code> predicates on unnested array bind variables</li>
     * </ul>
     *
     * @see #notIn(Collection)
     */
    @SuppressWarnings("unchecked")
    @NotNull
    @Support
    Condition notIn(Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>... record);

    
Compare this row value expression with a subselect for non-equality.

See Also:
  • notIn(Collection)
/**
     * Compare this row value expression with a subselect for non-equality.
     *
     * @see #notIn(Collection)
     */
    @NotNull
    @Support
    Condition notIn(Select<? extends Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select);

}