Revision 44058 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.db/org.gvsig.fmap.dal.db.jdbc/src/main/java/org/gvsig/fmap/dal/store/jdbc2/spi/operations/OperationsFactoryBase.java

View differences:

OperationsFactoryBase.java
2 2

  
3 3
import java.util.Iterator;
4 4
import java.util.List;
5
import org.apache.commons.lang3.StringUtils;
5 6
import org.apache.commons.lang3.tuple.Pair;
6 7
import org.cresques.cts.IProjection;
7 8
import org.gvsig.fmap.dal.exception.DataException;
......
10 11
import org.gvsig.fmap.dal.feature.FeatureType;
11 12
import org.gvsig.fmap.dal.SQLBuilder;
12 13
import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;
14
import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;
15
import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
13 16
import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;
14 17
import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
15 18
import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;
......
17 20

  
18 21
public class OperationsFactoryBase implements OperationsFactory {
19 22

  
23
    protected class DefaultTableReference implements TableReference {
24

  
25
        private final String database;
26
        private final String schema;
27
        private final String table;
28
        private final String subquery;
29

  
30
        public DefaultTableReference(String database, String schema, String table, String subquery) {
31
            this.database = StringUtils.defaultIfBlank(database, null);
32
            this.schema = StringUtils.defaultIfBlank(schema, null);
33
            this.table = StringUtils.defaultIfBlank(table, null);
34
            this.subquery = StringUtils.defaultIfBlank(subquery, null);
35
        }
36
        
37
        @Override
38
        public String getDatabase() {
39
            return this.database;
40
        }
41

  
42
        @Override
43
        public String getSchema() {
44
            return this.schema;
45
        }
46

  
47
        @Override
48
        public String getTable() {
49
            return this.table;
50
        }
51

  
52
        @Override
53
        public String getSubquery() {
54
            return this.subquery;
55
        }
56

  
57
        @Override
58
        public boolean hasDatabase() {
59
            return this.database != null;
60
        }
61
        
62
        @Override
63
        public boolean hasSchema() {
64
            return this.schema != null;
65
        }
66
        
67
        @Override
68
        public boolean hasTable() {
69
            return this.table != null;
70
        }
71
        
72
        @Override
73
        public boolean hasSubquery() {
74
            return this.subquery != null;
75
        }
76
        
77
    }
78
    
20 79
    protected final JDBCHelper helper;
21 80

  
22 81
    public OperationsFactoryBase(JDBCHelper helper) {
......
24 83
    }
25 84

  
26 85
    @Override
86
    public TableReference createTableReference(JDBCStoreParameters params) {
87
        TableReference t = new DefaultTableReference(
88
                params.getDBName(),
89
                params.getSchema(),
90
                params.getTable(),
91
                params.getSQL()
92
        );
93
        return t;
94
    }
95

  
96
    @Override
97
    public TableReference createTableReference(JDBCNewStoreParameters params) {
98
        TableReference t = new DefaultTableReference(
99
                params.getDBName(),
100
                params.getSchema(),
101
                params.getTable(),
102
                null
103
        );
104
        return t;
105
    }
106

  
107
    @Override
108
    public TableReference createTableReference(String database, String schema, String table, String subquery) {
109
        TableReference t = new DefaultTableReference(database, schema, table, subquery);
110
        return t;
111
    }
112

  
113
    
114
    @Override
27 115
    public FetchFeatureTypeOperation createFetchFeatureType(
28 116
            EditableFeatureType type, 
29
            String database,
30
            String schema, 
31
            String table, 
117
            TableReference table, 
32 118
            List<String> primaryKeys, 
33 119
            String defaultGeometryField, 
34 120
            IProjection crs
35 121
        ) {
36
        return new FetchFeatureTypeOperation(helper, type, database, schema, table, 
122
        return new FetchFeatureTypeOperation(helper, type, table, 
37 123
                primaryKeys, defaultGeometryField, crs);
38 124
    }
39 125
    
40
//    @Override
41
//    public FetchFeatureTypeOperation createFetchFeatureType(
42
//            EditableFeatureType type, 
43
//            String defaultGeometryField, 
44
//            IProjection crs
45
//        ) {
46
//        return new FetchFeatureTypeOperation(helper, type, defaultGeometryField, crs);
47
//    }
48

  
49 126
    @Override
50 127
    public FetchFeatureProviderByReferenceOperation createFetchFeatureProviderByReference(
51 128
            FeatureReferenceProviderServices reference, 
52 129
            FeatureType featureType, 
53
            String database,
54
            String schema, 
55
            String table
130
            TableReference table
56 131
        ) {
57 132
        return new FetchFeatureProviderByReferenceOperation(helper, reference, 
58
                featureType, database, schema, table);
133
                featureType, table);
59 134
    }
60 135

  
61 136
    @Override
62 137
    public CalculateEnvelopeOfColumnOperation createCalculateEnvelopeOfColumn(
63
            String subquery, 
64
            String database,
65
            String schema, 
66
            String table, 
138
            TableReference table, 
67 139
            String columnName, 
68 140
            String baseFilter, 
69 141
            Envelope workingArea, 
70 142
            IProjection crs
71 143
        ) {
72
        return new CalculateEnvelopeOfColumnOperation(helper, subquery, database, schema, 
144
        return new CalculateEnvelopeOfColumnOperation(helper, 
73 145
                table, columnName, baseFilter, workingArea, crs);
74 146
    }
75 147

  
76 148
    @Override
77 149
    public PerformChangesOperation createPerformChanges(
78
            String database,
79
            String schema, 
80
            String table, 
150
            TableReference table, 
81 151
            FeatureType type, 
82 152
            Iterator deleteds, 
83 153
            Iterator inserteds, 
84 154
            Iterator updateds, 
85 155
            Iterator featureTypesChanged
86 156
        ) {
87
        return new PerformChangesOperation(helper, database,schema, table, type, 
157
        return new PerformChangesOperation(helper, table, type, 
88 158
                deleteds, inserteds, updateds, featureTypesChanged);
89 159
    }
90 160

  
91 161
    @Override
92 162
    public AppendOperation createAppend(
93
            String database,
94
            String schema, 
95
            String table, 
163
            TableReference table, 
96 164
            FeatureType type
97 165
        ) {
98
        return new AppendOperation(helper, database,schema, table, type);
166
        return new AppendOperation(helper, table, type);
99 167
    }
100 168

  
101 169
    @Override
102 170
    public CountOperation createCount(
103
            String database,
104
            String schema, 
105
            String table, 
106
            String sql, 
171
            TableReference table, 
107 172
            String baseFilter, 
108 173
            String filter
109 174
        ) {
110
        return new CountOperation(helper, database, schema, table, sql, 
111
                baseFilter, filter);
175
        return new CountOperation(helper, table, baseFilter, filter);
112 176
    }
113 177

  
114 178
    @Override
115 179
    public TableIsEmptyOperation createTableIsEmpty(
116
            String database,
117
            String schema, 
118
            String table,
119
            String sql, 
180
            TableReference table,
120 181
            String baseFilter, 
121 182
            String filter
122 183
        ) {
123
        return new TableIsEmptyOperation(helper, database, schema, table, sql, 
124
                baseFilter, filter);
184
        return new TableIsEmptyOperation(helper, table, baseFilter, filter);
125 185
    }
126 186

  
127 187
    @Override
128 188
    public ResultSetForSetProviderOperation createResultSetForSetProvider(
129
            String database,
130
            String schema, 
131
            String table, 
132
            String subquery, 
189
            TableReference table, 
133 190
            String baseFilter, 
134 191
            String baseOrder, 
135 192
            FeatureQuery query, 
......
139 196
            long offset, 
140 197
            int fetchSize
141 198
        ) {
142
        return new ResultSetForSetProviderOperation(helper, database, schema, table, 
143
                subquery, baseFilter, baseOrder, query, storeType, setType, 
199
        return new ResultSetForSetProviderOperation(helper, table, 
200
                baseFilter, baseOrder, query, storeType, setType, 
144 201
                limit, offset, fetchSize);
145 202
    }
146 203

  
......
156 213
    
157 214
    @Override
158 215
    public DropTableOperation createDropTable( 
159
            String dbName,
160
            String schemaName,
161
            String tableName            
216
            TableReference tableName            
162 217
        ) {
163
        return new DropTableOperation(helper, dbName, schemaName, tableName);
218
        return new DropTableOperation(helper, tableName);
164 219
    }
165 220
    
166 221
    @Override
167 222
    public CreateTableOperation createTable(
168
            String dbName,
169
            String schemaName, 
170
            String tableName, 
223
            TableReference table, 
171 224
            FeatureType type, 
172 225
            List<Pair<String, SQLBuilder.Privilege>> userAndPrivileges, 
173 226
            List<String> additionalSQLs
174 227
        ) throws DataException {
175 228
        return new CreateTableOperation(
176
                helper, dbName, schemaName, tableName, type, 
229
                helper, table, type, 
177 230
                userAndPrivileges, additionalSQLs
178 231
        );
179 232
    }
......
185 238

  
186 239
    @Override
187 240
    public UpdateTableStatisticsOperation createUpdateTableStatistics(
188
            String dbName,
189
            String schemaName, 
190
            String tableName
241
            TableReference table
191 242
        ) {
192
        return new UpdateTableStatisticsOperation(helper, dbName, schemaName, tableName);
243
        return new UpdateTableStatisticsOperation(helper, table);
193 244
    }
194 245
    
195 246
    @Override
196 247
    public CanModifyTableOperation createCanModifyTableOperation(
197
            String dbName,
198
            String schemaName, 
199
            String tableName
248
            TableReference table
200 249
        ) {
201
        return new CanModifyTableOperation(helper, dbName, schemaName, tableName);
250
        return new CanModifyTableOperation(helper, table);
202 251
    }
203 252
    
204 253
    @Override

Also available in: Unified diff