← Back to branch summary

~ubuntu-branches/ubuntu/vivid/apgdiff/vivid

« back to all changes in this revision

Viewing changes to src/main/java/cz/startnet/utils/pgdiff/PgDiff.java

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Berg
  • Date: 2010-10-02 19:35:17 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20101002193517-9wesve8sksxcktkc
Tags: 2.2-1
* New upstream version.
* Update homepage location.
* Finally enable test suite, yay!

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/java/cz/startnet/utils/pgdiff/PgDiff.java
 
1
/**
 
2
 * Copyright 2006 StartNet s.r.o.
 
3
 *
 
4
 * Distributed under MIT license
 
5
 */
1
6
package cz.startnet.utils.pgdiff;
2
7
 
3
8
import cz.startnet.utils.pgdiff.loader.PgDumpLoader;
18
23
     * Creates a new instance of PgDiff.
19
24
     */
20
25
    private PgDiff() {
21
 
        super();
22
26
    }
23
27
 
24
28
    /**
31
35
            final PgDiffArguments arguments) {
32
36
        diffDatabaseSchemas(writer, arguments,
33
37
                PgDumpLoader.loadDatabaseSchema(arguments.getOldDumpFile(),
34
 
                arguments.getInCharsetName()),
 
38
                arguments.getInCharsetName(),
 
39
                arguments.isOutputIgnoredStatements()),
35
40
                PgDumpLoader.loadDatabaseSchema(arguments.getNewDumpFile(),
36
 
                arguments.getInCharsetName()));
 
41
                arguments.getInCharsetName(),
 
42
                arguments.isOutputIgnoredStatements()));
37
43
    }
38
44
 
39
45
    /**
50
56
            final PgDiffArguments arguments, final InputStream oldInputStream,
51
57
            final InputStream newInputStream) {
52
58
        diffDatabaseSchemas(writer, arguments,
53
 
                PgDumpLoader.loadDatabaseSchema(
54
 
                oldInputStream, arguments.getInCharsetName()),
55
 
                PgDumpLoader.loadDatabaseSchema(
56
 
                newInputStream, arguments.getInCharsetName()));
 
59
                PgDumpLoader.loadDatabaseSchema(oldInputStream,
 
60
                arguments.getInCharsetName(),
 
61
                arguments.isOutputIgnoredStatements()),
 
62
                PgDumpLoader.loadDatabaseSchema(newInputStream,
 
63
                arguments.getInCharsetName(),
 
64
                arguments.isOutputIgnoredStatements()));
57
65
    }
58
66
 
59
67
    /**
60
68
     * Creates new schemas (not the objects inside the schemas).
61
69
     *
62
70
     * @param writer writer the output should be written to
63
 
     * @param arguments object containing arguments settings
64
71
     * @param oldDatabase original database schema
65
72
     * @param newDatabase new database schema
66
73
     */
67
74
    private static void createNewSchemas(final PrintWriter writer,
68
 
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
69
 
            final PgDatabase newDatabase) {
 
75
            final PgDatabase oldDatabase, final PgDatabase newDatabase) {
70
76
        for (final PgSchema newSchema : newDatabase.getSchemas()) {
71
77
            if (oldDatabase.getSchema(newSchema.getName()) == null) {
72
78
                writer.println();
73
 
                writer.println(newSchema.getCreationSQL(
74
 
                        arguments.isQuoteNames()));
 
79
                writer.println(newSchema.getCreationSQL());
75
80
            }
76
81
        }
77
82
    }
91
96
            writer.println("START TRANSACTION;");
92
97
        }
93
98
 
94
 
        dropOldSchemas(writer, arguments, oldDatabase, newDatabase);
95
 
        createNewSchemas(writer, arguments, oldDatabase, newDatabase);
 
99
        dropOldSchemas(writer, oldDatabase, newDatabase);
 
100
        createNewSchemas(writer, oldDatabase, newDatabase);
96
101
        updateSchemas(writer, arguments, oldDatabase, newDatabase);
97
102
 
98
103
        if (arguments.isAddTransaction()) {
99
104
            writer.println();
100
105
            writer.println("COMMIT TRANSACTION;");
101
106
        }
 
107
 
 
108
        if (arguments.isOutputIgnoredStatements()) {
 
109
            if (!oldDatabase.getIgnoredStatements().isEmpty()) {
 
110
                writer.println();
 
111
                writer.println("/* Original database ignored statements");
 
112
 
 
113
                for (final String statement :
 
114
                        oldDatabase.getIgnoredStatements()) {
 
115
                    writer.println();
 
116
                    writer.println(statement);
 
117
                }
 
118
 
 
119
                writer.println("*/");
 
120
            }
 
121
 
 
122
            if (!newDatabase.getIgnoredStatements().isEmpty()) {
 
123
                writer.println();
 
124
                writer.println("/* New database ignored statements");
 
125
 
 
126
                for (final String statement :
 
127
                        newDatabase.getIgnoredStatements()) {
 
128
                    writer.println();
 
129
                    writer.println(statement);
 
130
                }
 
131
 
 
132
                writer.println("*/");
 
133
            }
 
134
        }
102
135
    }
103
136
 
104
137
    /**
105
138
     * Drops old schemas that do not exist anymore.
106
139
     *
107
140
     * @param writer writer the output should be written to
108
 
     * @param arguments object containing arguments settings
109
141
     * @param oldDatabase original database schema
110
142
     * @param newDatabase new database schema
111
143
     */
