001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/datastore/sql/transaction/insert/InsertRow.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.insert;
037    
038    import java.util.ArrayList;
039    import java.util.Collection;
040    import java.util.HashMap;
041    import java.util.HashSet;
042    import java.util.Iterator;
043    import java.util.LinkedHashMap;
044    import java.util.List;
045    import java.util.Map;
046    import java.util.Set;
047    
048    import org.deegree.framework.log.ILogger;
049    import org.deegree.framework.log.LoggerFactory;
050    import org.deegree.i18n.Messages;
051    import org.deegree.io.datastore.TransactionException;
052    import org.deegree.ogcwebservices.wfs.operation.transaction.Insert;
053    
054    /**
055     * Represents a table row (columns + values) which has to be inserted as part of an {@link Insert} operation.
056     *
057     * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider</a>
058     * @author last edited by: $Author: mschneider $
059     *
060     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
061     */
062    public class InsertRow {
063    
064        private static final ILogger LOG = LoggerFactory.getLogger( InsertRow.class );
065    
066        /** Database table */
067        protected String table;
068    
069        /** Maps column names to their corresponding {@link InsertField} instance. */
070        protected Map<String, InsertField> columnMap = new LinkedHashMap<String, InsertField>();
071    
072        /**
073         * Creates a new <code>InsertRow</code> instance for the given table.
074         *
075         * @param table
076         */
077        public InsertRow( String table ) {
078            this.table = table;
079        }
080    
081        /**
082         * Returns the name of table.
083         *
084         * @return the name of table
085         */
086        public String getTable() {
087            return this.table;
088        }
089    
090        /**
091         * Sets the value to be inserted in the given table column.
092         * <p>
093         * In complex + erroneous mappings (or feature instances), it may happen that different property values (mapped to
094         * the same column) imply different values. This is checked for and in case an {@link TransactionException} is
095         * thrown.
096         *
097         * @param column
098         * @param value
099         * @param sqlType
100         * @param isPK
101         * @return column + value to be set
102         * @throws TransactionException
103         *             if the value for the column clashes
104         */
105        public InsertField setColumn( String column, Object value, int sqlType, boolean isPK )
106                                throws TransactionException {
107    
108            InsertField field = new InsertField( this, column, sqlType, value, isPK );
109            InsertField presentField = columnMap.get( column );
110            if ( presentField != null && ( !presentField.getValue().toString().equals( value.toString() ) ) ) {
111                Object[] params = new Object[] { column, this.table, presentField.getValue().toString(), value.toString() };
112                String msg = Messages.getMessage( "DATASTORE_AMBIGOUS_COLUMN_VALUES", params );
113                throw new TransactionException( msg );
114            }
115            if ( presentField == null ) {
116                this.columnMap.put( column, field );
117            }
118            // TODO type check
119            return field;
120        }
121    
122        /**
123         * Sets the value to be inserted in the given geometry column.
124         * <p>
125         * In complex + erroneous mappings (or feature instances), it may happen that different property values (mapped to
126         * the same column) imply different values. This is checked for and in case an {@link TransactionException} is
127         * thrown.
128         *
129         * @param column
130         * @param value
131         * @param sqlType
132         * @param isPK
133         * @param internalSrsCode
134         * @return column + value to be set
135         * @throws TransactionException
136         *             if the value for the column clashes
137         */
138        public InsertGeometryField setGeometryColumn( String column, Object value, int sqlType, boolean isPK,
139                                                      int internalSrsCode )
140                                throws TransactionException {
141    
142            InsertGeometryField field = new InsertGeometryField( this, column, sqlType, value, isPK, internalSrsCode );
143            InsertField presentField = columnMap.get( column );
144            if ( presentField != null && ( !presentField.getValue().toString().equals( value.toString() ) ) ) {
145                Object[] params = new Object[] { column, this.table, presentField.getValue().toString(), value.toString() };
146                String msg = Messages.getMessage( "DATASTORE_AMBIGOUS_COLUMN_VALUES", params );
147                throw new TransactionException( msg );
148            }
149            if ( presentField == null ) {
150                this.columnMap.put( column, field );
151            }
152            // TODO type check
153            return field;
154        }
155    
156        /**
157         * Sets the value to be inserted in the given table column - the column references the given {@link InsertField} and
158         * thus must have the same value as the referenced column.
159         * <p>
160         * In complex + erroneous mappings (or feature instances), it may happen that different property values (mapped to
161         * the same column) imply different values. This is checked for and in case an {@link TransactionException} is
162         * thrown.
163         *
164         * @param column
165         * @param referencedField
166         * @throws TransactionException
167         *             if the value for the column clashes
168         */
169        public void linkColumn( String column, InsertField referencedField )
170                                throws TransactionException {
171    
172            if ( referencedField.getValue() == null ) {
173                LOG.logError( "linkColumn (): referencedField is null" );
174                throw new TransactionException( "linkColumn (): referenced field is null!" );
175            }
176    
177            InsertField presentField = this.columnMap.get( column );
178            if ( presentField != null
179                 && ( !presentField.getValue().toString().equals( referencedField.getValue().toString() ) ) ) {
180                Object[] params = new Object[] { column, this.table, presentField.getValue().toString(),
181                                                referencedField.getValue().toString() };
182                String msg = Messages.getMessage( "DATASTORE_AMBIGOUS_COLUMN_VALUES", params );
183                throw new TransactionException( msg );
184            }
185    
186            InsertField field = presentField;
187            if ( presentField != null ) {
188                presentField.relinkField( referencedField );
189            } else {
190                field = new InsertField( this, column, referencedField );
191                this.columnMap.put( column, field );
192            }
193            referencedField.addReferencingField( field );
194        }
195    
196        /**
197         * Returns all {@link InsertField}s.
198         *
199         * @return all InsertFields
200         */
201        public Collection<InsertField> getColumns() {
202            return this.columnMap.values();
203        }
204    
205        /**
206         * Returns the {@link InsertField} for the given column name.
207         *
208         * @param column
209         *            requested column name
210         * @return the InsertField for the given column name, or null if it does not exist
211         */
212        public InsertField getColumn( String column ) {
213            return this.columnMap.get( column );
214        }
215    
216        /**
217         * Returns the {@link InsertField} for the primary key column.
218         *
219         * @return the InsertField for the primary key column
220         */
221        public InsertField getPKColumn() {
222            InsertField pkField = null;
223            for ( InsertField field : this.columnMap.values() ) {
224                if ( field.isPK() ) {
225                    pkField = field;
226                    break;
227                }
228            }
229            return pkField;
230        }
231    
232        /**
233         * Returns all {@link InsertField} that reference a column in this <code>InsertRow</code>. The fields may well be
234         * from other tables.
235         *
236         * @return all InsertFields that reference a column in this InsertRow
237         */
238        public List<InsertField> getReferencingFields() {
239            List<InsertField> referencingFields = new ArrayList<InsertField>();
240            Iterator<InsertField> iter = this.columnMap.values().iterator();
241            while ( iter.hasNext() ) {
242                InsertField field = iter.next();
243                referencingFields.addAll( field.getReferencingFields() );
244            }
245            return referencingFields;
246        }
247    
248        /**
249         * Returns all {@link InsertRow}s that reference a column in this <code>InsertRow</code>. The rows may well be from
250         * other tables.
251         *
252         * @return all InsertRows that reference a column in this InsertRow
253         */
254        Collection<InsertRow> getReferencingRows() {
255            Set<InsertRow> referencingRows = new HashSet<InsertRow>();
256            Iterator<InsertField> iter = this.columnMap.values().iterator();
257            while ( iter.hasNext() ) {
258                InsertField field = iter.next();
259                referencingRows.addAll( field.getReferencingRows() );
260            }
261            return referencingRows;
262        }
263    
264        /**
265         * Returns all {@link InsertField}s that are referenced by a field from this <code>InsertRow</code>. The fields may
266         * well be from other tables.
267         *
268         * @return all InsertField that are referenced by a field from this InsertRow
269         */
270        List<InsertField> getReferencedFields() {
271            List<InsertField> referencedFields = new ArrayList<InsertField>();
272            Iterator<InsertField> iter = this.columnMap.values().iterator();
273            while ( iter.hasNext() ) {
274                InsertField field = iter.next();
275                InsertField referencedField = field.getReferencedField();
276                if ( referencedField != null ) {
277                    referencedFields.add( referencedField );
278                }
279            }
280            return referencedFields;
281        }
282    
283        /**
284         * Returns all {@link InsertRow}s that are referenced by a field from this <code>InsertRow</code>. The rows may well
285         * be from other tables.
286         *
287         * @return all InsertRows that are referenced by a field from this InsertRow
288         */
289        private Collection<InsertRow> getReferencedRows() {
290            Set<InsertRow> referencedRows = new HashSet<InsertRow>();
291            Iterator<InsertField> iter = this.columnMap.values().iterator();
292            while ( iter.hasNext() ) {
293                InsertField field = iter.next();
294                InsertRow referencedRow = field.getReferencedRow();
295                if ( referencedRow != null ) {
296                    referencedRows.add( referencedRow );
297                }
298            }
299            return referencedRows;
300        }
301    
302        /**
303         * Sorts the given <code>InsertRow</code>s topologically (respecting the foreign key constraints), so they can be
304         * inserted in the resulting order without causing foreign key violations.
305         * <p>
306         * Number of precedessors (pre): number of fields that *are referenced by* this row Number of successors (post) :
307         * number of fields that *reference* this row
308         *
309         * @param inserts
310         *            insert rows to sort
311         * @return the nodes of the graph in topological order if no cycle is present, else in arbitrary order
312         */
313        public static List<InsertRow> getInsertOrder( List<InsertRow> inserts ) {
314    
315            List<InsertRow> result = new ArrayList<InsertRow>();
316    
317            // key: inserts, value: number of fields that are referenced by this row
318            Map<InsertRow, Integer> preMap = new HashMap<InsertRow, Integer>();
319    
320            // key: inserts with no foreign key constraints
321            List<InsertRow> noPre = new ArrayList<InsertRow>();
322    
323            // build map
324            Iterator<InsertRow> insertIter = inserts.iterator();
325            while ( insertIter.hasNext() ) {
326                InsertRow insertRow = insertIter.next();
327                int pre = insertRow.getReferencedFields().size();
328                LOG.logDebug( "Adding row to preMap: " + insertRow );
329                preMap.put( insertRow, pre );
330                if ( pre == 0 ) {
331                    noPre.add( insertRow );
332                }
333            }
334    
335            while ( !noPre.isEmpty() ) {
336                // select an insert row that has no open fk constraints
337                InsertRow insertRow = noPre.get( 0 );
338                noPre.remove( 0 );
339                result.add( insertRow );
340    
341                // decrease the number of pending fk constraints for all insert rows that
342                // reference the currently processed insert row
343                Collection<InsertField> postList = insertRow.getReferencingFields();
344                Iterator<InsertField> iter = postList.iterator();
345                while ( iter.hasNext() ) {
346                    InsertField postField = iter.next();
347                    if ( preMap.get( postField.getRow() ) == null ) {
348                        LOG.logDebug( "No pre info for: " + postField.getRow() );
349                    }
350                    int pre = preMap.get( postField.getRow() );
351                    preMap.put( postField.getRow(), --pre );
352                    if ( pre == 0 ) {
353                        noPre.add( postField.getRow() );
354                    }
355                }
356            }
357    
358            if ( result.size() != inserts.size() ) {
359                Collection<InsertRow> cycle = InsertRow.findCycle( inserts );
360                Iterator<InsertRow> cycleIter = cycle.iterator();
361                StringBuffer sb = new StringBuffer();
362                while ( cycleIter.hasNext() ) {
363                    sb.append( cycleIter.next() );
364                    if ( cycle.iterator().hasNext() ) {
365                        sb.append( " -> " );
366                    }
367                }
368                String msg = Messages.getMessage( "DATASTORE_FK_CYCLE", sb.toString() );
369                LOG.logWarning( msg );
370                result.clear();
371                result.addAll( inserts );
372            }
373            return result;
374        }
375    
376        /**
377         * Checks if the given <code>InsertRow</code>s contain cyclic fk constraints.
378         *
379         * @param rows
380         * @return steps of the cycle, or null if there is none
381         */
382        private static Collection<InsertRow> findCycle( Collection<InsertRow> rows ) {
383    
384            Iterator<InsertRow> rowsIter = rows.iterator();
385            while ( rowsIter.hasNext() ) {
386                InsertRow begin = rowsIter.next();
387                Iterator<InsertRow> refIter = begin.getReferencedRows().iterator();
388                while ( refIter.hasNext() ) {
389                    InsertRow referencedRow = refIter.next();
390                    List<InsertRow> cycle = findCycleRecursion( referencedRow, begin, new ArrayList<InsertRow>() );
391                    if ( cycle != null ) {
392                        return cycle;
393                    }
394                }
395            }
396            return null;
397        }
398    
399        private static List<InsertRow> findCycleRecursion( InsertRow next, InsertRow begin, List<InsertRow> steps ) {
400    
401            if ( steps.contains( next ) ) {
402                steps.add( next );
403                return steps;
404            }
405            steps.add( next );
406    
407            Iterator<InsertRow> refIter = next.getReferencedRows().iterator();
408            while ( refIter.hasNext() ) {
409                InsertRow referencedRow = refIter.next();
410                List<InsertRow> cycle = findCycleRecursion( referencedRow, begin, steps );
411                if ( cycle != null ) {
412                    return cycle;
413                }
414            }
415            steps.remove( steps.size() - 1 );
416            return null;
417        }
418    
419        /**
420         * Returns a string representation of the object.
421         *
422         * @return a string representation of the object
423         */
424        @Override
425        public String toString() {
426            StringBuffer sb = new StringBuffer( "InsertRow, table: '" );
427            sb.append( this.table );
428            sb.append( "'" );
429            Iterator<String> columnIter = this.columnMap.keySet().iterator();
430            while ( columnIter.hasNext() ) {
431                sb.append( ", " );
432                String column = columnIter.next();
433                InsertField field = this.columnMap.get( column );
434                sb.append( field );
435            }
436            return sb.toString();
437        }
438    }