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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of payment-retries-plugin Show documentation
Kill Bill Payment Retries plugin
The newest version!
/*
 * Copyright (c) 2009-2016, Data Geekery GmbH (http://www.datageekery.com)
 * All rights reserved.
 *
 * 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.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.jooq.CaseWhenStep;
import org.jooq.Clause;
import org.jooq.Configuration;
import org.jooq.Context;
import org.jooq.DataType;
import org.jooq.Field;
import org.jooq.QueryPart;

final class CaseWhenStepImpl extends AbstractFunction implements CaseWhenStep {

    /**
     * Generated UID
     */
    private static final long    serialVersionUID = -3817194006479624228L;

    private final Field       value;
    private final List> compareValues;
    private final List> results;
    private Field             otherwise;

    CaseWhenStepImpl(Field value, Field compareValue, Field result) {
        this(value, result.getDataType());

        when(compareValue, result);
    }

    CaseWhenStepImpl(Field value, Map, ? extends Field> map) {
        this(value, dataType(map));

        for (Entry, ? extends Field> entry : map.entrySet())
            when(entry.getKey(), entry.getValue());
    }

    private CaseWhenStepImpl(Field value, DataType type) {
        super("case", type);

        this.value = value;
        this.compareValues = new ArrayList>();
        this.results = new ArrayList>();
    }


    @SuppressWarnings("unchecked")
    private static final  DataType dataType(Map, ? extends Field> map) {
        if (map.isEmpty())
            return (DataType) SQLDataType.OTHER;
        else
            return map.entrySet().iterator().next().getValue().getDataType();
    }

    @Override
    public final Field otherwise(T result) {
        return otherwise(Tools.field(result));
    }

    @Override
    public final Field otherwise(Field result) {
        this.otherwise = result;

        return this;
    }

    @Override
    public final CaseWhenStep when(V compareValue, T result) {
        return when(Tools.field(compareValue), Tools.field(result));
    }

    @Override
    public final CaseWhenStep when(V compareValue, Field result) {
        return when(Tools.field(compareValue), result);
    }

    @Override
    public final CaseWhenStep when(Field compareValue, T result) {
        return when(compareValue, Tools.field(result));
    }

    @Override
    public final CaseWhenStep when(Field compareValue, Field result) {
        compareValues.add(compareValue);
        results.add(result);

        return this;
    }

    @Override
    public final CaseWhenStep mapValues(Map values) {
        for (Entry entry : values.entrySet())
            when(entry.getKey(), entry.getValue());

        return this;
    }

    @Override
    public final CaseWhenStep mapFields(Map, ? extends Field> fields) {
        for (Entry, ? extends Field> entry : fields.entrySet())
            when(entry.getKey(), entry.getValue());

        return this;
    }

    @Override
    final QueryPart getFunction0(Configuration configuration) {
        switch (configuration.dialect().family()) {





            default:
                return new Native();
        }
    }

    private abstract class Base extends AbstractQueryPart {

        /**
         * Generated UID
         */
        private static final long serialVersionUID = 6146002888421945901L;

        @Override
        public final Clause[] clauses(Context ctx) {
            return null;
        }
    }







































    private class Native extends Base {

        /**
         * Generated UID
         */
        private static final long serialVersionUID = 7564667836130498156L;

        @Override
        public final void accept(Context ctx) {
            ctx.formatIndentLockStart()
               .keyword("case");

            int size = compareValues.size();
            switch (ctx.configuration().dialect()) {

                // The DERBY dialect doesn't support the simple CASE clause
                case DERBY: {
                    ctx.formatIndentLockStart();

                    for (int i = 0; i < size; i++) {
                        if (i > 0)
                            ctx.formatNewLine();

                        ctx.sql(' ').keyword("when").sql(' ');
                        ctx.visit(value.equal(compareValues.get(i)));
                        ctx.sql(' ').keyword("then").sql(' ');
                        ctx.visit(results.get(i));
                    }

                    break;
                }

                default: {
                    ctx.sql(' ')
                       .visit(value)
                       .formatIndentStart();

                    for (int i = 0; i < size; i++)
                        ctx.formatSeparator()
                           .keyword("when").sql(' ')
                           .visit(compareValues.get(i)).sql(' ')
                           .keyword("then").sql(' ')
                           .visit(results.get(i));

                    break;
                }
            }

            if (otherwise != null)
                ctx.formatSeparator()
                   .keyword("else").sql(' ')
                   .visit(otherwise);

            ctx.formatIndentEnd();

            if (size > 1 || otherwise != null)
                ctx.formatSeparator();
            else
                ctx.sql(' ');

            ctx.keyword("end")
               .formatIndentLockEnd();
        }
    }
}