112
144
    private static void dropOldSchemas(final PrintWriter writer,
113
 
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
114
 
            final PgDatabase newDatabase) {
 
145
            final PgDatabase oldDatabase, final PgDatabase newDatabase) {
115
146
        for (final PgSchema oldSchema : oldDatabase.getSchemas()) {
116
147
            if (newDatabase.getSchema(oldSchema.getName()) == null) {
117
148
                writer.println();
118
149
                writer.println("DROP SCHEMA "
119
 
                        + PgDiffUtils.getQuotedName(oldSchema.getName(),
120
 
                        arguments.isQuoteNames()) + " CASCADE;");
 
150
                        + PgDiffUtils.getQuotedName(oldSchema.getName())
 
151
                        + " CASCADE;");
121
152
            }
122
153
        }
123
154
    }
133
164
    private static void updateSchemas(final PrintWriter writer,
134
165
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
135
166
            final PgDatabase newDatabase) {
136
 
        final boolean setSearchPath = (newDatabase.getSchemas().size() > 1)
137
 
                || !newDatabase.getSchemas().
138
 
                get(0).getName().equals("public");
 
167
        final boolean setSearchPath = newDatabase.getSchemas().size() > 1
 
168
                || !newDatabase.getSchemas().get(0).getName().equals("public");
139
169
 
140
170
        for (final PgSchema newSchema : newDatabase.getSchemas()) {
141
171
            if (setSearchPath) {
142
172
                writer.println();
143
173
                writer.println("SET search_path = "
144
 
                        + PgDiffUtils.getQuotedName(newSchema.getName(),
145
 
                        arguments.isQuoteNames()) + ", pg_catalog;");
 
174
                        + PgDiffUtils.getQuotedName(newSchema.getName(), true)
 
175
                        + ", pg_catalog;");
146
176
            }
147
177
 
148
178
            final PgSchema oldSchema =
149
179
                    oldDatabase.getSchema(newSchema.getName());
150
180
 
 
181
            PgDiffTriggers.dropTriggers(writer, oldSchema, newSchema);
151
182
            PgDiffFunctions.dropFunctions(
152
183
                    writer, arguments, oldSchema, newSchema);
153
 
            PgDiffTriggers.dropTriggers(
154
 
                    writer, arguments, oldSchema, newSchema);
155
184
            PgDiffFunctions.createFunctions(
156
185
                    writer, arguments, oldSchema, newSchema);
157
 
            PgDiffViews.dropViews(writer, arguments, oldSchema, newSchema);
158
 
            PgDiffConstraints.dropConstraints(
159
 
                    writer, arguments, oldSchema, newSchema, true);
160
 
            PgDiffConstraints.dropConstraints(
161
 
                    writer, arguments, oldSchema, newSchema, false);
162
 
            PgDiffIndexes.dropIndexes(writer, arguments, oldSchema, newSchema);
163
 
            PgDiffTables.dropClusters(writer, arguments, oldSchema, newSchema);
164
 
            PgDiffTables.dropTables(writer, arguments, oldSchema, newSchema);
165
 
            PgDiffSequences.dropSequences(
166
 
                    writer, arguments, oldSchema, newSchema);
 
186
            PgDiffViews.dropViews(writer, oldSchema, newSchema);
 
187
            PgDiffConstraints.dropConstraints(
 
188
                    writer, oldSchema, newSchema, true);
 
189
            PgDiffConstraints.dropConstraints(
 
190
                    writer, oldSchema, newSchema, false);
 
191
            PgDiffIndexes.dropIndexes(writer, oldSchema, newSchema);
 
192
            PgDiffTables.dropClusters(writer, oldSchema, newSchema);
 
193
            PgDiffTables.dropTables(writer, oldSchema, newSchema);
 
194
            PgDiffSequences.dropSequences(writer, oldSchema, newSchema);
167
195
 
168
 
            PgDiffSequences.createSequences(
169
 
                    writer, arguments, oldSchema, newSchema);
 
196
            PgDiffSequences.createSequences(writer, oldSchema, newSchema);
170
197
            PgDiffSequences.alterSequences(
171
198
                    writer, arguments, oldSchema, newSchema);
172
 
            PgDiffTables.createTables(writer, arguments, oldSchema, newSchema);
 
199
            PgDiffTables.createTables(writer, oldSchema, newSchema);
173
200
            PgDiffTables.alterTables(writer, arguments, oldSchema, newSchema);
174
201
            PgDiffConstraints.createConstraints(
175
 
                    writer, arguments, oldSchema, newSchema, true);
 
202
                    writer, oldSchema, newSchema, true);
176
203
            PgDiffConstraints.createConstraints(
177
 
                    writer, arguments, oldSchema, newSchema, false);
178
 
            PgDiffIndexes.createIndexes(
179
 
                    writer, arguments, oldSchema, newSchema);
180
 
            PgDiffTables.createClusters(
181
 
                    writer, arguments, oldSchema, newSchema);
182
 
            PgDiffTriggers.createTriggers(
183
 
                    writer, arguments, oldSchema, newSchema);
184
 
            PgDiffViews.createViews(writer, arguments, oldSchema, newSchema);
 
204
                    writer, oldSchema, newSchema, false);
 
205
            PgDiffIndexes.createIndexes(writer, oldSchema, newSchema);
 
206
            PgDiffTables.createClusters(writer, oldSchema, newSchema);
 
207
            PgDiffTriggers.createTriggers(writer, oldSchema, newSchema);
 
208
            PgDiffViews.createViews(writer, oldSchema, newSchema);
 
209
            PgDiffViews.alterViews(writer, oldSchema, newSchema);
185
210
        }
186
211
    }
187
212
}