FWD » Core Development » Database

package com.goldencode.p2j.persist.orm;

import com.goldencode.p2j.persist.Database;

import com.goldencode.p2j.persist.PersistenceException;

import java.io.IOException;

import java.sql.*;

import java.time.Instant;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Objects;

/**

 * JDBC schema comparator. Compares current DB schema state with last known state. Last known state may be provided.

 */

public class SchemaComparator {

    /**

     * Get an instance of the Comparator, load the current database state for use in comparison.

     *

     * @param database database to connect to

     * @return Comparator instance

     */

    public static SchemaComparator saveInitialState(Database database) {

        SchemaComparator schemaComparator = new SchemaComparator(database);

        schemaComparator.saveLastKnownState(null);

        return schemaComparator;

    }

    /**

     * Get an instance of the Comparator, assuming the current database state is already loaded.

     *

     * @param database database to connect to

     * @return Comparator instance

     */

    public static SchemaComparator getInstanceExistingState(Database database) {

        return new SchemaComparator(database);

    }

    private final Database database;

    private SchemaComparator(Database database) {

        this.database = database;

    }

    /**

     * Compare current state with last known state.

     *

     * @return ComparisonResult instance

     * @throws IOException translated from PersistenceException

     */

    public ComparisonResult compareWithPrevious() throws IOException {

        return compare(loadLastKnownState());

    }

    /**

     * Compare current state with given state.

     *

     * @param previousState previous known state for comparison

     * @return ComparisonResult instance

     * @throws IOException translated from PersistenceException

     */

    public ComparisonResult compare(DatabaseState previousState) throws IOException {

        try (Session session = new Session(database))

        {

            Connection conn = session.getConnection();

            ComparisonResult comparisonResult = new ComparisonResult();

            getAndCompareTables(conn, previousState, comparisonResult);

            getAndCompareColumns(conn, previousState, comparisonResult);

            getAndCompareIndexes(conn, previousState, comparisonResult);

            if (!comparisonResult.isSame())

            {

                saveLastKnownState(comparisonResult.getState());

            }

            return comparisonResult;

        } catch (PersistenceException | SQLException e) {

            throw new IOException("Connection failed during comparison", e);

        }

    }

    private DatabaseState loadLastKnownState() {

        // TODO: load

        return new DatabaseState(Instant.now());

    }

    private void saveLastKnownState(DatabaseState newState) {

        // TODO: persist state info

    }

    private void getAndCompareTables(Connection conn, DatabaseState previousState, ComparisonResult comparisonResult) throws SQLException {

        // Load tables from DB

        ResultSet tables = conn.getMetaData()

                .getTables(null, null, "%", new String[]{"TABLE"});

        // Put all data into the new State

        DatabaseState currentState = comparisonResult.getState();

        while (tables.next()) {

            currentState.getTables()

                    .add(new Table(tables.getString("TABLE_NAME")));

        }

        // Compare if old State is available

        if (previousState != null)

        {

            // Detect added

            for (Table table : currentState.getTables()) {

                if (!previousState.getTables().contains(table)) {

                    comparisonResult.getDifferences()

                            .add(new Difference(null, table));

                }

            }

            // Detect removed

            for (Table table : previousState.getTables()) {

                if (!currentState.getTables().contains(table)) {

                    comparisonResult.getDifferences()

                            .add(new Difference(table, null));

                }

            }

        }

    }

    private void getAndCompareColumns(Connection conn, DatabaseState previousState, ComparisonResult comparisonResult) throws SQLException {

        // TODO: load info from conn

        if (previousState != null)

        {

            // TODO: compare with previous state

        }

    }

    private void getAndCompareIndexes(Connection conn, DatabaseState previousState, ComparisonResult comparisonResult) throws SQLException {

        // TODO: load info from conn

        if (previousState != null)

        {

            // TODO: compare with previous state

        }

    }

    /**

     * Result of schema comparison.

     *

     * TODO: could be immutable, requires builder

     */

    public static class ComparisonResult {

        private final DatabaseState state = new DatabaseState(Instant.now());

        private final Collection<Difference> differences = new ArrayList<>();

        public boolean isSame() {

            return differences.isEmpty();

        }

        public Collection<Difference> getDifferences() {

            return differences;

        }

        private DatabaseState getState() {

            return state;

        }

    }

    public static class DatabaseState {

        private final Instant creationTime;

        private final Collection<Table> tables = new HashSet<>();

        public DatabaseState(Instant creationTime) {

            this.creationTime = creationTime;

        }

        public Collection<Table> getTables() {

            return tables;

        }

        public Instant getCreationTime() {

            return creationTime;

        }

    }

    public abstract static class Element {

        private final String name;

        protected Element(String name) {

            this.name = name;

        }

        public String getName() {

            return name;

        }

        @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (o == null || getClass() != o.getClass()) return false;

            Element element = (Element) o;

            return name.equals(element.name);

        }

        @Override

        public int hashCode() {

            return Objects.hash(name);

        }

    }

    public static class Table extends Element {

        private final Collection<Attribute> attributes = new HashSet<>();

        private final Collection<Index> indexes = new HashSet<>();

        public Table(String name) {

            super(name);

        }

        public Collection<Attribute> getAttributes() {

            return attributes;

        }

        public Collection<Index> getIndexes() {

            return indexes;

        }

    }

    public static class Attribute extends Element {

        public Attribute(String name) {

            super(name);

        }

    }

    public static class Index extends Element {

        public Index(String name) {

            super(name);

        }

    }

    public static class Difference {

        private final Element oldElement;

        private final Element newElement;

        public Difference(Element oldElement, Element newElement) {

            this.oldElement = oldElement;

            this.newElement = newElement;

            if (oldElement == null && newElement == null) {

                throw new IllegalArgumentException("New state and old state cannot be both null");

            }

        }

        public Element getOldElement() {

            return oldElement;

        }

        public Element getNewElement() {

            return newElement;

        }

        @Override

        public String toString() {

            if (getOldElement() == null) {

                return "Added " + getNewElement().getName();

            } else if (getNewElement() == null) {

                return "Removed " + getOldElement().getName();

            }

            return getOldElement().getName() + " -> " + getNewElement().getName();

        }

    }

}