org.jooq.impl.BetweenCondition Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jooq Show documentation
There is a newer version: 3.19.15
/*
 * 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
 *
 *  https://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
 * Apache-2.0 and offer limited warranties, support, maintenance, and commercial
 * database integrations.
 *
 * For more information, please visit: https://www.jooq.org/legal/licensing
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package org.jooq.impl;

import static org.jooq.Clause.CONDITION;
import static org.jooq.Clause.CONDITION_BETWEEN;
import static org.jooq.Clause.CONDITION_BETWEEN_SYMMETRIC;
import static org.jooq.Clause.CONDITION_NOT_BETWEEN;
import static org.jooq.Clause.CONDITION_NOT_BETWEEN_SYMMETRIC;
// ...
// ...
// ...
// ...
import static org.jooq.SQLDialect.CUBRID;
// ...
import static org.jooq.SQLDialect.DERBY;
import static org.jooq.SQLDialect.FIREBIRD;
import static org.jooq.SQLDialect.H2;
// ...
import static org.jooq.SQLDialect.IGNITE;
// ...
// ...
import static org.jooq.SQLDialect.MARIADB;
// ...
import static org.jooq.SQLDialect.MYSQL;
// ...
// ...
// ...
// ...
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
// ...
import static org.jooq.impl.DSL.row;
import static org.jooq.impl.DSL.val;
import static org.jooq.impl.Keywords.K_AND;
import static org.jooq.impl.Keywords.K_BETWEEN;
import static org.jooq.impl.Keywords.K_NOT;
import static org.jooq.impl.Keywords.K_SYMMETRIC;
import static org.jooq.impl.Tools.embeddedFields;
import static org.jooq.impl.Tools.nullSafe;
import static org.jooq.impl.Tools.nullableIf;

import java.util.Set;
import java.util.function.Predicate;

import org.jooq.BetweenAndStep;
import org.jooq.Clause;
import org.jooq.Condition;
import org.jooq.Context;
import org.jooq.Field;
import org.jooq.Function1;
import org.jooq.Function3;
import org.jooq.RowN;
import org.jooq.SQLDialect;
import org.jooq.impl.QOM.Between;
import org.jooq.QueryPart;
// ...

/**
 * @author Lukas Eder
 */
final class BetweenCondition extends AbstractCondition implements BetweenAndStep, Between {

    private static final Clause[]        CLAUSES_BETWEEN               = { CONDITION, CONDITION_BETWEEN };
    private static final Clause[]        CLAUSES_BETWEEN_SYMMETRIC     = { CONDITION, CONDITION_BETWEEN_SYMMETRIC };
    private static final Clause[]        CLAUSES_NOT_BETWEEN           = { CONDITION, CONDITION_NOT_BETWEEN };
    private static final Clause[]        CLAUSES_NOT_BETWEEN_SYMMETRIC = { CONDITION, CONDITION_NOT_BETWEEN_SYMMETRIC };
    private static final Set NO_SUPPORT_SYMMETRIC          = SQLDialect.supportedBy(CUBRID, DERBY, FIREBIRD, H2, IGNITE, MARIADB, MYSQL, SQLITE);

    private final boolean                symmetric;
    private final boolean                not;
    final Field                       field;
    final Field                       minValue;
    Field                             maxValue;

    BetweenCondition(Field field, Field minValue, boolean not, boolean symmetric) {
        this.field = nullableIf(false, nullSafe(field, minValue.getDataType()));
        this.minValue = nullableIf(false, nullSafe(minValue, field.getDataType()));
        this.not = not;
        this.symmetric = symmetric;
    }

    @Override
    public final Condition and(T value) {
        return and(val(value, field.getDataType()));
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Override
    public final Condition and(Field f) {
        if (maxValue == null) {
            this.maxValue = nullableIf(false, nullSafe(f, field.getDataType()));
            return this;
        }
        else
            return super.and(f);
    }

    @Override // Avoid AbstractCondition implementation
    public final Clause[] clauses(Context ctx) {
        return not ? symmetric ? CLAUSES_NOT_BETWEEN_SYMMETRIC
                               : CLAUSES_NOT_BETWEEN
                   : symmetric ? CLAUSES_BETWEEN_SYMMETRIC
                               : CLAUSES_BETWEEN;
    }

    @Override
    public final void accept(Context ctx) {
        if (field.getDataType().isEmbeddable()
                && minValue.getDataType().isEmbeddable()
                && maxValue.getDataType().isEmbeddable()) {
            RowN f = row(embeddedFields(field));
            RowN min = row(embeddedFields(minValue));
            RowN max = row(embeddedFields(maxValue));

            ctx.visit(not
                 ? symmetric
                     ? f.notBetweenSymmetric(min).and(max)
                     : f.notBetween(min).and(max)
                 : symmetric
                     ? f.betweenSymmetric(min).and(max)
                     : f.between(min).and(max));
        }










        else if (symmetric && NO_SUPPORT_SYMMETRIC.contains(ctx.dialect())) {
            ctx.visit(not
                ? field.notBetween(minValue, maxValue).and(field.notBetween(maxValue, minValue))
                : field.between(minValue, maxValue).or(field.between(maxValue, minValue)));
        }
        else {
                           ctx.visit(field);
            if (not)       ctx.sql(' ').visit(K_NOT);
                           ctx.sql(' ').visit(K_BETWEEN);
            if (symmetric) ctx.sql(' ').visit(K_SYMMETRIC);
                           ctx.sql(' ').visit(minValue);
                           ctx.sql(' ').visit(K_AND);
                           ctx.sql(' ').visit(maxValue);
        }
    }

    // -------------------------------------------------------------------------
    // XXX: Query Object Model
    // -------------------------------------------------------------------------

    @SuppressWarnings("unchecked")
    @Override
    public final Function3, ? super Field, ? super Field, ? extends QOM.Between> $constructor() {
        return (f, min, max) -> (QOM.Between) new BetweenCondition<>(f, min, not, symmetric).and(max);
    }

    @Override
    public final Field $arg1() {
        return field;
    }

    @Override
    public final Field $arg2() {
        return minValue;
    }

    @Override
    public final Field $arg3() {
        return maxValue;
    }

    @Override
    public final boolean $symmetric() {
        return symmetric;
    }

    @SuppressWarnings("unchecked")
    @Override
    public final Between $symmetric(boolean s) {
        return (Between) new BetweenCondition($arg1(), $arg2(), not, s).and($arg3());
    }






















}