• Home
• org.jooq
• jooq
• 3.17.29
• source code
• MockResultSet.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jooq.tools.jdbc.MockResultSet Maven / Gradle / Ivy

/*
 * 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.tools.jdbc;

import static org.jooq.SQLDialect.DEFAULT;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Reader;
import java.io.Serializable;
import java.io.StringReader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Map;

import org.jooq.Converter;
import org.jooq.Converters;
import org.jooq.Field;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.impl.DSL;
import org.jooq.impl.DefaultConfiguration;
import org.jooq.tools.StringUtils;

/**
 * A mock result set.
 *
 * @author Lukas Eder
 * @see MockConnection
 */
public class MockResultSet extends JDBC41ResultSet implements ResultSet, Serializable {

    private final int               maxRows;
    Result                       result;
    private final int               size;
    private transient int           index;
    private transient Record        record;
    private transient boolean       wasNull;
    private final Converter[] converters;

    public MockResultSet(Result result) {
        this(result, 0);
    }

    public MockResultSet(Result result, int maxRows) {
        this.result = result;
        this.maxRows = maxRows;

        if (result != null) {
            size = result.size();
            int l = result.fieldsRow().size();
            this.converters = new Converter[l];
            for (int i = 0; i < l; i++)
                converters[i] = Converters.inverse(result.field(i).getConverter());
        }
        else {
            size = 0;
            converters = new Converter[0];
        }
    }

    // -------------------------------------------------------------------------
    // XXX: Unwrapping
    // -------------------------------------------------------------------------

    @SuppressWarnings("unchecked")
    @Override
    public  T unwrap(Class iface) throws SQLException {
        if (isWrapperFor(iface))
            return (T) this;
        else
            throw new SQLException("MockResultSet does not implement " + iface);
    }

    @Override
    public boolean isWrapperFor(Class iface) throws SQLException {
        return iface.isInstance(this);
    }

    // -------------------------------------------------------------------------
    // XXX: ResultSet operations
    // -------------------------------------------------------------------------

    private int size() {
        if (maxRows == 0)
            return size;
        else
            return Math.min(maxRows, size);
    }

    void checkNotClosed() throws SQLException {
        if (result == null)
            throw new SQLException("ResultSet is already closed");
    }

    private void checkInRange() throws SQLException {
        checkNotClosed();

        if (index <= 0 || index > size)
            throw new SQLException("ResultSet index is at an illegal position : " + index);
    }

    private Field field(String columnLabel) throws SQLException {
        Field field = result.field(columnLabel);

        if (field == null)
            throw new SQLException("Unknown column label : " + columnLabel);

        return field;
    }

    private Converter converter(int columnIndex) throws SQLException {
        if (columnIndex > 0 && columnIndex <= converters.length)
            return converters[columnIndex - 1];
        else
            throw new SQLException("Unknown column index : " + columnIndex);
    }

    private long getMillis(Calendar cal, int year, int month, int day, int hour, int minute, int second, int millis) {
        cal = (Calendar) cal.clone();
        cal.clear();
        cal.setLenient(true);

        if (year <= 0) {
            cal.set(Calendar.ERA, GregorianCalendar.BC);
            cal.set(Calendar.YEAR, 1 - year);
        }
        else {
            cal.set(Calendar.ERA, GregorianCalendar.AD);
            cal.set(Calendar.YEAR, year);
        }

        cal.set(Calendar.MONTH, month);
        cal.set(Calendar.DAY_OF_MONTH, day);
        cal.set(Calendar.HOUR_OF_DAY, hour);
        cal.set(Calendar.MINUTE, minute);
        cal.set(Calendar.SECOND, second);
        cal.set(Calendar.MILLISECOND, millis);

        return cal.getTimeInMillis();
    }

    private Timestamp withTZ(Timestamp timestamp, Calendar cal) {
        if (timestamp == null)
            return null;

        int year = timestamp.getYear() + 1900;
        int month = timestamp.getMonth();
        int day = timestamp.getDate();
        int hour = timestamp.getHours();
        int minute = timestamp.getMinutes();
        int second = timestamp.getSeconds();
        int nanos = timestamp.getNanos();
        int millis = nanos / 1000000;
        nanos = nanos - millis * 1000000;

        Timestamp r = new Timestamp(getMillis(cal, year, month, day, hour, minute, second, millis));
        r.setNanos(nanos + millis * 1000000);
        return r;
    }

    private Time withTZ(Time time, Calendar cal) {
        if (time == null)
            return null;

        int hour = time.getHours();
        int minute = time.getMinutes();
        int second = time.getSeconds();
        int millis = (int) (time.getTime() % 1000);

        return new Time(getMillis(cal, 1970, 0, 1, hour, minute, second, millis));
    }

    private Date withTZ(Date date, Calendar cal) {
        if (date == null)
            return null;

        int year = date.getYear() + 1900;
        int month = date.getMonth();
        int day = date.getDate();

        return new Date(getMillis(cal, year, month, day, 0, 0, 0, 0));
    }

