• Home
• io.prestosql
• presto-jdbc
• 350
• source code
• AbstractPrestoResultSet.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.

io.prestosql.jdbc.AbstractPrestoResultSet 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.
 */
package io.prestosql.jdbc;

import io.prestosql.jdbc.$internal.guava.annotations.VisibleForTesting;
import io.prestosql.jdbc.$internal.guava.collect.ImmutableList;
import io.prestosql.jdbc.$internal.guava.collect.ImmutableMap;
import io.prestosql.jdbc.$internal.guava.collect.Lists;
import io.prestosql.jdbc.$internal.guava.io.BaseEncoding;
import io.prestosql.jdbc.$internal.client.ClientTypeSignature;
import io.prestosql.jdbc.$internal.client.ClientTypeSignatureParameter;
import io.prestosql.jdbc.$internal.client.Column;
import io.prestosql.jdbc.$internal.client.IntervalDayTime;
import io.prestosql.jdbc.$internal.client.IntervalYearMonth;
import io.prestosql.jdbc.$internal.client.QueryError;
import io.prestosql.jdbc.$internal.client.QueryStatusInfo;
import io.prestosql.jdbc.ColumnInfo.Nullable;
import io.prestosql.jdbc.TypeConversions.NoConversionRegisteredException;
import io.prestosql.jdbc.$internal.joda.time.DateTimeZone;
import io.prestosql.jdbc.$internal.joda.time.LocalDate;
import io.prestosql.jdbc.$internal.joda.time.format.DateTimeFormat;
import io.prestosql.jdbc.$internal.joda.time.format.DateTimeFormatter;
import io.prestosql.jdbc.$internal.joda.time.format.ISODateTimeFormat;

import java.io.InputStream;
import java.io.Reader;
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.sql.Types;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TimeZone;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static io.prestosql.jdbc.$internal.guava.base.Preconditions.checkArgument;
import static io.prestosql.jdbc.$internal.guava.base.Verify.verify;
import static io.prestosql.jdbc.$internal.guava.collect.Iterables.getOnlyElement;
import static io.prestosql.jdbc.ColumnInfo.setTypeInfo;
import static java.lang.Math.toIntExact;
import static java.lang.String.format;
import static java.math.BigDecimal.ROUND_HALF_UP;
import static java.util.Collections.unmodifiableList;
import static java.util.Collections.unmodifiableMap;
import static java.util.Locale.ENGLISH;
import static java.util.Objects.requireNonNull;
import static io.prestosql.jdbc.$internal.joda.time.DateTimeConstants.SECONDS_PER_DAY;

