liquibase.diff.compare.CompareControl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of liquibase-core Show documentation
Liquibase is a tool for managing and executing database changes.
There is a newer version: 4.29.2
package liquibase.diff.compare;

import liquibase.CatalogAndSchema;
import liquibase.database.Database;
import liquibase.exception.UnexpectedLiquibaseException;
import liquibase.structure.DatabaseObject;
import liquibase.structure.core.DatabaseObjectFactory;
import liquibase.util.StringUtil;

import java.util.*;

public class CompareControl {

    public static CompareControl STANDARD = new CompareControl();
    private CompareControl.SchemaComparison[] schemaComparisons;
    private Set> compareTypes = new HashSet<>();
    private Map, Set> suppressedFields = new HashMap<>();


    public CompareControl() {
        this(null);
    }

    public CompareControl(Set> compareTypes) {
        schemaComparisons = new SchemaComparison[]{new SchemaComparison(new CatalogAndSchema(null, null), new CatalogAndSchema(null, null))};
        setTypes(compareTypes);
    }

    public CompareControl(SchemaComparison[] schemaComparison, Set> compareTypes) {
        this.schemaComparisons = schemaComparison;
        setTypes(compareTypes);
    }

    public CompareControl(SchemaComparison[] schemaComparison, String compareTypes) {
        if ((schemaComparison != null) && (schemaComparison.length > 0)) {
            this.schemaComparisons = schemaComparison;
        } else {
            this.schemaComparisons = new SchemaComparison[]{new SchemaComparison(new CatalogAndSchema(null, null), new CatalogAndSchema(null, null))};
        }
        setTypes(DatabaseObjectFactory.getInstance().parseTypes(compareTypes));
    }

    public CompareControl(String[] referenceVsComparisonSchemas, Set> compareTypes) {
        String[] splitReferenceSchemas = referenceVsComparisonSchemas[0].split(",");
        String[] splitComparisonSchemas = referenceVsComparisonSchemas[1].split(",");
        this.schemaComparisons = new SchemaComparison[splitReferenceSchemas.length];
        for (int i = 0; i < splitReferenceSchemas.length; i++) {
            String referenceCatalogName = null;
            String referenceSchemaName = splitReferenceSchemas[i];
            if (referenceSchemaName.contains(".")) {
                referenceCatalogName = referenceSchemaName.split(".", 2)[0];
                referenceSchemaName = referenceSchemaName.split(".", 2)[1];
            }

            String comparisonCatalogName = null;
            String comparisonSchemaName = splitComparisonSchemas[i];
            if (comparisonSchemaName.contains(".")) {
                comparisonCatalogName = comparisonSchemaName.split(".", 2)[0];
                comparisonSchemaName = comparisonSchemaName.split(".", 2)[1];
            }

            CatalogAndSchema referenceSchema = new CatalogAndSchema(referenceCatalogName, referenceSchemaName);
            CatalogAndSchema comparisonSchema = new CatalogAndSchema(comparisonCatalogName, comparisonSchemaName);
            this.schemaComparisons[i] = new SchemaComparison(referenceSchema, comparisonSchema);

            setTypes(compareTypes);
        }
    }