    @Override
    public boolean next() throws SQLException {
        return relative(1);
    }

    @Override
    public boolean previous() throws SQLException {
        return relative(-1);
    }

    @Override
    public boolean absolute(int row) throws SQLException {
        if (size() > 0) {
            if (row > 0) {
                if (row <= size()) {
                    index(row);
                    return true;
                }
                else {
                    afterLast();
                    return false;
                }
            }
            else if (row == 0) {
                beforeFirst();
                return false;
            }
            else {
                if (-row <= size()) {
                    index(size() + 1 + row);
                    return true;
                }
                else {
                    beforeFirst();
                    return false;
                }
            }
        }
        else {
            return false;
        }
    }

    @Override
    public boolean relative(int rows) throws SQLException {
        checkNotClosed();

        return index(index + rows);
    }

    @Override
    public int getRow() throws SQLException {
        return (index > size()) ? 0 : index;
    }

    @Override
    public void beforeFirst() throws SQLException {
        checkNotClosed();
        index(0);
    }

    @Override
    public void afterLast() throws SQLException {
        checkNotClosed();
        index(size() + 1);
    }

    @Override
    public boolean first() throws SQLException {
        return absolute(1);
    }

    @Override
    public boolean last() throws SQLException {
        checkNotClosed();
        return absolute(size());
    }

    @Override
    public boolean isFirst() throws SQLException {
        checkNotClosed();
        return (size() > 0 && index == 1);
    }

    @Override
    public boolean isBeforeFirst() throws SQLException {
        checkNotClosed();
        return (size() > 0 && index == 0);
    }

    @Override
    public boolean isLast() throws SQLException {
        checkNotClosed();
        return (size() > 0 && index == size());
    }

    @Override
    public boolean isAfterLast() throws SQLException {
        checkNotClosed();
        return (size() > 0 && index > size());
    }

    @Override
    public void close() throws SQLException {
        result = null;
        index = 0;
    }

    @Override
    public boolean isClosed() throws SQLException {
        return result == null;
    }

    @Override
    public SQLWarning getWarnings() throws SQLException {
        // Warnings are not supported
        return null;
    }

    @Override
    public void clearWarnings() throws SQLException {
        // Warnings are not supported
    }

    @Override
    public String getCursorName() throws SQLException {
        throw new SQLFeatureNotSupportedException("jOOQ ResultSets don't have a cursor name");
    }

    @Override
    public int findColumn(String columnLabel) throws SQLException {
        checkNotClosed();

        Field field = result.field(columnLabel);
        if (field == null)
            throw new SQLException("No such column : " + columnLabel);

        return result.fieldsRow().indexOf(field) + 1;
    }

    @Override
    public void setFetchDirection(int direction) throws SQLException {

        // Fetch direction is not supported
        if (direction != ResultSet.FETCH_FORWARD)
            throw new SQLException("Fetch direction can only be FETCH_FORWARD");
    }

    @Override
    public int getFetchDirection() throws SQLException {

        // Fetch direction is not supported
        return ResultSet.FETCH_FORWARD;
    }

    @Override
    public void setFetchSize(int rows) throws SQLException {
        // Fetch size is not supported
    }

    @Override
    public int getFetchSize() throws SQLException {
        return 0;
    }

    @Override
    public int getType() throws SQLException {
        return ResultSet.TYPE_SCROLL_INSENSITIVE;
    }

    @Override
    public int getConcurrency() throws SQLException {
        return ResultSet.CONCUR_READ_ONLY;
    }

    @Override
    public int getHoldability() throws SQLException {
        return ResultSet.CLOSE_CURSORS_AT_COMMIT;
    }

    // -------------------------------------------------------------------------
    // XXX: Getters
    // -------------------------------------------------------------------------

    @Override
    public boolean wasNull() throws SQLException {
        checkNotClosed();

        return wasNull;
    }

    @Override
    public ResultSetMetaData getMetaData() throws SQLException {
        return new MockResultSetMetaData(this);
    }

    @Override
    public Statement getStatement() throws SQLException {
        return null;
    }

    private  T get(String columnLabel, Class type) throws SQLException {
        checkInRange();

        // [#11099] TODO: Possibly optimise this logic similar to that of MockResultSet.get(int, Class)
        Converter converter = Converters.inverse(field(columnLabel).getConverter());
        return get0(record.get(columnLabel, converter), type);
    }

    private  T get(int columnIndex, Class type) throws SQLException {
        checkInRange();

        return get0(record.get(columnIndex - 1, converter(columnIndex)), type);
    }

    @SuppressWarnings("unchecked")
    private  T get0(Object value, Class type) {
        Converter converter =
        (record.configuration() == null ? new DefaultConfiguration() : record.configuration())
            .converterProvider()
            .provide(value == null ? Object.class : (Class