← Back to branch summary

~ubuntu-branches/ubuntu/wily/apgdiff/wily

« 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: 2009-12-02 11:11:33 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20091202111133-k5wrh3zb2pzmbv8c
Tags: 1.4-1
* New upstream version. (Without changelog, I am afraid.)
* Test suite still not enabled as it needs network access. (The junit
  version in Debian needs upgrading.)
* Optimize rules files a bit so debhelper doesn't clean twice, and quilt's
  patch target doesn't prevent build-stamp from working.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/java/cz/startnet/utils/pgdiff/PgDiff.java
1
 
/*
2
 
 * $Id: PgDiff.java 91 2008-08-01 17:35:19Z fordfrog $
3
 
 */
4
1
package cz.startnet.utils.pgdiff;
5
2
 
6
3
import cz.startnet.utils.pgdiff.loader.PgDumpLoader;
14
11
 * Creates diff of two database schemas.
15
12
 *
16
13
 * @author fordfrog
17
 
 * @version $Id: PgDiff.java 91 2008-08-01 17:35:19Z fordfrog $
18
14
 */
19
15
public class PgDiff {
20
16
 
31
27
     * @param writer writer the output should be written to
32
28
     * @param arguments object containing arguments settings
33
29
     */
34
 
    public static void createDiff(
35
 
        final PrintWriter writer,
36
 
        final PgDiffArguments arguments) {
37
 
        diffDatabaseSchemas(
38
 
            writer,
39
 
            arguments,
40
 
            PgDumpLoader.loadDatabaseSchema(arguments.getOldDumpFile(),
41
 
            arguments.getInCharsetName()),
42
 
            PgDumpLoader.loadDatabaseSchema(arguments.getNewDumpFile(),
43
 
            arguments.getInCharsetName()));
 
30
    public static void createDiff(final PrintWriter writer,
 
31
            final PgDiffArguments arguments) {
 
32
        diffDatabaseSchemas(writer, arguments,
 
33
                PgDumpLoader.loadDatabaseSchema(arguments.getOldDumpFile(),
 
34
                arguments.getInCharsetName()),
 
35
                PgDumpLoader.loadDatabaseSchema(arguments.getNewDumpFile(),
 
36
                arguments.getInCharsetName()));
44
37
    }
45
38
 
46
39
    /**
53
46
     * @param newInputStream input stream of file containing dump of the new
54
47
     *        schema
55
48
     */
56
 
    public static void createDiff(
57
 
        final PrintWriter writer,
58
 
        final PgDiffArguments arguments,
59
 
        final InputStream oldInputStream,
60
 
        final InputStream newInputStream) {
61
 
        diffDatabaseSchemas(
62
 
            writer,
63
 
            arguments,
64
 
            PgDumpLoader.loadDatabaseSchema(oldInputStream, arguments.
65
 
            getInCharsetName()),
66
 
            PgDumpLoader.loadDatabaseSchema(newInputStream, arguments.
67
 
            getInCharsetName()));
 
49
    public static void createDiff(final PrintWriter writer,
 
50
            final PgDiffArguments arguments, final InputStream oldInputStream,
 
51
            final InputStream newInputStream) {
 
52
        diffDatabaseSchemas(writer, arguments,
 
53
                PgDumpLoader.loadDatabaseSchema(
 
54
                oldInputStream, arguments.getInCharsetName()),
 
55
                PgDumpLoader.loadDatabaseSchema(
 
56
                newInputStream, arguments.getInCharsetName()));
68
57
    }
69
58
 
70
59
    /**
75
64
     * @param oldDatabase original database schema
76
65
     * @param newDatabase new database schema
77
66
     */
78
 
    private static void createNewSchemas(
79
 
        final PrintWriter writer,
80
 
        final PgDiffArguments arguments,
81
 
        final PgDatabase oldDatabase,
82
 
        final PgDatabase newDatabase) {
83
 
        for (PgSchema newSchema : newDatabase.getSchemas()) {
 
67
    private static void createNewSchemas(final PrintWriter writer,
 
68
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
 
69
            final PgDatabase newDatabase) {
 
70
        for (final PgSchema newSchema : newDatabase.getSchemas()) {
84
71
            if (oldDatabase.getSchema(newSchema.getName()) == null) {
85
72
                writer.println();
86
 
                writer.println(
87
 
                    newSchema.getCreationSQL(arguments.isQuoteNames()));
 
73
                writer.println(newSchema.getCreationSQL(
 
74
                        arguments.isQuoteNames()));
88
75
            }
89
76
        }
90
77
    }
97
84
     * @param oldDatabase original database schema
98
85
     * @param newDatabase new database schema
99
86
     */
100
 
    private static void diffDatabaseSchemas(
101
 
        final PrintWriter writer,
102
 
        final PgDiffArguments arguments,
103
 
        final PgDatabase oldDatabase,
104
 
        final PgDatabase newDatabase) {
 
87
    private static void diffDatabaseSchemas(final PrintWriter writer,
 
88
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
 
89
            final PgDatabase newDatabase) {
105
90
        if (arguments.isAddTransaction()) {
106
91
            writer.println("START TRANSACTION;");
107
92
        }
124
109
     * @param oldDatabase original database schema
125
110
     * @param newDatabase new database schema
126
111
     */
127
 
    private static void dropOldSchemas(
128
 
        final PrintWriter writer,
129
 
        final PgDiffArguments arguments,
130
 
        final PgDatabase oldDatabase,
131
 
        final PgDatabase newDatabase) {
132
 
        for (PgSchema oldSchema : oldDatabase.getSchemas()) {
 
112
    private static void dropOldSchemas(final PrintWriter writer,
 
113
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
 
114
            final PgDatabase newDatabase) {
 
115
        for (final PgSchema oldSchema : oldDatabase.getSchemas()) {
133
116
            if (newDatabase.getSchema(oldSchema.getName()) == null) {
134
117
                writer.println();
135
 
                writer.println(
136
 
                    "DROP SCHEMA " + PgDiffUtils.getQuotedName(
137
 
                    oldSchema.getName(),
138
 
                    arguments.isQuoteNames()) + " CASCADE;");
 
118
                writer.println("DROP SCHEMA "
 
119
                        + PgDiffUtils.getQuotedName(oldSchema.getName(),
 
120
                        arguments.isQuoteNames()) + " CASCADE;");
139
121
            }
140
122
        }
141
123
    }
148
130
     * @param oldDatabase original database schema
149
131
     * @param newDatabase new database schema
150
132
     */
151
 
    private static void updateSchemas(
152
 
        final PrintWriter writer,
153
 
        final PgDiffArguments arguments,
154
 
        final PgDatabase oldDatabase,
155
 
        final PgDatabase newDatabase) {
156
 
        final boolean setSearchPath =
157
 
            (newDatabase.getSchemas().size() > 1) || !newDatabase.getSchemas().
158
 
            get(0).getName().equals("public");
 
133
    private static void updateSchemas(final PrintWriter writer,
 
134
            final PgDiffArguments arguments, final PgDatabase oldDatabase,
 
135
            final PgDatabase newDatabase) {
 
136
        final boolean setSearchPath = (newDatabase.getSchemas().size() > 1)
 
137
                || !newDatabase.getSchemas().
 
138
                get(0).getName().equals("public");
159
139
 
160
 
        for (PgSchema newSchema : newDatabase.getSchemas()) {
 
140
        for (final PgSchema newSchema : newDatabase.getSchemas()) {
161
141
            if (setSearchPath) {
162
142
                writer.println();
163
 
                writer.println(
164
 
                    "SET search_path = " + PgDiffUtils.getQuotedName(
165
 
                    newSchema.getName(),
166
 
                    arguments.isQuoteNames()) + ", pg_catalog;");
 
143
                writer.println("SET search_path = "
 
144
                        + PgDiffUtils.getQuotedName(newSchema.getName(),
 
145
                        arguments.isQuoteNames()) + ", pg_catalog;");
167
146
            }
168
147
 
169
148
            final PgSchema oldSchema =
170
 
                oldDatabase.getSchema(newSchema.getName());
171
 
            PgDiffFunctions.diffFunctions(writer, arguments, oldSchema,
172
 
                newSchema);
 
149
                    oldDatabase.getSchema(newSchema.getName());
 
150
 
 
151
            PgDiffFunctions.dropFunctions(
 
152
                    writer, arguments, oldSchema, newSchema);
 
153
            PgDiffTriggers.dropTriggers(
 
154
                    writer, arguments, oldSchema, newSchema);
 
155
            PgDiffFunctions.createFunctions(
 
156
                    writer, arguments, oldSchema, newSchema);
173
157
            PgDiffViews.dropViews(writer, arguments, oldSchema, newSchema);
174
 
            PgDiffSequences.diffSequences(
175
 
                writer,
176
 
                arguments,
177
 
                oldSchema,
178
 
                newSchema);
179
 
            PgDiffTables.diffTables(writer, arguments, oldSchema, newSchema);
180
 
            PgDiffConstraints.diffConstraints(
181
 
                writer,
182
 
                arguments,
183
 
                oldSchema,
184
 
                newSchema,
185
 
                true);
186
 
            PgDiffConstraints.diffConstraints(
187
 
                writer,
188
 
                arguments,
189
 
                oldSchema,
190
 
                newSchema,
191
 
                false);
192
 
            PgDiffIndexes.diffIndexes(writer, arguments, oldSchema, newSchema);
193
 
            PgDiffTables.diffClusters(writer, arguments, oldSchema, newSchema);
194
 
            PgDiffTriggers.diffTriggers(
195
 
                writer,
196
 
                arguments,
197
 
                oldSchema,
198
 
                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);
 
167
 
 
168
            PgDiffSequences.createSequences(
 
169
                    writer, arguments, oldSchema, newSchema);
 
170
            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);
 
178
            PgDiffIndexes.createIndexes(
 
179
                    writer, arguments, oldSchema, newSchema);
 
180
            PgDiffTables.createClusters(
 
181
                    writer, arguments, oldSchema, newSchema);
 
182
            PgDiffTriggers.createTriggers(
 
183
                    writer, arguments, oldSchema, newSchema);
199
184
            PgDiffViews.createViews(writer, arguments, oldSchema, newSchema);
200
185
        }
201
186
    }