org.jooq.impl.DMLQueryAsResultQuery 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.18
/*
 * 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
 * Apache-2.0 license 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 static org.jooq.impl.Tools.EMPTY_FIELD;

import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;

import org.jooq.CloseableResultQuery;
import org.jooq.Configuration;
import org.jooq.Context;
import org.jooq.Delete;
import org.jooq.DeleteResultStep;
import org.jooq.Field;
import org.jooq.Insert;
import org.jooq.InsertResultStep;
import org.jooq.Name;
import org.jooq.Param;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Table;
import org.jooq.Update;
import org.jooq.UpdateResultStep;
import org.jooq.conf.ParamType;
import org.jooq.exception.DataAccessException;
import org.jooq.exception.DataTypeException;
import org.jooq.impl.QOM.UNotYetImplemented;

import org.jetbrains.annotations.NotNull;

/**
 * A wrapped DML query ({@link Insert}, {@link Update}, {@link Delete}) that
 * works like a {@link ResultQuery}.
 *
 * @author Lukas Eder
 */
final class DMLQueryAsResultQuery>
extends
    AbstractQueryPart
implements
    ResultQueryTrait,
    DeleteResultStep,
    UpdateResultStep,
    InsertResultStep,
    UNotYetImplemented
{
    private final Q                        delegate;
    private final boolean                  returningResult;
    private Table                       coerceTable;
    private Collection> coerceFields;

    DMLQueryAsResultQuery(Q delegate, boolean returningResult) {
        this.delegate = delegate;
        this.returningResult = returningResult;
    }

    final Q getDelegate() {
        return delegate;
    }

    // TODO: Refactor this coercion, share logic with AbstractResultQuery

    @Override
    public final Field[] getFields(ThrowingSupplier rs) throws SQLException {
        Field[] f = getFields();
        return f != null ? f : delegate.getFields(rs);
    }

    @Override
    public final Field[] getFields() {
        if (coerceFields != null && !coerceFields.isEmpty())
            return coerceFields.toArray(EMPTY_FIELD);
        else
            return delegate.returningResolvedAsterisks.toArray(EMPTY_FIELD);
    }

    @Override
    public final  CloseableResultQuery coerce(Table table) {
        this.coerceTable = table;
        return (CloseableResultQuery) coerce(Arrays.asList(table.fields()));
    }

    @Override
    public final CloseableResultQuery coerce(Collection> fields) {
        this.coerceFields = fields;
        return (CloseableResultQuery) this;
    }

    @Override
    public final Class getRecordType() {
        if (coerceTable != null)
            return (Class) coerceTable.getRecordType();
        else if (returningResult)
            return (Class) delegate.getRecordType();
        else
            return delegate.table().getRecordType();
    }

    @Override
    public final Result fetch() {
        delegate.execute();
        return (@NotNull Result) getResult();
    }

    @Override
    public final int execute() throws DataAccessException {
        return delegate.execute();
    }

    @Override
    public final CompletionStage executeAsync() {
        return delegate.executeAsync();
    }

    @Override
    public final CompletionStage executeAsync(Executor executor) {
        return delegate.executeAsync(executor);
    }

    @Override
    public final boolean isExecutable() {
        return delegate.isExecutable();
    }

    @Override
    public final String getSQL() {
        return delegate.getSQL();
    }

    @Override
    public final String getSQL(ParamType paramType) {
        return delegate.getSQL(paramType);
    }

    @Override
    public final List