• Home
• com.d3xsystems
• d3x-core-db
• 1.0.82
• source code
• DatabaseMapping.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.

com.d3x.core.db.DatabaseMapping Maven / Gradle / Ivy

/*
 * Copyright (C) 2018-2019 D3X Systems - 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.
 */
package com.d3x.core.db;

import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Currency;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TimeZone;
import java.util.concurrent.atomic.AtomicBoolean;

import com.d3x.core.util.Option;

/**
 * A component that defines how a data type is mapped to a database for select, insert, update and delete operations.
 *
 * @param    the type for this mapping
 */
public interface DatabaseMapping {

    /**
     * Returns the data type for this mapping
     * @return  the data type
     */
    Type type();

    /**
     * The mapper to map a row in a result set to some object
     * @return  the mapper to map a row in a result set to some object
     */
    default Mapper select() {
        throw new UnsupportedOperationException("The select operation is not supported for type: " + type());
    }

    /**
     * The binder to bind arguments to a PreparedStatement for affecting inserts
     * @return binder to bind arguments to a PreparedStatement for affecting inserts
     */
    default Binder insert()  {
        throw new UnsupportedOperationException("The insert operation is not supported for type: " + type());
    }

    /**
     * The binder to bind arguments to a PreparedStatement for affecting updates
     * @return binder to bind arguments to a PreparedStatement for affecting updates
     */
    default Binder update() {
        throw new UnsupportedOperationException("The update operation is not supported for type: " + type());
    }

