001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/datastore/sde/AbstractSDERequestHandler.java $
002 /*---------------- FILE HEADER ------------------------------------------
003
004 This file is part of deegree.
005 Copyright (C) 2006 by: M.O.S.S. Computer Grafik Systeme GmbH
006 Hohenbrunner Weg 13
007 D-82024 Taufkirchen
008 http://www.moss.de/
009
010 This library is free software; you can redistribute it and/or
011 modify it under the terms of the GNU Lesser General Public
012 License as published by the Free Software Foundation; either
013 version 2.1 of the License, or (at your option) any later version.
014
015 This library is distributed in the hope that it will be useful,
016 but WITHOUT ANY WARRANTY; without even the implied warranty of
017 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
018 Lesser General Public License for more details.
019
020 You should have received a copy of the GNU Lesser General Public
021 License along with this library; if not, write to the Free Software
022 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
023
024 ---------------------------------------------------------------------------*/
025 package org.deegree.io.datastore.sde;
026
027 import java.util.ArrayList;
028 import java.util.HashMap;
029 import java.util.Iterator;
030 import java.util.List;
031 import java.util.Map;
032
033 import org.deegree.framework.log.ILogger;
034 import org.deegree.framework.log.LoggerFactory;
035 import org.deegree.io.datastore.DatastoreException;
036 import org.deegree.io.datastore.FeatureId;
037 import org.deegree.io.datastore.schema.MappedFeatureType;
038 import org.deegree.io.datastore.schema.MappedGMLId;
039 import org.deegree.io.datastore.schema.MappedGeometryPropertyType;
040 import org.deegree.io.datastore.schema.MappedPropertyType;
041 import org.deegree.io.datastore.schema.MappedSimplePropertyType;
042 import org.deegree.io.datastore.schema.TableRelation;
043 import org.deegree.io.datastore.schema.content.MappingField;
044 import org.deegree.io.datastore.schema.content.SimpleContent;
045 import org.deegree.io.datastore.sql.TableAliasGenerator;
046 import org.deegree.io.sdeapi.SDEConnection;
047 import org.deegree.model.feature.schema.PropertyType;
048 import org.deegree.model.filterencoding.ComplexFilter;
049 import org.deegree.model.filterencoding.Filter;
050
051 import com.esri.sde.sdk.client.SeFilter;
052 import com.esri.sde.sdk.client.SeLayer;
053 import com.esri.sde.sdk.client.SeQuery;
054 import com.esri.sde.sdk.client.SeRow;
055 import com.esri.sde.sdk.client.SeSqlConstruct;
056
057 /**
058 * Handles <code>Transaction</code> requests to SQL based datastores.
059 *
060 * @author <a href="mailto:cpollmann@moss.de">Christoph Pollmann</a>
061 * @author last edited by: $Author: rbezema $
062 *
063 * @version $Revision: 12183 $, $Date: 2008-06-05 11:17:23 +0200 (Do, 05 Jun 2008) $
064 */
065 public class AbstractSDERequestHandler {
066
067 private static final ILogger LOG = LoggerFactory.getLogger( AbstractSDERequestHandler.class );
068
069 /**
070 * feature type column
071 */
072 protected static final String FT_COLUMN = "featuretype";
073
074 /**
075 * The prefix of feature types 'ft_'
076 */
077 protected static final String FT_PREFIX = "ft_";
078
079 /**
080 * datastore to operate upon
081 */
082 protected SDEDatastore datastore;
083
084 /**
085 * reference to the alias generator
086 */
087 protected TableAliasGenerator aliasGenerator;
088
089 /**
090 * a connection
091 */
092 protected SDEConnection conn;
093
094 /**
095 * Creates a new instance of <code>AbstractSDERequestHandler</code> from the given parameters.
096 *
097 * @param datastore
098 * @param aliasGenerator
099 * @param conn
100 */
101 public AbstractSDERequestHandler( SDEDatastore datastore, TableAliasGenerator aliasGenerator, SDEConnection conn ) {
102 this.datastore = datastore;
103 this.aliasGenerator = aliasGenerator;
104 this.conn = conn;
105 }
106
107 /**
108 * Returns the underlying <code>AbstractSQLDatastore</code>.
109 *
110 * @return the underlying <code>AbstractSQLDatastore</code>.
111 */
112 public SDEDatastore getDatastore() {
113 return this.datastore;
114 }
115
116 /**
117 * Returns the underlying <code>AbstractSQLDatastore</code>.
118 *
119 * @return the underlying <code>AbstractSQLDatastore</code>.
120 */
121 public SDEConnection getConnection() {
122 return this.conn;
123 }
124
125 /**
126 * Returns the underlying <code>AbstractSQLDatastore</code>.
127 *
128 * @return the underlying <code>AbstractSQLDatastore</code>.
129 */
130 public TableAliasGenerator getAliasGenerator() {
131 return this.aliasGenerator;
132 }
133
134 /**
135 * Determines the feature ids that are matched by the given filter.
136 *
137 * @param ft
138 * @param filter
139 * @return the feature ids that are matched by the given filter.
140 * @throws DatastoreException
141 */
142 public FeatureId[] determineAffectedFIDs( MappedFeatureType ft, Filter filter )
143 throws DatastoreException {
144
145 SDEWhereBuilder whereBuilder = this.datastore.getWhereBuilder( new MappedFeatureType[] { ft }, null, filter,
146 new TableAliasGenerator() );
147
148 // if no filter is given
149 FeatureId[] fids = null;
150 SeQuery stmt = null;
151 try {
152 stmt = buildInitialFIDSelect( ft, whereBuilder );
153 stmt.execute();
154 fids = extractFeatureIds( stmt, ft );
155 } catch ( Exception e ) {
156 throw new DatastoreException( "Error performing the delete transaction operation on mapped feature type '"
157 + ft.getName() + "'." );
158 } finally {
159 try {
160 if ( stmt != null ) {
161 stmt.close();
162 }
163 } catch ( Exception e ) {
164 // eat'em keeps you healthy
165 }
166 }
167 return fids;
168 }
169
170 /**
171 * Builds the initial SELECT statement that retrieves the feature ids that are matched by the
172 * given <code>WhereBuilder</code>.
173 * <p>
174 * The statement is structured like this:
175 * <ul>
176 * <li><code>SELECT</code></li>
177 * <li>comma-separated list of qualified fid fields</li>
178 * <li><code>FROM</code></li>
179 * <li>comma-separated list of tables and their aliases (this is needed to constrain the paths
180 * to selected XPath-PropertyNames)</li>
181 * <li><code>WHERE</code></li>
182 * <li>SQL representation of the Filter expression</li>
183 * </ul>
184 *
185 * @param rootFeatureType
186 * @param whereBuilder
187 * @return the query
188 */
189 protected SeQuery buildInitialFIDSelect( MappedFeatureType rootFeatureType, SDEWhereBuilder whereBuilder ) {
190 SeQuery query = null;
191 try {
192 StringBuffer whereCondition = new StringBuffer();
193 whereBuilder.appendWhereCondition( whereCondition );
194 SeSqlConstruct constr = new SeSqlConstruct( rootFeatureType.getTable(), whereCondition.toString() );
195 String[] fidColumns = getFeatureIdColumns( rootFeatureType );
196 query = new SeQuery( getConnection().getConnection(), fidColumns, constr );
197 if ( whereBuilder.getFilter() instanceof ComplexFilter ) {
198 // There is NO chance, to make a new SeCoordinateReference equal to the existing crs
199 // of the requested layer.
200 // So, we give it a chance, by passing the layer definitions (and its associated
201 // crs) to the whereBuilder method
202 List<SeLayer> layers = getConnection().getConnection().getLayers();
203 SeFilter[] spatialFilter = whereBuilder.buildSpatialFilter( (ComplexFilter) whereBuilder.getFilter(),
204 layers );
205 if ( null != spatialFilter && 0 < spatialFilter.length ) {
206 query.setSpatialConstraints( SeQuery.SE_OPTIMIZE, false, spatialFilter );
207 }
208 }
209 query.prepareQuery();
210 } catch ( Exception e ) {
211 e.printStackTrace();
212 }
213 return query;
214 }
215
216 /**
217 * Appends the alias qualified columns that make up the feature id to the given query.
218 *
219 * @param featureType
220 * @return the feature id columns
221 */
222 protected String[] getFeatureIdColumns( MappedFeatureType featureType ) {
223 MappingField[] fidFields = featureType.getGMLId().getIdFields();
224 String[] columns = new String[fidFields.length];
225 for ( int i = 0; i < fidFields.length; i++ ) {
226 columns[i] = fidFields[i].getField();
227 }
228 return columns;
229 }
230
231 /**
232 * @param stmt
233 * @param ft
234 * @return the ids
235 * @throws Exception
236 */
237 public FeatureId[] extractFeatureIds( SeQuery stmt, MappedFeatureType ft )
238 throws Exception {
239 List<FeatureId> featureIdList = new ArrayList<FeatureId>();
240 MappedGMLId gmlId = ft.getGMLId();
241 MappingField[] idFields = gmlId.getIdFields();
242 SeRow row = null;
243 for ( ;; ) {
244 try {
245 row = stmt.fetch();
246 } catch ( Exception e ) {
247 row = null;
248 }
249 if ( null == row )
250 break;
251 Object[] idValues = new Object[idFields.length];
252 for ( int i = 0; i < idValues.length; i++ ) {
253 idValues[i] = row.getObject( i );
254 }
255 featureIdList.add( new FeatureId( ft, idValues ) );
256 }
257 return featureIdList.toArray( new FeatureId[featureIdList.size()] );
258 }
259
260 /**
261 * Builds a helper map that contains the column names of the feature type's table as keys. Each
262 * column name is mapped to a <code>List</code> containing the <code>MappingField</code>
263 * instances that refer to this column.
264 * <p>
265 * The following MappingField instances of the feature type's annotation are used to build the
266 * map:
267 * <ul>
268 * <li>MappingFields from the wfs:gmlId - annotation element of the feature type definition</li>
269 * <li>MappingFields in the annotations of the property element definitions; if the property's
270 * content is stored in a related table, the MappingFields used in the first wfs:Relation
271 * element's wfs:From element are considered</li>
272 * </ul>
273 *
274 * @param featureType
275 * feature type for which the map is built
276 * @param requestedProperties
277 * requested properties
278 * @param withIdFields
279 * @return key class: String (column names), value class: List (containing MappingField
280 * instances)
281 */
282 protected Map<String, List<MappingField>> buildColumnsMap( MappedFeatureType featureType,
283 PropertyType[] requestedProperties, boolean withIdFields ) {
284 Map<String, List<MappingField>> columnsMap = new HashMap<String, List<MappingField>>();
285
286 // add table columns that are necessary to build the feature's gml id
287 if ( withIdFields ) {
288 MappingField[] idFields = featureType.getGMLId().getIdFields();
289 for ( int i = 0; i < idFields.length; i++ ) {
290 List<MappingField> mappingFieldList = columnsMap.get( idFields[i].getField() );
291 if ( mappingFieldList == null ) {
292 mappingFieldList = new ArrayList<MappingField>();
293 }
294 mappingFieldList.add( idFields[i] );
295 columnsMap.put( idFields[i].getField(), mappingFieldList );
296 }
297 }
298
299 // add columns that are necessary to build the requested feature properties
300 for ( int i = 0; i < requestedProperties.length; i++ ) {
301 MappedPropertyType pt = (MappedPropertyType) requestedProperties[i];
302
303 TableRelation[] tableRelations = pt.getTableRelations();
304 if ( tableRelations != null && tableRelations.length != 0 ) {
305 // if property is not stored in feature type's table, retrieve key fields of
306 // the first relation's 'From' element
307 MappingField[] fields = tableRelations[0].getFromFields();
308 for ( int j = 0; j < fields.length; j++ ) {
309 List<MappingField> list = columnsMap.get( fields[j].getField() );
310 if ( list == null ) {
311 list = new ArrayList<MappingField>();
312 }
313 list.add( fields[j] );
314 columnsMap.put( fields[j].getField(), list );
315 }
316 // if (content instanceof FeaturePropertyContent) {
317 // if (tableRelations.length == 1) {
318 // // if feature property contains an abstract feature type, retrieve
319 // // feature type as well (stored in column named "FT_fk")
320 // MappedFeatureType subFeatureType = ( (FeaturePropertyContent) content )
321 // .getFeatureTypeReference().getFeatureType();
322 // if (subFeatureType.isAbstract()) {
323 // String typeColumn = FT_PREFIX + fields [0].getField();
324 // columnsMap.put (typeColumn, new ArrayList ());
325 // }
326 // }
327 // }
328 } else {
329 MappingField field = null;
330 if ( pt instanceof MappedSimplePropertyType ) {
331 SimpleContent content = ( (MappedSimplePropertyType) pt ).getContent();
332 if ( content instanceof MappingField ) {
333 field = (MappingField) content;
334 } else {
335 // ignore virtual properties here
336 continue;
337 }
338 } else if ( pt instanceof MappedGeometryPropertyType ) {
339 field = ( (MappedGeometryPropertyType) pt ).getMappingField();
340 } else {
341 String msg = "Unsupported property type: '" + pt.getClass().getName()
342 + "' in QueryHandler.buildColumnsMap(). ";
343 LOG.logError( msg );
344 throw new IllegalArgumentException( msg );
345 }
346 List<MappingField> list = columnsMap.get( field.getField() );
347 if ( list == null ) {
348 list = new ArrayList<MappingField>();
349 }
350 list.add( field );
351 columnsMap.put( field.getField(), list );
352 }
353 }
354 return columnsMap;
355 }
356
357 /**
358 * Builds a lookup map that contains <code>MappingField</code> instances as keys. Each
359 * <code>MappingField</code> is mapped to the index position (an <code>Integer</code>) of
360 * the MappingField's field name in the given column array.
361 *
362 * @param columns
363 * @param columnsMap
364 * @return key class: MappingField, value class: Integer (index of field name in columns)
365 */
366 protected Map<MappingField, Integer> buildMappingFieldMap( String[] columns,
367 Map<String, List<MappingField>> columnsMap ) {
368 Map<MappingField, Integer> mappingFieldMap = new HashMap<MappingField, Integer>();
369 for ( int i = 0; i < columns.length; i++ ) {
370 Integer resultPos = new Integer( i );
371 List<MappingField> mappingFieldList = columnsMap.get( columns[i] );
372 Iterator<MappingField> iter = mappingFieldList.iterator();
373 while ( iter.hasNext() ) {
374 mappingFieldMap.put( iter.next(), resultPos );
375 }
376 }
377 return mappingFieldMap;
378 }
379 }