001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/datastore/sql/transaction/UpdateHandler.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036 package org.deegree.io.datastore.sql.transaction;
037
038 import java.sql.Connection;
039 import java.sql.PreparedStatement;
040 import java.sql.ResultSet;
041 import java.sql.SQLException;
042 import java.util.ArrayList;
043 import java.util.Enumeration;
044 import java.util.Hashtable;
045 import java.util.LinkedHashMap;
046 import java.util.List;
047 import java.util.Map;
048
049 import org.deegree.datatypes.QualifiedName;
050 import org.deegree.datatypes.Types;
051 import org.deegree.framework.log.ILogger;
052 import org.deegree.framework.log.LoggerFactory;
053 import org.deegree.i18n.Messages;
054 import org.deegree.io.datastore.DatastoreException;
055 import org.deegree.io.datastore.FeatureId;
056 import org.deegree.io.datastore.TransactionException;
057 import org.deegree.io.datastore.idgenerator.FeatureIdAssigner;
058 import org.deegree.io.datastore.schema.MappedFeaturePropertyType;
059 import org.deegree.io.datastore.schema.MappedFeatureType;
060 import org.deegree.io.datastore.schema.MappedGeometryPropertyType;
061 import org.deegree.io.datastore.schema.MappedPropertyType;
062 import org.deegree.io.datastore.schema.MappedSimplePropertyType;
063 import org.deegree.io.datastore.schema.TableRelation;
064 import org.deegree.io.datastore.schema.TableRelation.FK_INFO;
065 import org.deegree.io.datastore.schema.content.MappingField;
066 import org.deegree.io.datastore.schema.content.MappingGeometryField;
067 import org.deegree.io.datastore.schema.content.SimpleContent;
068 import org.deegree.io.datastore.sql.AbstractRequestHandler;
069 import org.deegree.io.datastore.sql.StatementBuffer;
070 import org.deegree.io.datastore.sql.TableAliasGenerator;
071 import org.deegree.io.datastore.sql.transaction.delete.DeleteHandler;
072 import org.deegree.io.datastore.sql.transaction.insert.InsertHandler;
073 import org.deegree.model.feature.Feature;
074 import org.deegree.model.feature.FeatureProperty;
075 import org.deegree.model.feature.schema.FeaturePropertyType;
076 import org.deegree.model.feature.schema.PropertyType;
077 import org.deegree.model.filterencoding.Filter;
078 import org.deegree.model.spatialschema.Geometry;
079 import org.deegree.ogcbase.ElementStep;
080 import org.deegree.ogcbase.PropertyPath;
081 import org.deegree.ogcbase.PropertyPathStep;
082 import org.deegree.ogcwebservices.wfs.operation.transaction.Insert;
083 import org.deegree.ogcwebservices.wfs.operation.transaction.Transaction;
084 import org.deegree.ogcwebservices.wfs.operation.transaction.Update;
085
086 /**
087 * Handler for {@link Update} operations (usually contained in {@link Transaction} requests).
088 *
089 * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider</a>
090 * @author last edited by: $Author: rbezema $
091 *
092 * @version $Revision: 19436 $, $Date: 2009-08-31 16:37:44 +0200 (Mo, 31 Aug 2009) $
093 */
094 public class UpdateHandler extends AbstractRequestHandler {
095
096 private static final ILogger LOG = LoggerFactory.getLogger( UpdateHandler.class );
097
098 private SQLTransaction dsTa;
099
100 private String lockId;
101
102 /**
103 * Creates a new <code>UpdateHandler</code> from the given parameters.
104 *
105 * @param dsTa
106 * @param aliasGenerator
107 * @param conn
108 * @param lockId
109 * optional id of associated lock (may be null)
110 */
111 public UpdateHandler( SQLTransaction dsTa, TableAliasGenerator aliasGenerator, Connection conn, String lockId ) {
112 super( dsTa.getDatastore(), aliasGenerator, conn );
113 this.dsTa = dsTa;
114 this.lockId = lockId;
115 }
116
117 /**
118 * Performs an update operation against the associated datastore.
119 *
120 * @param ft
121 * @param replacementProps
122 * @param filter
123 * @return number of updated (root) feature instances
124 * @throws DatastoreException
125 */
126 public int performUpdate( MappedFeatureType ft, Map<PropertyPath, FeatureProperty> replacementProps, Filter filter )
127 throws DatastoreException {
128
129 List<FeatureId> fids = determineAffectedAndModifiableFIDs( ft, filter, this.lockId );
130
131 LOG.logDebug( "Updating: " + ft );
132 for ( FeatureId fid : fids ) {
133 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> tableToFeatureUpdate = new Hashtable<String, Hashtable<FeatureId, StatementBuffer>>();
134
135 for ( PropertyPath property : replacementProps.keySet() ) {
136 LOG.logDebug( "Updating feature: " + fid );
137 FeatureProperty propertyValue = replacementProps.get( property );
138 performUpdate( fid, ft, property, propertyValue, tableToFeatureUpdate );
139 }
140
141 for ( Hashtable<FeatureId, StatementBuffer> featureStatementBuffers : tableToFeatureUpdate.values() ) {
142 for ( Enumeration<FeatureId> it = featureStatementBuffers.keys(); it.hasMoreElements(); ) {
143 FeatureId statementFid = it.nextElement();
144 StatementBuffer query = featureStatementBuffers.get( statementFid );
145
146 query.append( " WHERE " );
147 appendFIDWhereCondition( query, statementFid );
148
149 PreparedStatement stmt = null;
150 LOG.logDebug( "Performing aggregate update of in-table properties: " + query.getQueryString() );
151 try {
152 stmt = this.datastore.prepareStatement( conn, query );
153 stmt.execute();
154 } catch ( SQLException e ) {
155 throw new DatastoreException( "Error in performUpdate(): " + e.getMessage() );
156 } finally {
157 if ( stmt != null ) {
158 try {
159 stmt.close();
160 } catch ( SQLException e ) {
161 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
162 }
163 }
164 }
165 }
166 }
167 }
168 return fids.size();
169 }
170
171 /**
172 * Performs an update operation (replace-style) against the associated datastore.
173 * <p>
174 * All features matched by the given filter are altered, so their properties are identical to those of the specified
175 * replacement feature.
176 * </p>
177 * <p>
178 * NOTE: Currently, the contained feature must not contain any feature-valued properties or multi-properties.
179 * </p>
180 *
181 * @param mappedFeatureType
182 * @param replacementFeature
183 * @param filter
184 * @return number of updated (root) feature instances
185 * @throws DatastoreException
186 */
187 public int performUpdate( MappedFeatureType mappedFeatureType, Feature replacementFeature, Filter filter )
188 throws DatastoreException {
189 LOG.logDebug( "Updating (replace): " + mappedFeatureType );
190 if ( filter != null ) {
191 LOG.logDebug( " filter: " + filter.to110XML() );
192 }
193
194 PropertyType[] replPropertyTypes = replacementFeature.getFeatureType().getProperties();
195 int result = 0;
196 // rb: updating complex features is a needed feature, gml:id reservation as well, therefore let's see if we are
197 // updating a complex feature, we do the old school, delete->insert (loosing gml:id) if updating a simple
198 // feature, do a 'new school' update.
199 if ( replPropertyTypes != null ) {
200 boolean oldSchool = false;
201 for ( int i = 0; i < replPropertyTypes.length && !oldSchool; ++i ) {
202 PropertyType rpt = replPropertyTypes[i];
203 oldSchool = rpt != null
204 && ( rpt instanceof FeaturePropertyType || rpt instanceof MappedFeaturePropertyType );
205
206 }
207 if ( oldSchool ) {
208 LOG.logWarning( "The given featuretype, is a complex feature type, updating this feature will result in the loss of gml:id's in the update feature and it's references." );
209 result = performUpdateWithFeatures( mappedFeatureType, replacementFeature, filter );
210 } else {
211 LOG.logDebug( "Updating feature with correct gml:id handling (replace): " + mappedFeatureType );
212 result = performUpdateCorrectForProperties( mappedFeatureType, replacementFeature, filter );
213 }
214 }
215 return result;
216 }
217
218 /**
219 * Performs an update operation (replace-style) against the associated datastore.
220 * <p>
221 * All features matched by the given filter are altered, so their properties are identical to those of the specified
222 * replacement feature.
223 * </p>
224 * <p>
225 * NOTE: Currently, the contained feature must not contain any feature-valued properties or multi-properties.
226 * </p>
227 *
228 * @param mappedFeatureType
229 * @param replacementFeature
230 * @param filter
231 * @return number of updated (root) feature instances
232 * @throws DatastoreException
233 */
234 private int performUpdateCorrectForProperties( MappedFeatureType mappedFeatureType, Feature replacementFeature,
235 Filter filter )
236 throws DatastoreException {
237
238 Map<PropertyPath, FeatureProperty> replaceProperties = new LinkedHashMap<PropertyPath, FeatureProperty>();
239 FeatureProperty[] featureProps = replacementFeature.getProperties();
240 for ( FeatureProperty featureProperty : featureProps ) {
241 List<PropertyPathStep> steps = new ArrayList<PropertyPathStep>( 1 );
242 steps.add( new ElementStep( featureProperty.getName() ) );
243 PropertyPath path = new PropertyPath( steps );
244 replaceProperties.put( path, featureProperty );
245 }
246 return performUpdate( mappedFeatureType, replaceProperties, filter );
247 }
248
249 /**
250 * Performs an update operation against the associated datastore.
251 * <p>
252 * The filter must match exactly one feature instance (or none) which is then replaced by the specified replacement
253 * feature.
254 *
255 * @param mappedFeatureType
256 * @param replacementFeature
257 * @param filter
258 * @return number of updated (root) feature instances (0 or 1)
259 * @throws DatastoreException
260 */
261 private int performUpdateWithFeatures( MappedFeatureType mappedFeatureType, Feature replacementFeature,
262 Filter filter )
263 throws DatastoreException {
264
265 List<FeatureId> fids = determineAffectedAndModifiableFIDs( mappedFeatureType, filter, this.lockId );
266
267 if ( fids.size() > 1 ) {
268 String msg = Messages.getMessage( "DATASTORE_MORE_THAN_ONE_FEATURE" );
269 throw new DatastoreException( msg );
270 }
271 DeleteHandler deleteHandler = new DeleteHandler( this.dsTa, this.aliasGenerator, this.conn, this.lockId );
272 deleteHandler.performDelete( mappedFeatureType, filter );
273
274 // identify stored subfeatures / assign feature ids
275 FeatureIdAssigner fidAssigner = new FeatureIdAssigner( Insert.ID_GEN.GENERATE_NEW );
276 fidAssigner.assignFID( replacementFeature, this.dsTa );
277 // TODO remove this hack
278 fidAssigner.markStoredFeatures();
279
280 InsertHandler insertHandler = new InsertHandler( this.dsTa, this.aliasGenerator, this.conn );
281 List<Feature> features = new ArrayList<Feature>();
282 features.add( replacementFeature );
283 insertHandler.performInsert( features );
284
285 return fids.size();
286 }
287
288 /**
289 * Performs the update (replacing of a property) of the given feature instance.
290 * <p>
291 * If the selected property is a direct property of the feature, the root feature is updated, otherwise the targeted
292 * subfeatures have to be determined first.
293 *
294 * @param fid
295 * @param ft
296 * @param propertyName
297 * @param replacementProperty
298 * @param statementBuffers
299 * @throws DatastoreException
300 */
301 private void performUpdate( FeatureId fid, MappedFeatureType ft, PropertyPath propertyName,
302 FeatureProperty replacementProperty,
303 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers )
304 throws DatastoreException {
305
306 Object replacementValue = replacementProperty.getValue();
307 LOG.logDebug( "Updating fid: " + fid + ", propertyName: " + propertyName + " -> " + replacementValue );
308
309 int steps = propertyName.getSteps();
310 QualifiedName propName = propertyName.getStep( steps - 1 ).getPropertyName();
311 if ( steps > 2 ) {
312 QualifiedName subFtName = propertyName.getStep( steps - 2 ).getPropertyName();
313 MappedFeatureType subFt = this.datastore.getFeatureType( subFtName );
314 MappedPropertyType pt = (MappedPropertyType) subFt.getProperty( propName );
315 List<TableRelation> tablePath = getTablePath( ft, propertyName );
316 List<FeatureId> subFids = determineAffectedFIDs( fid, subFt, tablePath );
317 for ( FeatureId subFid : subFids ) {
318 updateProperty( subFid, subFt, pt, replacementValue, statementBuffers );
319 }
320 } else {
321 MappedPropertyType pt = (MappedPropertyType) ft.getProperty( propName );
322 updateProperty( fid, ft, pt, replacementValue, statementBuffers );
323 }
324 }
325
326 /**
327 * Determines the subfeature instances that are targeted by the given PropertyName.
328 *
329 * @param fid
330 * @param subFt
331 * @param path
332 * @return the matched feature ids
333 * @throws DatastoreException
334 */
335 private List<FeatureId> determineAffectedFIDs( FeatureId fid, MappedFeatureType subFt, List<TableRelation> path )
336 throws DatastoreException {
337
338 List<FeatureId> subFids = new ArrayList<FeatureId>();
339
340 this.aliasGenerator.reset();
341 String[] tableAliases = this.aliasGenerator.generateUniqueAliases( path.size() + 1 );
342 String toTableAlias = tableAliases[tableAliases.length - 1];
343 StatementBuffer query = new StatementBuffer();
344 query.append( "SELECT " );
345 appendFeatureIdColumns( subFt, toTableAlias, query );
346 query.append( " FROM " );
347 query.append( path.get( 0 ).getFromTable() );
348 query.append( " " );
349 query.append( tableAliases[0] );
350 // append joins
351 for ( int i = 0; i < path.size(); i++ ) {
352 query.append( " JOIN " );
353 query.append( path.get( i ).getToTable() );
354 query.append( " " );
355 query.append( tableAliases[i + 1] );
356 query.append( " ON " );
357 MappingField[] fromFields = path.get( i ).getFromFields();
358 MappingField[] toFields = path.get( i ).getToFields();
359 for ( int j = 0; j < fromFields.length; j++ ) {
360 query.append( tableAliases[i] );
361 query.append( '.' );
362 query.append( fromFields[j].getField() );
363 query.append( '=' );
364 query.append( tableAliases[i + 1] );
365 query.append( '.' );
366 query.append( toFields[j].getField() );
367 }
368 }
369 query.append( " WHERE " );
370 MappingField[] fidFields = fid.getFidDefinition().getIdFields();
371 for ( int i = 0; i < fidFields.length; i++ ) {
372 query.append( tableAliases[0] );
373 query.append( '.' );
374 query.append( fidFields[i].getField() );
375 query.append( "=?" );
376 query.addArgument( fid.getValue( i ), fidFields[i].getType() );
377 if ( i != fidFields.length - 1 ) {
378 query.append( " AND " );
379 }
380 }
381
382 PreparedStatement stmt = null;
383 ResultSet rs = null;
384 try {
385 stmt = this.datastore.prepareStatement( conn, query );
386 rs = stmt.executeQuery();
387 subFids = extractFeatureIds( rs, subFt );
388 } catch ( SQLException e ) {
389 throw new DatastoreException( "Error in determineAffectedFIDs(): " + e.getMessage() );
390 } finally {
391 try {
392 if ( rs != null ) {
393 try {
394 rs.close();
395 } catch ( SQLException e ) {
396 LOG.logError( "Error closing result set: '" + e.getMessage() + "'.", e );
397 }
398 }
399 } finally {
400 if ( stmt != null ) {
401 try {
402 stmt.close();
403 } catch ( SQLException e ) {
404 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
405 }
406 }
407 }
408 }
409 return subFids;
410 }
411
412 /**
413 * Returns the relations (the "path") that lead from the feature type's table to the subfeature table which is
414 * targeted by the specified property name.
415 *
416 * @param ft
417 * source feature type
418 * @param path
419 * property name
420 * @return relations that lead from the feature type's table to the subfeature table
421 */
422 private List<TableRelation> getTablePath( MappedFeatureType ft, PropertyPath path ) {
423 List<TableRelation> relations = new ArrayList<TableRelation>();
424 for ( int i = 1; i < path.getSteps() - 2; i += 2 ) {
425 QualifiedName propName = path.getStep( i ).getPropertyName();
426 MappedFeaturePropertyType pt = (MappedFeaturePropertyType) ft.getProperty( propName );
427 TableRelation[] tableRelations = pt.getTableRelations();
428 for ( int j = 0; j < tableRelations.length; j++ ) {
429 relations.add( tableRelations[j] );
430 }
431 ft = pt.getFeatureTypeReference().getFeatureType();
432 }
433 return relations;
434 }
435
436 /**
437 * Replaces the specified feature's property with the given value.
438 *
439 * @param fid
440 * @param ft
441 * @param pt
442 * @param replacementValue
443 * @throws DatastoreException
444 */
445 private void updateProperty( FeatureId fid, MappedFeatureType ft, MappedPropertyType pt, Object replacementValue,
446 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers )
447 throws DatastoreException {
448
449 LOG.logDebug( "Updating property '" + pt.getName() + "' of feature '" + fid + "'." );
450 if ( !ft.isUpdatable() ) {
451 String msg = Messages.getMessage( "DATASTORE_FT_NOT_UPDATABLE", ft.getName() );
452 throw new DatastoreException( msg );
453 }
454 TableRelation[] tablePath = pt.getTableRelations();
455 if ( pt instanceof MappedSimplePropertyType ) {
456 SimpleContent content = ( (MappedSimplePropertyType) pt ).getContent();
457 if ( content.isUpdateable() ) {
458 if ( content instanceof MappingField ) {
459 updateSimpleProperty( fid, tablePath, (MappingField) content, replacementValue, statementBuffers );
460 }
461 } else {
462 LOG.logInfo( "Ignoring property '" + pt.getName() + "' in update - content is virtual." );
463 }
464 } else if ( pt instanceof MappedGeometryPropertyType ) {
465 MappedGeometryPropertyType geomPt = (MappedGeometryPropertyType) pt;
466 MappingGeometryField dbField = geomPt.getMappingField();
467 Geometry deegreeGeometry = (Geometry) replacementValue;
468 Object dbGeometry;
469
470 int createSrsCode = dbField.getSRS();
471 int targetSrsCode = -1;
472
473 if ( deegreeGeometry.getCoordinateSystem() == null ) {
474 LOG.logDebug( "No SRS information for geometry available. Assuming '" + geomPt.getSRS() + "'." );
475 } else if ( !geomPt.getSRS().toString().equals( deegreeGeometry.getCoordinateSystem().getIdentifier() ) ) {
476 String msg = "Insert-Transformation: geometry srs: "
477 + deegreeGeometry.getCoordinateSystem().getIdentifier() + " -> property srs: "
478 + geomPt.getSRS();
479 LOG.logDebug( msg );
480 if ( createSrsCode == -1 ) {
481 msg = Messages.getMessage( "DATASTORE_SRS_NOT_SPECIFIED", pt.getName(),
482 deegreeGeometry.getCoordinateSystem(), geomPt.getSRS() );
483 throw new TransactionException( msg );
484 }
485 try {
486 createSrsCode = datastore.getNativeSRSCode( deegreeGeometry.getCoordinateSystem().getIdentifier() );
487 } catch ( DatastoreException e ) {
488 throw new TransactionException( e.getMessage(), e );
489 }
490 targetSrsCode = dbField.getSRS();
491 }
492
493 try {
494 dbGeometry = this.datastore.convertDeegreeToDBGeometry( deegreeGeometry, createSrsCode, this.conn );
495 } catch ( DatastoreException e ) {
496 throw new TransactionException( e.getMessage(), e );
497 }
498
499 // TODO remove this Oracle hack
500 if ( this.datastore.getClass().getName().contains( "OracleDatastore" ) ) {
501 dbField = new MappingGeometryField( dbField.getTable(), dbField.getField(), Types.STRUCT,
502 dbField.getSRS() );
503 }
504
505 updateGeometryProperty( fid, tablePath, dbField, dbGeometry, targetSrsCode, statementBuffers );
506 } else if ( pt instanceof FeaturePropertyType ) {
507 updateProperty( fid, ft, (MappedFeaturePropertyType) pt, (Feature) replacementValue );
508 } else {
509 throw new DatastoreException( "Internal error: Properties with type '" + pt.getClass()
510 + "' are not handled in UpdateHandler." );
511 }
512 }
513
514 /**
515 * Updates a simple property of the specified feature.
516 * <p>
517 * Three cases are distinguished (which all have to be handled differently):
518 * <ol>
519 * <li>property value stored in feature table</li>
520 * <li>property value stored in property table, fk in property table</li>
521 * <li>property value stored in property table, fk in feature table</li>
522 * </ol>
523 *
524 * @param fid
525 * @param tablePath
526 * @param dbField
527 * @param replacementValue
528 * @throws DatastoreException
529 */
530 private void updateSimpleProperty( FeatureId fid, TableRelation[] tablePath, MappingField dbField,
531 Object replacementValue,
532 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers )
533 throws DatastoreException {
534
535 if ( tablePath.length == 0 ) {
536 updateSimpleProperty( fid, dbField, replacementValue, statementBuffers );
537 } else if ( tablePath.length == 1 ) {
538 TableRelation relation = tablePath[0];
539 if ( tablePath[0].getFKInfo() == FK_INFO.fkIsToField ) {
540 Object[] keyValues = determineKeyValues( fid, relation );
541 if ( keyValues != null ) {
542 deletePropertyRows( relation, keyValues );
543 }
544 if ( replacementValue != null ) {
545 insertPropertyRow( relation, keyValues, dbField, replacementValue );
546 }
547 } else {
548 Object[] oldKeyValues = determineKeyValues( fid, relation );
549 Object[] newKeyValues = findOrInsertPropertyRow( relation, dbField, replacementValue );
550 updateFeatureRow( fid, relation, newKeyValues );
551 if ( oldKeyValues != null ) {
552 deleteOrphanedPropertyRows( relation, oldKeyValues );
553 }
554 }
555 } else {
556 throw new DatastoreException( "Updating of properties that are stored in "
557 + "related tables using join tables is not " + "supported." );
558 }
559 }
560
561 /**
562 * Updates a geometry property of the specified feature.
563 * <p>
564 * Three cases are distinguished (which all have to be handled differently):
565 * <ol>
566 * <li>property value stored in feature table</li>
567 * <li>property value stored in property table, fk in property table</li>
568 * <li>property value stored in property table, fk in feature table</li>
569 * </ol>
570 *
571 * @param fid
572 * @param tablePath
573 * @param dbField
574 * @param replacementValue
575 * @param targetSrsCode
576 * @throws DatastoreException
577 */
578 private void updateGeometryProperty( FeatureId fid, TableRelation[] tablePath, MappingGeometryField dbField,
579 Object replacementValue, int targetSrsCode,
580 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers )
581 throws DatastoreException {
582
583 if ( tablePath.length == 0 ) {
584 updateGeometryProperty( fid, dbField, replacementValue, targetSrsCode, statementBuffers );
585 } else if ( tablePath.length == 1 ) {
586 throw new DatastoreException( "Updating of geometry properties that are stored in "
587 + "related tables is not supported." );
588 } else {
589 throw new DatastoreException( "Updating of properties that are stored in "
590 + "related tables using join tables is not " + "supported." );
591 }
592 }
593
594 private void updateFeatureRow( FeatureId fid, TableRelation relation, Object[] newKeyValues )
595 throws DatastoreException {
596
597 StatementBuffer query = new StatementBuffer();
598 query.append( "UPDATE " );
599 query.append( relation.getFromTable() );
600 query.append( " SET " );
601 MappingField[] fromFields = relation.getFromFields();
602 for ( int i = 0; i < newKeyValues.length; i++ ) {
603 query.append( fromFields[i].getField() );
604 query.append( "=?" );
605 query.addArgument( newKeyValues[i], fromFields[i].getType() );
606 }
607 query.append( " WHERE " );
608 appendFIDWhereCondition( query, fid );
609
610 LOG.logDebug( "Performing update: " + query.getQueryString() );
611
612 PreparedStatement stmt = null;
613 try {
614 stmt = this.datastore.prepareStatement( conn, query );
615 stmt.execute();
616 } catch ( SQLException e ) {
617 throw new DatastoreException( "Error in performUpdate(): " + e.getMessage() );
618 } finally {
619 if ( stmt != null ) {
620 try {
621 stmt.close();
622 } catch ( SQLException e ) {
623 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
624 }
625 }
626 }
627 }
628
629 /**
630 * Updates a simple property of the specified feature.
631 * <p>
632 * This method handles the case where the property is stored in the feature table itself, so a single UPDATE
633 * statement is sufficient.
634 *
635 * If there is already another UPDATE statement created for this feature and table than a column=value fragment is
636 * added to this statement.
637 *
638 * @param fid
639 * @param dbField
640 * @param replacementValue
641 * @throws DatastoreException
642 */
643 private void updateSimpleProperty( FeatureId fid, MappingField dbField, Object replacementValue,
644 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers ) {
645
646 Hashtable<FeatureId, StatementBuffer> featureStatementBuffers = statementBuffers.get( dbField.getTable() );
647 StatementBuffer query = null;
648 if ( featureStatementBuffers == null ) {
649 featureStatementBuffers = new Hashtable<FeatureId, StatementBuffer>();
650 statementBuffers.put( dbField.getTable(), featureStatementBuffers );
651 } else {
652 query = featureStatementBuffers.get( fid );
653 }
654
655 if ( query == null ) {
656 query = new StatementBuffer();
657 query.append( "UPDATE " );
658 query.append( dbField.getTable() );
659 query.append( " SET " );
660
661 featureStatementBuffers.put( fid, query );
662 } else {
663 query.append( ", " );
664 }
665
666 query.append( dbField.getField() );
667 query.append( "=?" );
668 query.addArgument( replacementValue, dbField.getType() );
669 }
670
671 /**
672 * Updates a geometry property of the specified feature.
673 * <p>
674 * This method handles the case where the property is stored in the feature table itself, so a single UPDATE
675 * statement is sufficient.
676 *
677 * If there is already another UPDATE statement created for this feature and table than a column=value fragment is
678 * added to this statement.
679 *
680 * @param fid
681 * @param dbField
682 * @param replacementValue
683 * @param targetSrsCode
684 * @throws DatastoreException
685 */
686 private void updateGeometryProperty( FeatureId fid, MappingGeometryField dbField, Object replacementValue,
687 int targetSrsCode,
688 Hashtable<String, Hashtable<FeatureId, StatementBuffer>> statementBuffers )
689 throws DatastoreException {
690
691 Hashtable<FeatureId, StatementBuffer> featureStatementBuffers = statementBuffers.get( dbField.getTable() );
692 StatementBuffer query = null;
693 if ( featureStatementBuffers == null ) {
694 featureStatementBuffers = new Hashtable<FeatureId, StatementBuffer>();
695 statementBuffers.put( dbField.getTable(), featureStatementBuffers );
696 } else {
697 query = featureStatementBuffers.get( fid );
698 }
699
700 if ( query == null ) {
701 query = new StatementBuffer();
702 query.append( "UPDATE " );
703 query.append( dbField.getTable() );
704 query.append( " SET " );
705
706 featureStatementBuffers.put( fid, query );
707 } else {
708 query.append( ", " );
709 }
710
711 query.append( dbField.getField() );
712 query.append( "=" );
713 String placeHolder = "?";
714 if ( targetSrsCode != -1 ) {
715 placeHolder = this.datastore.buildSRSTransformCall( "?", targetSrsCode );
716 }
717 query.append( placeHolder );
718 query.addArgument( replacementValue, dbField.getType() );
719 }
720
721 /**
722 * Determines the values for the key columns that are referenced by the given table relation (as from fields).
723 *
724 * @param fid
725 * @param relation
726 * @return the values for the key columns
727 * @throws DatastoreException
728 */
729 private Object[] determineKeyValues( FeatureId fid, TableRelation relation )
730 throws DatastoreException {
731
732 StatementBuffer query = new StatementBuffer();
733 query.append( "SELECT " );
734 MappingField[] fromFields = relation.getFromFields();
735 for ( int i = 0; i < fromFields.length; i++ ) {
736 query.append( fromFields[i].getField() );
737 if ( i != fromFields.length - 1 ) {
738 query.append( ',' );
739 }
740 }
741 query.append( " FROM " );
742 query.append( relation.getFromTable() );
743 query.append( " WHERE " );
744 appendFIDWhereCondition( query, fid );
745
746 Object[] keyValues = new Object[fromFields.length];
747 LOG.logDebug( "determineKeyValues: " + query.getQueryString() );
748 PreparedStatement stmt = null;
749 try {
750 stmt = this.datastore.prepareStatement( conn, query );
751 ResultSet rs = stmt.executeQuery();
752 if ( rs.next() ) {
753 for ( int i = 0; i < keyValues.length; i++ ) {
754 Object value = rs.getObject( i + 1 );
755 if ( value != null ) {
756 keyValues[i] = value;
757 } else {
758 keyValues = null;
759 break;
760 }
761 }
762 } else {
763 LOG.logError( "Internal error. Result is empty (no rows)." );
764 throw new SQLException();
765 }
766 } catch ( SQLException e ) {
767 throw new DatastoreException( "Error in performUpdate(): " + e.getMessage() );
768 } finally {
769 if ( stmt != null ) {
770 try {
771 stmt.close();
772 } catch ( SQLException e ) {
773 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
774 }
775 }
776 }
777 return keyValues;
778 }
779
780 private void deletePropertyRows( TableRelation relation, Object[] keyValues )
781 throws DatastoreException {
782
783 StatementBuffer query = new StatementBuffer();
784 query.append( "DELETE FROM " );
785 query.append( relation.getToTable() );
786 query.append( " WHERE " );
787 MappingField[] toFields = relation.getToFields();
788 for ( int i = 0; i < toFields.length; i++ ) {
789 query.append( toFields[i].getField() );
790 query.append( "=?" );
791 query.addArgument( keyValues[i], toFields[i].getType() );
792 if ( i != toFields.length - 1 ) {
793 query.append( " AND " );
794 }
795 }
796
797 PreparedStatement stmt = null;
798 LOG.logDebug( "deletePropertyRows: " + query.getQueryString() );
799 try {
800 stmt = this.datastore.prepareStatement( conn, query );
801 stmt.execute();
802 } catch ( SQLException e ) {
803 throw new DatastoreException( "Error in performUpdate(): " + e.getMessage() );
804 } finally {
805 if ( stmt != null ) {
806 try {
807 stmt.close();
808 } catch ( SQLException e ) {
809 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
810 }
811 }
812 }
813 }
814
815 private void insertPropertyRow( TableRelation relation, Object[] keyValues, MappingField dbField,
816 Object replacementValue )
817 throws DatastoreException {
818
819 if ( keyValues == null ) {
820 if ( relation.getFromFields().length > 1 ) {
821 throw new DatastoreException( "Key generation for compound keys is not supported." );
822 }
823 // generate new primary key
824 keyValues = new Object[1];
825 keyValues[0] = relation.getIdGenerator().getNewId( dsTa );
826 }
827
828 StatementBuffer query = new StatementBuffer();
829 query.append( "INSERT INTO " );
830 query.append( relation.getToTable() );
831 query.append( " (" );
832 MappingField[] toFields = relation.getToFields();
833 for ( int i = 0; i < toFields.length; i++ ) {
834 query.append( toFields[i].getField() );
835 query.append( ',' );
836 }
837 query.append( dbField.getField() );
838 query.append( ") VALUES (" );
839 for ( int i = 0; i < toFields.length; i++ ) {
840 query.append( '?' );
841 query.addArgument( keyValues[i], toFields[i].getType() );
842 query.append( ',' );
843 }
844 query.append( "?)" );
845 query.addArgument( replacementValue, dbField.getType() );
846
847 PreparedStatement stmt = null;
848 LOG.logDebug( "insertPropertyRow: " + query.getQueryString() );
849 try {
850 stmt = this.datastore.prepareStatement( conn, query );
851 stmt.execute();
852 } catch ( SQLException e ) {
853 throw new DatastoreException( "Error in performUpdate(): " + e.getMessage() );
854 } finally {
855 if ( stmt != null ) {
856 try {
857 stmt.close();
858 } catch ( SQLException e ) {
859 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
860 }
861 }
862 }
863 }
864
865 /**
866 * Returns the foreign key value(s) for the row that stores the given property.
867 * <p>
868 * If the row already exists, the existing key is returned, otherwise a new row for the property is inserted first.
869 *
870 * @param relation
871 * @param dbField
872 * @param replacementValue
873 * @return foreign key value(s) for the row that stores the given property
874 * @throws DatastoreException
875 */
876 private Object[] findOrInsertPropertyRow( TableRelation relation, MappingField dbField, Object replacementValue )
877 throws DatastoreException {
878
879 Object[] keyValues = null;
880
881 if ( dbField.getType() != Types.GEOMETRY ) {
882 StatementBuffer query = new StatementBuffer();
883 query.append( "SELECT " );
884 MappingField[] toFields = relation.getToFields();
885 for ( int i = 0; i < toFields.length; i++ ) {
886 query.append( toFields[i].getField() );
887 if ( i != toFields.length - 1 ) {
888 query.append( ',' );
889 }
890 }
891 query.append( " FROM " );
892 query.append( relation.getToTable() );
893 query.append( " WHERE " );
894 query.append( dbField.getField() );
895 query.append( "=?" );
896 query.addArgument( replacementValue, dbField.getType() );
897
898 PreparedStatement stmt = null;
899 LOG.logDebug( "findOrInsertPropertyRow: " + query.getQueryString() );
900 try {
901 stmt = this.datastore.prepareStatement( conn, query );
902 ResultSet rs = stmt.executeQuery();
903 if ( rs.next() ) {
904 keyValues = new Object[toFields.length];
905 for ( int i = 0; i < toFields.length; i++ ) {
906 keyValues[i] = rs.getObject( i + 1 );
907 }
908 }
909 } catch ( SQLException e ) {
910 throw new DatastoreException( "Error in findOrInsertPropertyRow(): " + e.getMessage() );
911 } finally {
912 if ( stmt != null ) {
913 try {
914 stmt.close();
915 } catch ( SQLException e ) {
916 LOG.logError( "Error closing statement: '" + e.getMessage() + "'.", e );
917 }
918 }
919 }
920 if ( keyValues != null ) {
921 return keyValues;
922 }
923 }
924
925 if ( relation.getToFields().length > 1 ) {
926 throw new DatastoreException( "Key generation for compound keys is not supported." );
927 }
928
929 // property does not yet exist (or it's a geometry)
930 keyValues = new Object[1];
931 // generate new PK
932 keyValues[0] = relation.getNewPK( this.dsTa );
933 insertPropertyRow( relation, keyValues, dbField, replacementValue );
934
935 return keyValues;
936 }
937
938 private void deleteOrphanedPropertyRows( TableRelation relation, Object[] keyValues )
939 throws DatastoreException {
940 DeleteHandler deleteHandler = new DeleteHandler( this.dsTa, this.aliasGenerator, this.conn, this.lockId );
941 deleteHandler.deleteOrphanedPropertyRows( relation, keyValues );
942 }
943
944 private void updateProperty( @SuppressWarnings("unused")
945 FeatureId fid, @SuppressWarnings("unused")
946 MappedFeatureType ft, @SuppressWarnings("unused")
947 MappedFeaturePropertyType pt, @SuppressWarnings("unused")
948 Feature replacementFeature ) {
949 throw new UnsupportedOperationException( "Updating of feature properties is not implemented yet." );
950 }
951
952 private void appendFIDWhereCondition( StatementBuffer query, FeatureId fid ) {
953 MappingField[] fidFields = fid.getFidDefinition().getIdFields();
954 for ( int i = 0; i < fidFields.length; i++ ) {
955 query.append( fidFields[i].getField() );
956 query.append( "=?" );
957 query.addArgument( fid.getValue( i ), fidFields[i].getType() );
958 if ( i != fidFields.length - 1 ) {
959 query.append( " AND " );
960 }
961 }
962 }
963 }