abstract class AbstractPrestoResultSet
        implements ResultSet
{
    private static final Pattern DATETIME_PATTERN = Pattern.compile("" +
            "(?[-+]?\\d{4,})-(?\\d{1,2})-(?\\d{1,2})" +
            "(?: (?\\d{1,2}):(?\\d{1,2})(?::(?\\d{1,2})(?:\\.(?\\d+))?)?)?" +
            "\\s*(?.+)?");

    private static final Pattern TIME_PATTERN = Pattern.compile("(?\\d{1,2}):(?\\d{1,2}):(?\\d{1,2})(?:\\.(?\\d+))?");
    private static final Pattern TIME_WITH_TIME_ZONE_PATTERN = Pattern.compile("" +
            "(?\\d{1,2}):(?\\d{1,2}):(?\\d{1,2})(?:\\.(?\\d+))?" +
            "[ ]?(?[+-])(?\\d\\d):(?\\d\\d)");

    private static final long[] POWERS_OF_TEN = {
            1L,
            10L,
            100L,
            1000L,
            10_000L,
            100_000L,
            1_000_000L,
            10_000_000L,
            100_000_000L,
            1_000_000_000L,
            10_000_000_000L,
            100_000_000_000L,
            1000_000_000_000L
    };

    private static final int MAX_DATETIME_PRECISION = 12;

    private static final int MILLISECONDS_PER_SECOND = 1000;
    private static final int MILLISECONDS_PER_MINUTE = 60 * MILLISECONDS_PER_SECOND;
    private static final long NANOSECONDS_PER_SECOND = 1_000_000_000;
    private static final int PICOSECONDS_PER_NANOSECOND = 1_000;

    static final DateTimeFormatter DATE_FORMATTER = ISODateTimeFormat.date();
    static final DateTimeFormatter TIME_FORMATTER = DateTimeFormat.forPattern("HH:mm:ss.SSS");
    static final DateTimeFormatter TIMESTAMP_FORMATTER = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.SSS");

    // Before 1900, Java Time and Joda Time are not consistent with java.sql.Date and java.util.Calendar
    // Since January 1, 1900 UTC is still December 31, 1899 in other zones, we are adding a 1 year margin.
    private static final long START_OF_MODERN_ERA_SECONDS = java.time.LocalDate.of(1901, 1, 1).toEpochDay() * SECONDS_PER_DAY;

    @VisibleForTesting
    static final Map> DEFAULT_OBJECT_REPRESENTATION = ImmutableMap.>builder()
            .put("decimal", BigDecimal.class)
            .put("date", java.sql.Date.class)
            .put("time", java.sql.Time.class)
            .put("time with time zone", java.sql.Time.class)
            .put("timestamp", java.sql.Timestamp.class)
            .put("timestamp with time zone", java.sql.Timestamp.class)
            .put("interval year to month", PrestoIntervalYearMonth.class)
            .put("interval day to second", PrestoIntervalDayTime.class)
            .put("map", Map.class)
            .put("row", Row.class)
            .build();

    @VisibleForTesting
    static final TypeConversions TYPE_CONVERSIONS =
            TypeConversions.builder()
                    .add("decimal", String.class, BigDecimal.class, AbstractPrestoResultSet::parseBigDecimal)
                    .add("varbinary", byte[].class, String.class, value -> "0x" + BaseEncoding.base16().encode(value))
                    .add("date", String.class, Date.class, string -> {
                        try {
                            return parseDate(string, DateTimeZone.forID(ZoneId.systemDefault().getId()));
                        }
                        // TODO (https://github.com/prestosql/presto/issues/6242) this should never fail
                        catch (IllegalArgumentException e) {
                            throw new SQLException("Expected value to be a date but is: " + string, e);
                        }
                    })
                    .add("time", String.class, Time.class, string -> parseTime(string, ZoneId.systemDefault()))
                    .add("time with time zone", String.class, Time.class, AbstractPrestoResultSet::parseTimeWithTimeZone)
                    .add("timestamp", String.class, Timestamp.class, string -> parseTimestampAsSqlTimestamp(string, ZoneId.systemDefault()))
                    .add("timestamp with time zone", String.class, Timestamp.class, AbstractPrestoResultSet::parseTimestampWithTimeZoneAsSqlTimestamp)
                    .add("timestamp with time zone", String.class, ZonedDateTime.class, AbstractPrestoResultSet::parseTimestampWithTimeZone)
                    .add("interval year to month", String.class, PrestoIntervalYearMonth.class, AbstractPrestoResultSet::parseIntervalYearMonth)
                    .add("interval day to second", String.class, PrestoIntervalDayTime.class, AbstractPrestoResultSet::parseIntervalDayTime)
                    .add("array", List.class, List.class, (type, list) -> (List) convertFromClientRepresentation(type, list))
                    .add("map", Map.class, Map.class, (type, map) -> (Map) convertFromClientRepresentation(type, map))
                    .add("row", io.prestosql.jdbc.$internal.client.Row.class, Row.class, (type, clientRow) -> (Row) convertFromClientRepresentation(type, clientRow))
                    .add("row", io.prestosql.jdbc.$internal.client.Row.class, Map.class, (type, clientRow) -> {
                        Row row = (Row) convertFromClientRepresentation(type, clientRow);
                        Map result = new HashMap<>();
                        for (RowField field : row.getFields()) {
                            String name = field.getName()
                                    .orElseGet(() -> "field" + field.getOrdinal());
                            if (result.containsKey(name)) {
                                throw new SQLException("Duplicate field name: " + name);
                            }
                            result.put(name, field.getValue());
                        }
                        return result;
                    })
                    .build();

    private final DateTimeZone resultTimeZone;
    protected final Iterator> results;
    private final Map fieldMap;
    private final List columnInfoList;
    private final ResultSetMetaData resultSetMetaData;
    private final AtomicReference> row = new AtomicReference<>();
    private final AtomicLong currentRowNumber = new AtomicLong(); // Index into 'rows' of our current row (1-based)
    private final AtomicBoolean wasNull = new AtomicBoolean();
    protected final AtomicBoolean closed = new AtomicBoolean();
    private final Optional statement;

    AbstractPrestoResultSet(Optional statement, List columns, Iterator> results)
    {
        this.statement = requireNonNull(statement, "statement is null");
        this.resultTimeZone = DateTimeZone.forID(ZoneId.systemDefault().getId());

        requireNonNull(columns, "columns is null");
        this.fieldMap = getFieldMap(columns);
        this.columnInfoList = getColumnInfo(columns);
        this.resultSetMetaData = new PrestoResultSetMetaData(columnInfoList);

        this.results = requireNonNull(results, "results is null");
    }

    @Override
    public boolean next()
            throws SQLException
    {
        checkOpen();
        try {
            if (!results.hasNext()) {
                row.set(null);
                currentRowNumber.set(0);
                return false;
            }
            row.set(results.next());
            currentRowNumber.incrementAndGet();
            return true;
        }
        catch (RuntimeException e) {
            if (e.getCause() instanceof SQLException) {
                throw (SQLException) e.getCause();
            }
            throw new SQLException("Error fetching results", e);
        }
    }

    @Override
    public boolean wasNull()
            throws SQLException
    {
        return wasNull.get();
    }

    @Override
    public String getString(int columnIndex)
            throws SQLException
    {
        Object value = column(columnIndex);
        if (value == null) {
            return null;
        }
        ClientTypeSignature columnTypeSignature = columnInfo(columnIndex).getColumnTypeSignature();
        if (TYPE_CONVERSIONS.hasConversion(columnTypeSignature.getRawType(), String.class)) {
            return TYPE_CONVERSIONS.convert(columnTypeSignature, value, String.class);
        }
        return value.toString();
    }

    @Override
    public boolean getBoolean(int columnIndex)
            throws SQLException
    {
        Object value = column(columnIndex);
        return (value != null) ? (Boolean) value : false;
    }

    @Override
    public byte getByte(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).byteValue();
    }

    @Override
    public short getShort(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).shortValue();
    }

    @Override
    public int getInt(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).intValue();
    }

    @Override
    public long getLong(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).longValue();
    }

    @Override
    public float getFloat(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).floatValue();
    }

    @Override
    public double getDouble(int columnIndex)
            throws SQLException
    {
        return toNumber(column(columnIndex)).doubleValue();
    }

    @Override
    public BigDecimal getBigDecimal(int columnIndex, int scale)
            throws SQLException
    {
        BigDecimal bigDecimal = getBigDecimal(columnIndex);
        if (bigDecimal != null) {
            bigDecimal = bigDecimal.setScale(scale, ROUND_HALF_UP);
        }
        return bigDecimal;
    }

    @Override
    public byte[] getBytes(int columnIndex)
            throws SQLException
    {
        return (byte[]) column(columnIndex);
    }

    @Override
    public Date getDate(int columnIndex)
            throws SQLException
    {
        return getDate(columnIndex, resultTimeZone);
    }

    private Date getDate(int columnIndex, DateTimeZone localTimeZone)
            throws SQLException
    {
        Object value = column(columnIndex);
        if (value == null) {
            return null;
        }

        try {
            return parseDate(String.valueOf(value), localTimeZone);
        }
        catch (IllegalArgumentException e) {
            throw new SQLException("Expected value to be a date but is: " + value, e);
        }
    }

    private static Date parseDate(String value, DateTimeZone localTimeZone)
    {
        long millis = DATE_FORMATTER.withZone(localTimeZone).parseMillis(String.valueOf(value));
        if (millis >= START_OF_MODERN_ERA_SECONDS * MILLISECONDS_PER_SECOND) {
            return new Date(millis);
        }

        // The chronology used by default by Joda is not historically accurate for dates
        // preceding the introduction of the Gregorian calendar and is not consistent with
        // java.sql.Date (the same millisecond value represents a different year/month/day)
        // before the 20th century. For such dates we are falling back to using the more
        // expensive GregorianCalendar; note that Joda also has a chronology that works for
        // older dates, but it uses a slightly different algorithm and yields results that
        // are not compatible with java.sql.Date.
        LocalDate localDate = DATE_FORMATTER.parseLocalDate(String.valueOf(value));
        Calendar calendar = new GregorianCalendar(localDate.getYear(), localDate.getMonthOfYear() - 1, localDate.getDayOfMonth());
        calendar.setTimeZone(TimeZone.getTimeZone(ZoneId.of(localTimeZone.getID())));

        return new Date(calendar.getTimeInMillis());
    }

    @Override
    public Time getTime(int columnIndex)
            throws SQLException
    {
        return getTime(columnIndex, resultTimeZone);
    }

    private Time getTime(int columnIndex, DateTimeZone localTimeZone)
            throws SQLException
    {
        Object value = column(columnIndex);
        if (value == null) {
            return null;
        }

        ColumnInfo columnInfo = columnInfo(columnIndex);
        if (columnInfo.getColumnTypeSignature().getRawType().equalsIgnoreCase("time")) {
            try {
                return parseTime((String) value, ZoneId.of(localTimeZone.getID()));
            }
            catch (IllegalArgumentException e) {
                throw new SQLException("Invalid time from server: " + value, e);
            }
        }

        if (columnInfo.getColumnTypeSignature().getRawType().equalsIgnoreCase("time with time zone")) {
            try {
                return parseTimeWithTimeZone((String) value);
            }
            catch (IllegalArgumentException e) {
                throw new SQLException("Invalid time from server: " + value, e);
            }
        }

        throw new IllegalArgumentException("Expected column to be a time type but is " + columnInfo.getColumnTypeName());
    }

    @Override
    public Timestamp getTimestamp(int columnIndex)
            throws SQLException
    {
        return getTimestamp(columnIndex, resultTimeZone);
    }

    private Timestamp getTimestamp(int columnIndex, DateTimeZone localTimeZone)
            throws SQLException
    {
        Object value = column(columnIndex);
        if (value == null) {
            return null;
        }

        ColumnInfo columnInfo = columnInfo(columnIndex);
        if (columnInfo.getColumnTypeSignature().getRawType().equalsIgnoreCase("timestamp")) {
            try {
                return parseTimestampAsSqlTimestamp((String) value, ZoneId.of(localTimeZone.getID()));
            }
            catch (IllegalArgumentException e) {
                throw new SQLException("Invalid timestamp from server: " + value, e);
            }
        }

        if (columnInfo.getColumnTypeSignature().getRawType().equalsIgnoreCase("timestamp with time zone")) {
            try {
                return parseTimestampWithTimeZoneAsSqlTimestamp((String) value);
            }
            catch (IllegalArgumentException e) {
                throw new SQLException("Invalid timestamp from server: " + value, e);
            }
        }

        throw new IllegalArgumentException("Expected column to be a timestamp type but is " + columnInfo.getColumnTypeName());
    }

    private static ZonedDateTime parseTimestampWithTimeZone(String value)
    {
        ParsedTimestamp parsed = parseTimestamp(value);
        return toZonedDateTime(parsed, timezone -> ZoneId.of(timezone.orElseThrow(() -> new IllegalArgumentException("Time zone missing: " + value))));
    }

    @Override
    public InputStream getAsciiStream(int columnIndex)
            throws SQLException
    {
        throw new NotImplementedException("ResultSet", "getAsciiStream");
    }

    @Override
    public InputStream getUnicodeStream(int columnIndex)
            throws SQLException
    {
        throw new SQLFeatureNotSupportedException("getUnicodeStream");
    }

    @Override
    public InputStream getBinaryStream(int columnIndex)
            throws SQLException
    {
        throw new NotImplementedException("ResultSet", "getBinaryStream");
    }

    @Override
    public String getString(String columnLabel)
            throws SQLException
    {
        return getString(columnIndex(columnLabel));
    }

    @Override
    public boolean getBoolean(String columnLabel)
            throws SQLException
    {
        return getBoolean(columnIndex(columnLabel));
    }

    @Override
    public byte getByte(String columnLabel)
            throws SQLException
    {
        return getByte(columnIndex(columnLabel));
    }

    @Override
    public short getShort(String columnLabel)
            throws SQLException
    {
        return getShort(columnIndex(columnLabel));
    }

    @Override
    public int getInt(String columnLabel)
            throws SQLException
    {
        return getInt(columnIndex(columnLabel));
    }

    @Override
    public long getLong(String columnLabel)
            throws SQLException
    {
        return getLong(columnIndex(columnLabel));
    }

    @Override
    public float getFloat(String columnLabel)
            throws SQLException
    {
        return getFloat(columnIndex(columnLabel));
    }

    @Override
    public double getDouble(String columnLabel)
            throws SQLException
    {
        return getDouble(columnIndex(columnLabel));
    }

    @Override
    public BigDecimal getBigDecimal(String columnLabel, int scale)
            throws SQLException
    {
        return getBigDecimal(columnIndex(columnLabel), scale);
    }

    @Override
    public byte[] getBytes(String columnLabel)
            throws SQLException
    {
        return getBytes(columnIndex(columnLabel));
    }

    @Override
    public Date getDate(String columnLabel)
            throws SQLException
    {
        return getDate(columnIndex(columnLabel));
    }

    @Override
    public Time getTime(String columnLabel)
            throws SQLException
    {
        return getTime(columnIndex(columnLabel));
    }

    @Override
    public Timestamp getTimestamp(String columnLabel)
            throws SQLException
    {
        return getTimestamp(columnIndex(columnLabel));
    }

    @Override
    public InputStream getAsciiStream(String columnLabel)
            throws SQLException
    {
        throw new NotImplementedException("ResultSet", "getAsciiStream");
    }

    @Override
    public InputStream getUnicodeStream(String columnLabel)
            throws SQLException
    {
        throw new SQLFeatureNotSupportedException("getUnicodeStream");
    }

    @Override
    public InputStream getBinaryStream(String columnLabel)
            throws SQLException
    {
        throw new NotImplementedException("ResultSet", "getBinaryStream");
    }

    @Override
    public SQLWarning getWarnings()
            throws SQLException
    {
        checkOpen();
        return null;
    }

    @Override
    public void clearWarnings()
            throws SQLException
    {
        checkOpen();
    }

    @Override
    public String getCursorName()
            throws SQLException
    {
        throw new SQLFeatureNotSupportedException("getCursorName");
    }

    @Override
    public ResultSetMetaData getMetaData()
            throws SQLException
    {
        return resultSetMetaData;
    }

    @Override
    public Object getObject(int columnIndex)
            throws SQLException
    {
        ColumnInfo columnInfo = columnInfo(columnIndex);

        if (columnInfo.getColumnType() == Types.ARRAY) {
            // Array requires special treatment due to element metadata provided by the Array object
            // TODO (https://github.com/prestosql/presto/issues/6049) consider returning List instead
            return getArray(columnIndex);
        }

        Class defaultRepresentation = DEFAULT_OBJECT_REPRESENTATION.get(columnInfo.getColumnTypeSignature().getRawType());
        if (defaultRepresentation != null) {
            return getObject(columnIndex, defaultRepresentation);
        }

        return column(columnIndex);
    }

    @io.prestosql.jdbc.$internal.javax.annotation.Nullable
    private static Object convertFromClientRepresentation(ClientTypeSignature columnType, @io.prestosql.jdbc.$internal.javax.annotation.Nullable Object value)
            throws SQLException
    {
        requireNonNull(columnType, "columnType is null");

        if (value == null) {
            return null;
        }

        switch (columnType.getRawType()) {
            case "array": {
                ClientTypeSignature elementType = getOnlyElement(columnType.getArgumentsAsTypeSignatures());
                List