    public static ComputedSchemas computeSchemas(String schemaNames, String referenceSchemaNames, String
        outputSchemaNames, String defaultCatalogName, String defaultSchemaName, String referenceDefaultCatalogName,
                                                 String referenceDefaultSchemaName, Database database) {

        //Make sure either both schemaNames and referenceSchemaNames are set or both are null. If only one is set,
        // make them equal
        if ((schemaNames == null) && (referenceSchemaNames == null)) {
            //they will be set to the defaults
        } else if ((schemaNames == null) && (referenceSchemaNames != null)) {
            schemaNames = referenceSchemaNames;
        } else if ((schemaNames != null) && (referenceSchemaNames == null)) {
            referenceSchemaNames = schemaNames;
        }

        if ((schemaNames == null) && (outputSchemaNames != null)) {
            if (defaultSchemaName == null) {
                schemaNames = database.getDefaultSchemaName();
            } else {
                schemaNames = defaultSchemaName;
            }
            referenceSchemaNames = schemaNames;
        }

        ComputedSchemas returnObj = new ComputedSchemas();
        if (referenceSchemaNames == null) {
            returnObj.finalSchemaComparisons = new CompareControl.SchemaComparison[]{new CompareControl
                .SchemaComparison(
                new CatalogAndSchema(referenceDefaultCatalogName, referenceDefaultSchemaName),
                new CatalogAndSchema(defaultCatalogName, defaultSchemaName)
            )};
            returnObj.finalTargetSchemas = new CatalogAndSchema[]{new CatalogAndSchema(defaultCatalogName,
                defaultSchemaName)};
        } else {
            List schemaComparisons = new ArrayList<>();
            List referenceSchemas = new ArrayList<>();
            List targetSchemas = new ArrayList<>();

            List splitReferenceSchemaNames = StringUtil.splitAndTrim(referenceSchemaNames, ",");
            List splitSchemaNames = StringUtil.splitAndTrim(schemaNames, ",");
            List splitOutputSchemaNames = StringUtil.splitAndTrim(StringUtil.trimToNull(outputSchemaNames),
                ",");

            if (splitReferenceSchemaNames.size() != splitSchemaNames.size()) {
                throw new UnexpectedLiquibaseException("You must specify the same number of schemas in --schemas and " +
                    "--referenceSchemas");
            }
            if ((splitOutputSchemaNames != null) && (splitOutputSchemaNames.size() != splitSchemaNames.size())) {
                throw new UnexpectedLiquibaseException("You must specify the same number of schemas in --schemas and " +
                    "--outputSchemasAs");
            }

            for (int i = 0; i < splitReferenceSchemaNames.size(); i++) {
                String referenceSchema = splitReferenceSchemaNames.get(i);
                String targetSchema = splitSchemaNames.get(i);
                String outputSchema = null;
                if (splitOutputSchemaNames != null) {
                    outputSchema = splitOutputSchemaNames.get(i);
                }

                CatalogAndSchema correctedTargetSchema = new CatalogAndSchema(null, targetSchema).customize(database);
                CatalogAndSchema correctedReferenceSchema = new CatalogAndSchema(null, referenceSchema).customize
                    (database);
                SchemaComparison comparison = new SchemaComparison(correctedReferenceSchema, correctedTargetSchema);
                comparison.setOutputSchemaAs(outputSchema);
                schemaComparisons.add(comparison);
                referenceSchemas.add(correctedReferenceSchema);
                targetSchemas.add(correctedTargetSchema);
            }
            returnObj.finalSchemaComparisons = schemaComparisons.toArray(new CompareControl
                .SchemaComparison[schemaComparisons.size()]);
            returnObj.finalTargetSchemas = targetSchemas.toArray(new CatalogAndSchema[targetSchemas.size()]);
        }

        return returnObj;
    }

    protected void setTypes(Set> types) {
        if ((types == null) || types.isEmpty()) {
            types = DatabaseObjectFactory.getInstance().getStandardTypes();
        }
        this.compareTypes = types;
    }

    public Set> getComparedTypes() {
        return compareTypes;
    }

    public CompareControl addSuppressedField(Class type, String field) {
        if (!suppressedFields.containsKey(type)) {
            suppressedFields.put(type, new HashSet());
        }
        suppressedFields.get(type).add(field);

        return this;
    }

    public boolean isSuppressedField(Class type, String field) {
        if (!suppressedFields.containsKey(type)) {
            return false;
        }
        return suppressedFields.get(type).contains(field);
    }

    public SchemaComparison[] getSchemaComparisons() {
        return schemaComparisons;
    }

    public CatalogAndSchema[] getSchemas(DatabaseRole databaseRole) {
        CatalogAndSchema[] schemas = new CatalogAndSchema[schemaComparisons.length];
        for (int i=0; i