Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.sql.utils;

import org.openconcerto.sql.Log;
import org.openconcerto.sql.model.Constraint;
import org.openconcerto.sql.model.DBRoot;
import org.openconcerto.sql.model.DBSystemRoot;
import org.openconcerto.sql.model.SQLBase;
import org.openconcerto.sql.model.SQLDataSource;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLField.Properties;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLSchema;
import org.openconcerto.sql.model.SQLServer;
import org.openconcerto.sql.model.SQLSyntax;
import org.openconcerto.sql.model.SQLSyntax.ConstraintType;
import org.openconcerto.sql.model.SQLSystem;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.SQLTable.Index;
import org.openconcerto.sql.model.graph.Link;
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.CompareUtils;
import org.openconcerto.utils.ProductInfo;
import org.openconcerto.utils.cc.CustomEquals;
import org.openconcerto.utils.cc.CustomEquals.ProxyItf;
import org.openconcerto.utils.cc.HashingStrategy;
import org.openconcerto.utils.cc.IClosure;

import java.net.URISyntaxException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Diff {

    /**
     * If <code>true</code> the table changes will be outputted sequentially. This is more legible
     * but cannot be executed when cycles exist.
     */
    public static final String SIMPLE_SEQ = "org.openconcerto.sql.Diff.simpleSeq";
    private static final String ROOTS_TO_MAP = "rootsToMap";

    private static void usage() {
        System.out.println("Usage: " + Diff.class.getName() + " url1 url2 [tableName]...");
        System.out.println("Outputs SQL statements to patch url1. That is if you execute the statements on url1 it will become url2.");
        System.out.println("System properties: " + ROOTS_TO_MAP + "=list of roots to map");
    }

    public static void main(String[] args) throws URISyntaxException {
        if (args.length < 2) {
            usage();
            System.exit(1);
        }
        System.setProperty(SQLSchema.NOAUTO_CREATE_METADATA, "true");
        // for caching the db
        ProductInfo.setInstance(new ProductInfo(Diff.class.getName()));

        final SQL_URL url1 = SQL_URL.create(args[0]);
        final SQL_URL url2 = SQL_URL.create(args[1]);
        final List<String> tables = args.length < 3 ? null : Arrays.asList(args).subList(2, args.length);

        final DBRoot root1 = getRoot(url1);
        final DBRoot root2 = getRoot(url2);
        final Diff diff = new Diff(root1, root2);
        if (tables == null)
            System.out.println(diff.compute());
        else
            System.out.println(diff.compute(tables));
        root1.getServer().destroy();
        root2.getServer().destroy();
    }

    private static DBRoot getRoot(final SQL_URL url1) {
        final DBSystemRoot sysRoot = SQLServer.create(url1, SQLRow.toList(System.getProperty(ROOTS_TO_MAP, "")), new IClosure<SQLDataSource>() {
            @Override
            public void executeChecked(SQLDataSource input) {
                input.addConnectionProperty("allowMultiQueries", "true");
            }
        });
        return sysRoot.getRoot(url1.getRootName());
    }

    private static String getDesc(final DBRoot root) {
        final SQL_URL url = root.getURL();
        if (url != null) {
            return url.asString();
        } else {
            return "root " + SQLBase.quoteIdentifier(root.getName()) + " of " + root.getDBSystemRoot().getDataSource().getUrl();
        }
    }

    private final DBRoot a, b;

    public Diff(DBRoot a, DBRoot b) {
        super();
        this.a = a;
        this.b = b;
    }

    private final String getHeader(final Collection<String> tableName) {
        final String t = tableName == null ? "" : "/" + tableName;
        return "-- To change " + getDesc(this.a) + t + "\n-- into " + getDesc(this.b) + t + "\n-- \n";
    }

    private Set<String> getTablesUnion() {
        return CollectionUtils.union(this.a.getChildrenNames(), this.b.getChildrenNames());
    }

    public final String compute() {
        return this.getHeader(null) + this.computeBody(getTablesUnion());
    }

    public final List<ChangeTable<?>> getChangeTables() {
        return this.getChangeTables(getTablesUnion());
    }

    public final List<ChangeTable<?>> getChangeTables(final Collection<String> tables) {
        final List<ChangeTable<?>> l = new ArrayList<ChangeTable<?>>();
        for (final String table : tables) {
            final ChangeTable<?> compute = this.computeP(table);
            if (compute != null) {
                l.add(compute);
            }
        }
        return l;
    }

    private final String computeBody(final Collection<String> tables) {
        final List<ChangeTable<?>> l = getChangeTables(tables);
        if (Boolean.getBoolean(SIMPLE_SEQ)) {
            final StringBuilder sb = new StringBuilder();
            for (final ChangeTable<?> compute : l) {
                sb.append("\n-- " + compute.getName() + "\n");
                sb.append(compute.asString(this.a.getName()));
                sb.append("\n");
            }
            return sb.toString();
        } else
            return ChangeTable.catToString(l, this.a.getName());
    }

    public final String compute(final Collection<String> tableName) {
        return this.getHeader(tableName) + this.computeBody(tableName);
    }

    private final ChangeTable<?> computeP(final String tableName) {
        final boolean inA = this.a.contains(tableName);
        final boolean inB = this.b.contains(tableName);
        if (!inA && !inB)
            return null;
        else if (inA && !inB)
            return new DropTable(this.a.getTable(tableName));
        else if (!inA && inB) {
            final SQLTable bT = this.b.getTable(tableName);
            return bT.getCreateTable(this.a.getDBSystemRoot().getSyntax());
        } else {
            // in both
            final SQLTable aT = this.a.getTable(tableName);
            final SQLTable bT = this.b.getTable(tableName);
            if (aT.equalsDesc(bT))
                return null;
            else {
                final AlterTable alterTable = new AlterTable(aT);
                final SQLSystem aSystem = aT.getServer().getSQLSystem();
                final SQLSystem bSystem = bT.getServer().getSQLSystem();
                final SQLSyntax bSyntax = bT.getDBSystemRoot().getSyntax();
                {
                    final Set<String> aFields = aT.getFieldsName();
                    final Set<String> bFields = bT.getFieldsName();
                    for (final String rm : CollectionUtils.substract(aFields, bFields)) {
                        alterTable.dropColumn(rm);
                    }
                    for (final String added : CollectionUtils.substract(bFields, aFields)) {
                        alterTable.addColumn(bT.getField(added));
                    }
                    for (final String common : CollectionUtils.inter(aFields, bFields)) {
                        final SQLField aF = aT.getField(common);
                        final SQLField bF = bT.getField(common);
                        final Map<Properties, String> diff = aF.getDiffMap(bF, bSyntax, true);
                        alterTable.alterColumn(common, bF, diff.keySet());
                    }
                }
                final List<String> aPKNames = aT.getPKsNames();
                final List<String> bPKNames = bT.getPKsNames();
                if (!aPKNames.equals(bPKNames)) {
                    if (aPKNames.size() > 0)
                        alterTable.dropPrimaryKey();
                    if (bPKNames.size() > 0)
                        alterTable.addPrimaryKey(bPKNames);
                }

                // foreign keys
                {
                    final Set<ProxyItf<Link>> aFKs = CustomEquals.createSet(Link.getInterSystemHashStrategy(), aT.getForeignLinks());
                    final Set<ProxyItf<Link>> bFKs = CustomEquals.createSet(Link.getInterSystemHashStrategy(), bT.getForeignLinks());
                    for (final ProxyItf<Link> removed : CollectionUtils.substract(aFKs, bFKs)) {
                        if (removed.getDelegate().getName() == null)
                            throw new IllegalStateException(removed + " is not a real constraint, use AddFK");
                        alterTable.dropForeignConstraint(removed.getDelegate().getName());
                    }
                    for (final ProxyItf<Link> added : CollectionUtils.substract(bFKs, aFKs)) {
                        final Link link = added.getDelegate();
                        alterTable.addForeignConstraint(link, false);
                    }
                }

                // indexes
                try {
                    // order irrelevant
                    final Set<Index> aIndexes = new HashSet<Index>(aT.getIndexes());
                    final Set<Index> bIndexes = new HashSet<Index>(bT.getIndexes());
                    for (final Index rm : CollectionUtils.substract(aIndexes, bIndexes)) {
                        alterTable.dropIndex(rm.getName());
                    }
                    for (final Index added : CollectionUtils.substract(bIndexes, aIndexes)) {
                        alterTable.addIndex(added);
                    }
                } catch (SQLException e) {
                    throw new UnsupportedOperationException("couldn't get indexes", e);
                }

                // constraints
                {
                    final HashingStrategy<Constraint> strategy = aSystem.equals(bSystem) ? null : Constraint.getInterSystemHashStrategy();
                    final Set<ProxyItf<Constraint>> aConstr = CustomEquals.createSet(strategy, aT.getConstraints());
                    final Set<ProxyItf<Constraint>> bConstr = CustomEquals.createSet(strategy, bT.getConstraints());
                    for (final ProxyItf<Constraint> rm : CollectionUtils.substract(aConstr, bConstr)) {
                        alterTable.dropConstraint(rm.getDelegate().getName());
                    }
                    for (final ProxyItf<Constraint> addedP : CollectionUtils.substract(bConstr, aConstr)) {
                        final Constraint added = addedP.getDelegate();
                        if (added.getType() == ConstraintType.UNIQUE)
                            alterTable.addUniqueConstraint(added.getName(), added.getCols());
                        else
                            throw new UnsupportedOperationException("unsupported constraint: " + added);
                    }
                }

                final boolean checkComment = aSystem.isTablesCommentSupported() && bSystem.isTablesCommentSupported();
                if (checkComment && !CompareUtils.equals(aT.getComment(), bT.getComment())) {
                    alterTable.addOutsideClause(alterTable.getSyntax().getSetTableComment(bT.getComment()));
                }

                if (alterTable.isEmpty()) {
                    final String exactDiff = aT.equalsDesc(bT, null, true);
                    assert exactDiff != null : "Why bother if exactly equals";
                    final String lenientDiff = aT.equalsDesc(bT, bSyntax, true);
                    if (lenientDiff == null)
                        Log.get().info("Tables " + aT.getSQLName() + " and " + bT.getSQLName() + " are not exactly equal, but due to diferring DB system features can't be :\n" + exactDiff);
                    else
                        throw new IllegalStateException("Unequal tables with no ALTER TABLE : " + aT.getSQLName() + " and " + bT.getSQLName() + "\n" + lenientDiff);
                }
                return alterTable;
            }
        }
    }
}