← 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/PgDiffIndexes.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/PgDiffIndexes.java
1
 
/*
2
 
 * $Id: PgDiffIndexes.java 94 2008-09-30 11:07:28Z fordfrog $
3
 
 */
4
1
package cz.startnet.utils.pgdiff;
5
2
 
6
3
import cz.startnet.utils.pgdiff.schema.PgIndex;
16
13
 * Diffs indexes.
17
14
 *
18
15
 * @author fordfrog
19
 
 * @version $Id: PgDiffIndexes.java 94 2008-09-30 11:07:28Z fordfrog $
20
16
 */
21
17
public class PgDiffIndexes {
22
18
 
28
24
    }
29
25
 
30
26
    /**
31
 
     * Outputs commands for differences in indexes.
32
 
     *
33
 
     * @param writer writer the output should be written to
34
 
     * @param arguments object containing arguments settings
35
 
     * @param oldSchema original schema
36
 
     * @param newSchema new schema
37
 
     */
38
 
    public static void diffIndexes(
39
 
            final PrintWriter writer,
40
 
            final PgDiffArguments arguments,
41
 
            final PgSchema oldSchema,
42
 
            final PgSchema newSchema) {
43
 
        for (PgTable newTable : newSchema.getTables()) {
 
27
     * Outputs commands for creation of new indexes.
 
28
     *
 
29
     * @param writer writer the output should be written to
 
30
     * @param arguments object containing arguments settings
 
31
     * @param oldSchema original schema
 
32
     * @param newSchema new schema
 
33
     */
 
34
    public static void createIndexes(final PrintWriter writer,
 
35
            final PgDiffArguments arguments, final PgSchema oldSchema,
 
36
            final PgSchema newSchema) {
 
37
        for (final PgTable newTable : newSchema.getTables()) {
 
38
            final String newTableName = newTable.getName();
 
39
            final PgTable oldTable;
 
40
 
 
41
            if (oldSchema == null) {
 
42
                oldTable = null;
 
43
            } else {
 
44
                oldTable = oldSchema.getTable(newTableName);
 
45
            }
 
46
 
 
47
            // Add new indexes
 
48
            if (oldSchema == null) {
 
49
                for (PgIndex index : newTable.getIndexes()) {
 
50
                    writer.println();
 
51
                    writer.println(
 
52
                            index.getCreationSQL(arguments.isQuoteNames()));
 
53
                }
 
54
            } else {
 
55
                for (PgIndex index : getNewIndexes(
 
56
                        oldSchema.getTable(newTableName), newTable)) {
 
57
                    writer.println();
 
58
                    writer.println(
 
59
                            index.getCreationSQL(arguments.isQuoteNames()));
 
60
                }
 
61
            }
 
62
        }
 
63
    }
 
64
 
 
65
    /**
 
66
     * Outputs commands for dropping indexes that exist no more.
 
67
     *
 
68
     * @param writer writer the output should be written to
 
69
     * @param arguments object containing arguments settings
 
70
     * @param oldSchema original schema
 
71
     * @param newSchema new schema
 
72
     */
 
73
    public static void dropIndexes(final PrintWriter writer,
 
74
            final PgDiffArguments arguments, final PgSchema oldSchema,
 
75
            final PgSchema newSchema) {
 
76
        for (final PgTable newTable : newSchema.getTables()) {
44
77
            final String newTableName = newTable.getName();
45
78
            final PgTable oldTable;
46
79
 
51
84
            }
52
85
 
53
86
            // Drop indexes that do not exist in new schema or are modified
54
 
            for (PgIndex index : getDropIndexes(oldTable, newTable)) {
 
87
            for (final PgIndex index : getDropIndexes(oldTable, newTable)) {
55
88
                writer.println();
56
89
                writer.println(index.getDropSQL(arguments.isQuoteNames()));
57
90
            }
58
 
 
59
 
            // Add new indexes
60
 
            if (oldSchema == null) {
61
 
                for (PgIndex index : newTable.getIndexes()) {
62
 
                    writer.println();
63
 
                    writer.println(
64
 
                            index.getCreationSQL(arguments.isQuoteNames()));
65
 
                }
66
 
            } else {
67
 
                for (PgIndex index : getNewIndexes(
68
 
                        oldSchema.getTable(newTableName),
69
 
                        newTable)) {
70
 
                    writer.println();
71
 
                    writer.println(
72
 
                            index.getCreationSQL(arguments.isQuoteNames()));
73
 
                }
74
 
            }
75
91
        }
76
92
    }
77
93
 
86
102
     * @todo Indexes that are depending on a removed field should not be added
87
103
     *       to drop because they are already removed.
88
104
     */
89
 
    private static List<PgIndex> getDropIndexes(
90
 
            final PgTable oldTable,
 
105
    private static List<PgIndex> getDropIndexes(final PgTable oldTable,
91
106
            final PgTable newTable) {
92
107
        final List<PgIndex> list = new ArrayList<PgIndex>();
93
108
 
94
109
        if ((newTable != null) && (oldTable != null)) {
95
110
            for (final PgIndex index : oldTable.getIndexes()) {
96
 
                if (!newTable.containsIndex(index.getName()) || !newTable.
97
 
                        getIndex(index.getName()).equals(index)) {
 
111
                if (!newTable.containsIndex(index.getName())
 
112
                        || !newTable.getIndex(index.getName()).equals(index)) {
98
113
                    list.add(index);
99
114
                }
100
115
            }
111
126
     *
112
127
     * @return list of indexes that should be added
113
128
     */
114
 
    private static List<PgIndex> getNewIndexes(
115
 
            final PgTable oldTable,
 
129
    private static List<PgIndex> getNewIndexes(final PgTable oldTable,
116
130
            final PgTable newTable) {
117
131
        final List<PgIndex> list = new ArrayList<PgIndex>();
118
132
 
123
137
                }
124
138
            } else {
125
139
                for (final PgIndex index : newTable.getIndexes()) {
126
 
                    if (!oldTable.containsIndex(index.getName()) || !oldTable.
127
 
                            getIndex(index.getName()).equals(
128
 
                            index)) {
 
140
                    if (!oldTable.containsIndex(index.getName())
 
141
                            || !oldTable.getIndex(index.getName()).
 
142
                            equals(index)) {
129
143
                        list.add(index);
130
144
                    }
131
145
                }