    /**
     * The binder to bind arguments to a PreparedStatement for affecting deletes
     * @return binder to bind arguments to a PreparedStatement for affecting deletes
     */
    default Binder delete() {
        throw new UnsupportedOperationException("The delete operation is not supported for type: " + type());
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readBoolean(ResultSet rs, int column) throws SQLException {
        var value = rs.getBoolean(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readBoolean(ResultSet rs, String column) throws SQLException {
        var value = rs.getBoolean(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readShort(ResultSet rs, int column) throws SQLException {
        var value = rs.getShort(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readShort(ResultSet rs, String column) throws SQLException {
        var value = rs.getShort(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readInt(ResultSet rs, int column) throws SQLException {
        var value = rs.getInt(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readInt(ResultSet rs, String column) throws SQLException {
        var value = rs.getInt(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLong(ResultSet rs, int column) throws SQLException {
        var value = rs.getLong(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLong(ResultSet rs, String column) throws SQLException {
        var value = rs.getLong(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readFloat(ResultSet rs, int column) throws SQLException {
        var value = rs.getFloat(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readFloat(ResultSet rs, String column) throws SQLException {
        var value = rs.getFloat(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDouble(ResultSet rs, int column) throws SQLException {
        var value = rs.getDouble(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDouble(ResultSet rs, String column) throws SQLException {
        var value = rs.getDouble(column);
        return rs.wasNull() ? Option.empty() : Option.of(value);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readString(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getString(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readString(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getString(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDate(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getDate(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDate(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getDate(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize date
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDate(ResultSet rs, int column, Calendar calendar) throws SQLException {
        return Option.of(rs.getDate(column, calendar));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize date
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readDate(ResultSet rs, String column, Calendar calendar) throws SQLException {
        return Option.of(rs.getDate(column, calendar));
    }


    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLocalDate(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getDate(column)).map(Date::toLocalDate);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLocalDate(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getDate(column)).map(Date::toLocalDate);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTime(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getTime(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTime(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getTime(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize time
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTime(ResultSet rs, int column, Calendar calendar) throws SQLException {
        return Option.of(rs.getTime(column, calendar));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize time
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTime(ResultSet rs, String column, Calendar calendar) throws SQLException {
        return Option.of(rs.getTime(column, calendar));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTimestamp(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getTimestamp(column));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize timestamp
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTimestamp(ResultSet rs, String column, Calendar calendar) throws SQLException {
        return Option.of(rs.getTimestamp(column, calendar));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @param calendar  the calendar to initialize timestamp
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTimestamp(ResultSet rs, int column, Calendar calendar) throws SQLException {
        return Option.of(rs.getTimestamp(column, calendar));
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readTimestamp(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getTimestamp(column));
    }


    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLocalDateTime(ResultSet rs, int column) throws SQLException {
        return Option.of(rs.getTimestamp(column)).map(Timestamp::toLocalDateTime);
    }

    /**
     * Returns an option on the value read from the ResultSet
     * @param rs        the result set to read from
     * @param column    the column to access
     * @return          the option on value
     * @throws SQLException if there is a SQL error
     */
    static Option readLocalDateTime(ResultSet rs, String column) throws SQLException {
        return Option.of(rs.getTimestamp(column)).map(Timestamp::toLocalDateTime);
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyBoolean(PreparedStatement stmt, int paramIndex, Boolean value) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.INTEGER);
        } else {
            stmt.setBoolean(paramIndex, value);
        }
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyInt(PreparedStatement stmt, int paramIndex, Integer value) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.INTEGER);
        } else {
            stmt.setInt(paramIndex, value);
        }
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyLong(PreparedStatement stmt, int paramIndex, Long value) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.BIGINT);
        } else {
            stmt.setLong(paramIndex, value);
        }
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyDouble(PreparedStatement stmt, int paramIndex, Double value) throws SQLException {
        if (value == null || Double.isNaN(value)) {
            stmt.setNull(paramIndex, Types.DOUBLE);
        } else {
            stmt.setDouble(paramIndex, value);
        }
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyFloat(PreparedStatement stmt, int paramIndex, Float value) throws SQLException {
        if (value == null || Float.isNaN(value)) {
            stmt.setNull(paramIndex, Types.FLOAT);
        } else {
            stmt.setFloat(paramIndex, value);
        }
    }

    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyString(PreparedStatement stmt, int paramIndex, String value) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.VARCHAR);
        } else {
            stmt.setString(paramIndex, value);
        }
    }


    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @throws SQLException if there is a SQL error
     */
    static void applyDate(PreparedStatement stmt, int paramIndex, Date value) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.DATE);
        } else {
            stmt.setDate(paramIndex, value);
        }
    }


    /**
     * Applies the value to the statement, calling PreparedStatement.setNull() if value is null
     * @param stmt          the statement to apply value to
     * @param paramIndex    the parameter index
     * @param value         the value to apply, can be null
     * @param calendar      the calendar to control time zone
     * @throws SQLException if there is a SQL error
     */
    static void applyDate(PreparedStatement stmt, int paramIndex, Date value, Calendar calendar) throws SQLException {
        if (value == null) {
            stmt.setNull(paramIndex, Types.DATE);
        } else {
            stmt.setDate(paramIndex, value, calendar);
        }
    }


    /**
     * Extracts all data from result set into a list using this mapping
     * @param rs        the result set to process
     * @return          the list of results
     * @throws SQLException if there is a SQL exception
     */
    default Set toSet(ResultSet rs) throws SQLException {
        var result = new HashSet();
        var mapper = select();
        while (rs.next()) {
            var record = mapper.map(rs);
            result.add(record);
        }
        return result;
    }


    /**
     * Extracts all data from result set into a list using this mapping
     * @param rs        the result set to process
     * @return          the list of results
     * @throws SQLException if there is a SQL exception
     */
    default List toList(ResultSet rs) throws SQLException {
        var result = new ArrayList();
        var mapper = select();
        while (rs.next()) {
            var record = mapper.map(rs);
            result.add(record);
        }
        return result;
    }


    /**
     * Returns an iterator over the records generated by the ResultSet
     * @param rs    the SQL result set to extract records from
     * @return      the iterator with records
     */
    default Iterator toIterator(ResultSet rs) {
        return DatabaseMapping.iterator(rs, select());
    }


    /**
     * Returns a command separated list of values for an in clause
     * @param values    the list of values, for example List.of("x", "y", "z")
     * @return          the in clause expression, for example ('x', 'y', 'z')
     */
    static String in(Collection values) {
        return in(values, Option.empty());
    }


    /**
     * Returns a command separated list of values for an in clause
     * @param values    the list of values, for example List.of("x", "y", "z")
     * @param zoneId    the optional zone if for formatting LocalDateTime
     * @return          the in clause expression, for example ('x', 'y', 'z')
     */
    static String in(Collection values, Option zoneId) {
        if (values.isEmpty()) return "()";
        else {
            final StringBuilder in = new StringBuilder("(");
            for (Object value : values) {
                in.append(in.length() > 1 ? ", " : "");
                if (value instanceof String) {
                    in.append("'").append(value).append("'");
                } else if (value instanceof Number) {
                    in.append(value);
                } else if (value instanceof Boolean) {
                    final boolean entry = (Boolean)value;
                    in.append(entry ? "1" : "0");
                } else if (value instanceof Currency) {
                    final Currency entry = (Currency)value;
                    final String text = entry.getCurrencyCode();
                    in.append("'").append(text).append("'");
                } else if (value instanceof LocalDate) {
                    final LocalDate entry = (LocalDate)value;
                    final String text = DateTimeFormatter.ISO_LOCAL_DATE.format(entry);
                    in.append("'").append(text).append("'");
                } else if (value instanceof LocalTime) {
                    final LocalTime entry = (LocalTime)value;
                    final String text = DateTimeFormatter.ISO_LOCAL_TIME.format(entry);
                    in.append("'").append(text).append("'");
                } else if (value instanceof LocalDateTime) {
                    final LocalDateTime entry = (LocalDateTime)value;
                    final LocalDateTime dateTime = zoneId.map(entry::atZone).map(ZonedDateTime::toLocalDateTime).orElse(entry);
                    final String text = DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(dateTime);
                    in.append("'").append(text).append("'");
                } else if (value instanceof ZonedDateTime) {
                    final ZonedDateTime entry = (ZonedDateTime)value;
                    final String text = DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(entry);
                    in.append("'").append(text).append("'");
                }
            }
            return in.append(")").toString();
        }
    }


    /**
     * Binds an array of arguments to the prepared statement
     * @param stmt  the prepared statement object to bind args to
     * @param args  the array of args to bind to statement
     * @return      the statement
     */
    static PreparedStatement bindArgs(PreparedStatement stmt, List