← Back to branch summary

~ubuntu-branches/ubuntu/karmic/apgdiff/karmic

« 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: 2008-09-09 15:42:54 UTC
  • Revision ID: james.westby@ubuntu.com-20080909154254-458sv7ew1rczdal1
Tags: upstream-1.2
Import upstream version 1.2

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
package cz.startnet.utils.pgdiff;
 
5
 
 
6
import cz.startnet.utils.pgdiff.loader.PgDumpLoader;
 
7
import cz.startnet.utils.pgdiff.schema.PgDatabase;
 
8
import cz.startnet.utils.pgdiff.schema.PgSchema;
 
9
 
 
10
import java.io.InputStream;
 
11
import java.io.PrintWriter;
 
12
 
 
13
/**
 
14
 * Creates diff of two database schemas.
 
15
 *
 
16
 * @author fordfrog
 
17
 * @version $Id: PgDiff.java 91 2008-08-01 17:35:19Z fordfrog $
 
18
 */
 
19
public class PgDiff {
 
20
 
 
21
    /**
 
22
     * Creates a new instance of PgDiff.
 
23
     */
 
24
    private PgDiff() {
 
25
        super();
 
26
    }
 
27
 
 
28
    /**
 
29
     * Creates diff on the two database schemas.
 
30
     *
 
31
     * @param writer writer the output should be written to
 
32
     * @param arguments object containing arguments settings
 
33
     */
 
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()));
 
44
    }
 
45
 
 
46
    /**
 
47
     * Creates diff on the two database schemas.
 
48
     *
 
49
     * @param writer writer the output should be written to
 
50
     * @param arguments object containing arguments settings
 
51
     * @param oldInputStream input stream of file containing dump of the
 
52
     *        original schema
 
53
     * @param newInputStream input stream of file containing dump of the new
 
54
     *        schema
 
55
     */
 
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()));
 
68
    }
 
69
 
 
70
    /**
 
71
     * Creates new schemas (not the objects inside the schemas).
 
72
     *
 
73
     * @param writer writer the output should be written to
 
74
     * @param arguments object containing arguments settings
 
75
     * @param oldDatabase original database schema
 
76
     * @param newDatabase new database schema
 
77
     */
 
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()) {
 
84
            if (oldDatabase.getSchema(newSchema.getName()) == null) {
 
85
                writer.println();
 
86
                writer.println(
 
87
                    newSchema.getCreationSQL(arguments.isQuoteNames()));
 
88
            }
 
89
        }
 
90
    }
 
91
 
 
92
    /**
 
93
     * Creates diff from comparison of two database schemas.
 
94
     *
 
95
     * @param writer writer the output should be written to
 
96
     * @param arguments object containing arguments settings
 
97
     * @param oldDatabase original database schema
 
98
     * @param newDatabase new database schema
 
99
     */
 
100
    private static void diffDatabaseSchemas(
 
101
        final PrintWriter writer,
 
102
        final PgDiffArguments arguments,
 
103
        final PgDatabase oldDatabase,
 
104
        final PgDatabase newDatabase) {
 
105
        if (arguments.isAddTransaction()) {
 
106
            writer.println("START TRANSACTION;");
 
107
        }
 
108
 
 
109
        dropOldSchemas(writer, arguments, oldDatabase, newDatabase);
 
110
        createNewSchemas(writer, arguments, oldDatabase, newDatabase);
 
111
        updateSchemas(writer, arguments, oldDatabase, newDatabase);
 
112
 
 
113
        if (arguments.isAddTransaction()) {
 
114
            writer.println();
 
115
            writer.println("COMMIT TRANSACTION;");
 
116
        }
 
117
    }
 
118
 
 
119
    /**
 
120
     * Drops old schemas that do not exist anymore.
 
121
     *
 
122
     * @param writer writer the output should be written to
 
123
     * @param arguments object containing arguments settings
 
124
     * @param oldDatabase original database schema
 
125
     * @param newDatabase new database schema
 
126
     */
 
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()) {
 
133
            if (newDatabase.getSchema(oldSchema.getName()) == null) {
 
134
                writer.println();
 
135
                writer.println(
 
136
                    "DROP SCHEMA " + PgDiffUtils.getQuotedName(
 
137
                    oldSchema.getName(),
 
138
                    arguments.isQuoteNames()) + " CASCADE;");
 
139
            }
 
140
        }
 
141
    }
 
142
 
 
143
    /**
 
144
     * Updates objects in schemas.
 
145
     *
 
146
     * @param writer writer the output should be written to
 
147
     * @param arguments object containing arguments settings
 
148
     * @param oldDatabase original database schema
 
149
     * @param newDatabase new database schema
 
150
     */
 
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");
 
159
 
 
160
        for (PgSchema newSchema : newDatabase.getSchemas()) {
 
161
            if (setSearchPath) {
 
162
                writer.println();
 
163
                writer.println(
 
164
                    "SET search_path = " + PgDiffUtils.getQuotedName(
 
165
                    newSchema.getName(),
 
166
                    arguments.isQuoteNames()) + ", pg_catalog;");
 
167
            }
 
168
 
 
169
            final PgSchema oldSchema =
 
170
                oldDatabase.getSchema(newSchema.getName());
 
171
            PgDiffFunctions.diffFunctions(writer, arguments, oldSchema,
 
172
                newSchema);
 
173
            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);
 
199
            PgDiffViews.createViews(writer, arguments, oldSchema, newSchema);
 
200
        }
 
201
    }
 
202
}