← Back to branch summary

~ubuntu-branches/ubuntu/raring/apgdiff/raring

« 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-11 09:08:18 UTC
  • mfrom: (2.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20101011090818-sdw8yfemrnxo328k
Tags: 2.2.2-1
* New upstream version.
* Using changelog included in zipfile, thanks Miroslav for providing this.
* Update manpage.

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.print("/* ");
 
112
                writer.println(Resources.getString(
 
113
                        "OriginalDatabaseIgnoredStatements"));
 
114
 
 
115
                for (final String statement :
 
116
                        oldDatabase.getIgnoredStatements()) {
 
117
                    writer.println();
 
118
                    writer.println(statement);
 
119
                }
 
120
 
 
121
                writer.println("*/");
 
122
            }
 
123
 
 
124
            if (!newDatabase.getIgnoredStatements().isEmpty()) {
 
125
                writer.println();
 
126
                writer.print("/* ");
 
127
                writer.println(
 
128
                        Resources.getString("NewDatabaseIgnoredStatements"));
 
129
 
 
130
                for (final String statement :
 
131
                        newDatabase.getIgnoredStatements()) {
 
132
                    writer.println();
 
133
                    writer.println(statement);
 
134
                }
 
135
 
 
136
                writer.println("*/");
 
137
            }
 
138
        }
102
139
    }
103
140
 
104
141
    /**
105
142
     * Drops old schemas that do not exist anymore.
106
143
     *
107
144
     * @param writer writer the output should be written to
108
 
     * @param arguments object containing arguments settings
109
145
     * @param oldDatabase original database schema
110
146
     * @param newDatabase new database schema
111
147
     */
112
148
    private static void dropOldSchemas(final PrintWriter writer,
113
 
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
114
 
            final PgDatabase newDatabase) {
 
149
            final PgDatabase oldDatabase, final PgDatabase newDatabase) {
115
150
        for (final PgSchema oldSchema : oldDatabase.getSchemas()) {
116
151
            if (newDatabase.getSchema(oldSchema.getName()) == null) {
117
152
                writer.println();
118
153
                writer.println("DROP SCHEMA "
119
 
                        + PgDiffUtils.getQuotedName(oldSchema.getName(),
120
 
                        arguments.isQuoteNames()) + " CASCADE;");
 
154
                        + PgDiffUtils.getQuotedName(oldSchema.getName())
 
155
                        + " CASCADE;");
121
156
            }
122
157
        }
123
158
    }
133
168
    private static void updateSchemas(final PrintWriter writer,
134
169
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
135
170
            final PgDatabase newDatabase) {
136
 
        final boolean setSearchPath = (newDatabase.getSchemas().size() > 1)
137
 
                || !newDatabase.getSchemas().
138
 
                get(0).getName().equals("public");
 
171
        final boolean setSearchPath = newDatabase.getSchemas().size() > 1
 
172
                || !newDatabase.getSchemas().get(0).getName().equals("public");
139
173
 
140
174
        for (final PgSchema newSchema : newDatabase.getSchemas()) {
 
175
            final SearchPathHelper searchPathHelper;
 
176
 
141
177
            if (setSearchPath) {
142
 
                writer.println();
143
 
                writer.println("SET search_path = "
144
 
                        + PgDiffUtils.getQuotedName(newSchema.getName(),
145
 
                        arguments.isQuoteNames()) + ", pg_catalog;");
 
178
                searchPathHelper = new SearchPathHelper("SET search_path = "
 
179
                        + PgDiffUtils.getQuotedName(newSchema.getName(), true)
 
180
                        + ", pg_catalog;");
 
181
            } else {
 
182
                searchPathHelper = new SearchPathHelper(null);
146
183
            }
147
184
 
148
185
            final PgSchema oldSchema =
149
186
                    oldDatabase.getSchema(newSchema.getName());
150
187
 
 
188
            PgDiffTriggers.dropTriggers(
 
189
                    writer, oldSchema, newSchema, searchPathHelper);
151
190
            PgDiffFunctions.dropFunctions(
152
 
                    writer, arguments, oldSchema, newSchema);
153
 
            PgDiffTriggers.dropTriggers(
154
 
                    writer, arguments, oldSchema, newSchema);
 
191
                    writer, arguments, oldSchema, newSchema, searchPathHelper);
155
192
            PgDiffFunctions.createFunctions(
156
 
                    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);
 
193
                    writer, arguments, oldSchema, newSchema, searchPathHelper);
 
194
            PgDiffViews.dropViews(
 
195
                    writer, oldSchema, newSchema, searchPathHelper);
 
196
            PgDiffConstraints.dropConstraints(
 
197
                    writer, oldSchema, newSchema, true, searchPathHelper);
 
198
            PgDiffConstraints.dropConstraints(
 
199
                    writer, oldSchema, newSchema, false, searchPathHelper);
 
200
            PgDiffIndexes.dropIndexes(
 
201
                    writer, oldSchema, newSchema, searchPathHelper);
 
202
            PgDiffTables.dropClusters(
 
203
                    writer, oldSchema, newSchema, searchPathHelper);
 
204
            PgDiffTables.dropTables(
 
205
                    writer, oldSchema, newSchema, searchPathHelper);
165
206
            PgDiffSequences.dropSequences(
166
 
                    writer, arguments, oldSchema, newSchema);
 
207
                    writer, oldSchema, newSchema, searchPathHelper);
167
208
 
168
209
            PgDiffSequences.createSequences(
169
 
                    writer, arguments, oldSchema, newSchema);
 
210
                    writer, oldSchema, newSchema, searchPathHelper);
170
211
            PgDiffSequences.alterSequences(
171
 
                    writer, arguments, oldSchema, newSchema);
172
 
            PgDiffTables.createTables(writer, arguments, oldSchema, newSchema);
173
 
            PgDiffTables.alterTables(writer, arguments, oldSchema, newSchema);
174
 
            PgDiffConstraints.createConstraints(
175
 
                    writer, arguments, oldSchema, newSchema, true);
176
 
            PgDiffConstraints.createConstraints(
177
 
                    writer, arguments, oldSchema, newSchema, false);
 
212
                    writer, arguments, oldSchema, newSchema, searchPathHelper);
 
213
            PgDiffTables.createTables(
 
214
                    writer, oldSchema, newSchema, searchPathHelper);
 
215
            PgDiffTables.alterTables(
 
216
                    writer, arguments, oldSchema, newSchema, searchPathHelper);
 
217
            PgDiffConstraints.createConstraints(
 
218
                    writer, oldSchema, newSchema, true, searchPathHelper);
 
219
            PgDiffConstraints.createConstraints(
 
220
                    writer, oldSchema, newSchema, false, searchPathHelper);
178
221
            PgDiffIndexes.createIndexes(
179
 
                    writer, arguments, oldSchema, newSchema);
 
222
                    writer, oldSchema, newSchema, searchPathHelper);
180
223
            PgDiffTables.createClusters(
181
 
                    writer, arguments, oldSchema, newSchema);
 
224
                    writer, oldSchema, newSchema, searchPathHelper);
182
225
            PgDiffTriggers.createTriggers(
183
 
                    writer, arguments, oldSchema, newSchema);
184
 
            PgDiffViews.createViews(writer, arguments, oldSchema, newSchema);
 
226
                    writer, oldSchema, newSchema, searchPathHelper);
 
227
            PgDiffViews.createViews(
 
228
                    writer, oldSchema, newSchema, searchPathHelper);
 
229
            PgDiffViews.alterViews(
 
230
                    writer, oldSchema, newSchema, searchPathHelper);
185
231
        }
186
232
    }
187
233
}