001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/io/datastore/schema/MappedGMLSchemaDocument.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.schema;
037    
038    import static org.deegree.framework.xml.XMLTools.getElements;
039    import static org.deegree.framework.xml.XMLTools.getNodeAsBoolean;
040    import static org.deegree.framework.xml.XMLTools.getNodeAsQualifiedName;
041    import static org.deegree.framework.xml.XMLTools.getRequiredElement;
042    import static org.deegree.framework.xml.XMLTools.getRequiredNodeAsQualifiedName;
043    import static org.deegree.ogcbase.CommonNamespaces.DEEGREEWFS_PREFIX;
044    import static org.deegree.ogcbase.CommonNamespaces.XS_PREFIX;
045    
046    import java.net.URI;
047    import java.util.ArrayList;
048    import java.util.Iterator;
049    import java.util.LinkedList;
050    import java.util.List;
051    import java.util.Properties;
052    
053    import org.deegree.datatypes.QualifiedName;
054    import org.deegree.datatypes.Types;
055    import org.deegree.datatypes.UnknownTypeException;
056    import org.deegree.framework.log.ILogger;
057    import org.deegree.framework.log.LoggerFactory;
058    import org.deegree.framework.util.Pair;
059    import org.deegree.framework.xml.XMLParsingException;
060    import org.deegree.framework.xml.XMLTools;
061    import org.deegree.framework.xml.schema.ComplexTypeDeclaration;
062    import org.deegree.framework.xml.schema.ElementDeclaration;
063    import org.deegree.framework.xml.schema.SimpleTypeDeclaration;
064    import org.deegree.framework.xml.schema.TypeDeclaration;
065    import org.deegree.framework.xml.schema.TypeReference;
066    import org.deegree.framework.xml.schema.XMLSchemaException;
067    import org.deegree.i18n.Messages;
068    import org.deegree.io.datastore.AnnotationDocument;
069    import org.deegree.io.datastore.Datastore;
070    import org.deegree.io.datastore.DatastoreConfiguration;
071    import org.deegree.io.datastore.DatastoreRegistry;
072    import org.deegree.io.datastore.idgenerator.IdGenerator;
073    import org.deegree.io.datastore.schema.MappedGMLId.IDPART_INFO;
074    import org.deegree.io.datastore.schema.TableRelation.FK_INFO;
075    import org.deegree.io.datastore.schema.content.ConstantContent;
076    import org.deegree.io.datastore.schema.content.FieldContent;
077    import org.deegree.io.datastore.schema.content.FunctionParam;
078    import org.deegree.io.datastore.schema.content.MappingField;
079    import org.deegree.io.datastore.schema.content.MappingGeometryField;
080    import org.deegree.io.datastore.schema.content.SQLFunctionCall;
081    import org.deegree.io.datastore.schema.content.SimpleContent;
082    import org.deegree.io.datastore.schema.content.SpecialContent;
083    import org.deegree.model.crs.UnknownCRSException;
084    import org.deegree.model.feature.schema.GMLSchemaDocument;
085    import org.deegree.model.feature.schema.PropertyType;
086    import org.deegree.ogcbase.CommonNamespaces;
087    import org.w3c.dom.Element;
088    import org.w3c.dom.Node;
089    
090    /**
091     * Parser for GML schema documents which are annotated with mapping (persistence) information.
092     *
093     * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider </a>
094     * @author last edited by: $Author: mschneider $
095     *
096     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
097     */
098    public class MappedGMLSchemaDocument extends GMLSchemaDocument {
099    
100        private static final long serialVersionUID = 8293629056821438839L;
101    
102        private static final ILogger LOG = LoggerFactory.getLogger( MappedGMLSchemaDocument.class );
103    
104        private String namespacePrefix;
105    
106        private URI defaultSRS;
107    
108        private boolean suppressXLinkOutput;
109    
110        private DatastoreConfiguration dsConfiguration;
111    
112        /**
113         * Returns the class representation of the underlying mapped GML schema document.
114         *
115         * @return the class representation of the underlying mapped GML schema document
116         * @throws XMLParsingException
117         * @throws XMLSchemaException
118         * @throws UnknownCRSException
119         */
120        public MappedGMLSchema parseMappedGMLSchema()
121                                throws XMLParsingException, XMLSchemaException, UnknownCRSException {
122            parseGlobalAnnotations();
123            SimpleTypeDeclaration[] simpleTypes = extractSimpleTypeDeclarations();
124            ComplexTypeDeclaration[] complexTypes = extractComplexTypeDeclarations();
125            ElementDeclaration[] elementDeclarations = extractElementDeclarations();
126            return new MappedGMLSchema( getTargetNamespace(), simpleTypes, complexTypes, elementDeclarations,
127                                        this.namespacePrefix, this.defaultSRS, this.dsConfiguration,
128                                        this.suppressXLinkOutput, this );
129        }
130    
131        /**
132         * Parses the global "xs:annotation/xs:appinfo" block.
133         * <p>
134         * Delegates the datastore specific configuration options to the responsible {@link AnnotationDocument} parser.
135         *
136         * @throws XMLParsingException
137         */
138        @SuppressWarnings("unchecked")
139        private void parseGlobalAnnotations()
140                                throws XMLParsingException {
141    
142            Element appinfoElement = (Element) XMLTools.getRequiredNode( getRootElement(), "xs:annotation/xs:appinfo",
143                                                                         nsContext );
144            this.namespacePrefix = XMLTools.getRequiredNodeAsString( appinfoElement, "deegreewfs:Prefix", nsContext );
145            String backend = XMLTools.getRequiredNodeAsString( appinfoElement, "deegreewfs:Backend", nsContext );
146            this.suppressXLinkOutput = XMLTools.getNodeAsBoolean( appinfoElement, "deegreewfs:SuppressXLinkOutput/text()",
147                                                                  nsContext, false );
148            this.defaultSRS = XMLTools.getRequiredNodeAsURI( appinfoElement, "deegreewfs:DefaultSRS", nsContext );
149    
150            Class<Datastore> datastoreClass = null;
151            try {
152                datastoreClass = DatastoreRegistry.getDatastoreClass( backend );
153            } catch ( IllegalArgumentException e ) {
154                String msg = Messages.getMessage( "DATASTORE_UNKNOWN_TYPE_CODE", backend );
155                LOG.logInfo( msg );
156                try {
157                    datastoreClass = (Class<Datastore>) Class.forName( backend );
158                } catch ( ClassNotFoundException e1 ) {
159                    msg = Messages.getMessage( "DATASTORE_UNKNOWN_TYPE_AND_CLASS", backend );
160                    throw new XMLParsingException( msg );
161                }
162            }
163    
164            AnnotationDocument annotationParser = null;
165            try {
166                Datastore ds = datastoreClass.newInstance();
167                annotationParser = ds.getAnnotationParser();
168            } catch ( Exception e ) {
169                String msg = Messages.getMessage( "DATASTORE_CLASS_INSTANTIATION_ERROR", datastoreClass.getName(),
170                                                  e.getMessage() );
171                throw new XMLParsingException( msg );
172            }
173    
174            annotationParser.setRootElement( this.getRootElement() );
175            annotationParser.setSystemId( this.getSystemId() );
176            try {
177                this.dsConfiguration = annotationParser.parseDatastoreConfiguration();
178            } catch ( XMLParsingException e ) {
179                LOG.logError( e.getMessage(), e );
180                String msg = Messages.getMessage( "DATASTORE_CONFIGURATION_BLOCK_FAULTY", e.getMessage() );
181                throw new XMLParsingException( msg );
182            }
183        }
184    
185        /**
186         * Parses the given <code>Element</code> as an annotated 'xs:element' declaration (with mapping information).
187         *
188         * @param element
189         *            'xs:element' declaration to be parsed
190         * @return object representation of the declaration
191         * @throws XMLParsingException
192         *             if the document is not a valid XML Schema document or does not match the limitations of this class
193         */
194        @Override
195        protected MappedElementDeclaration parseElementDeclaration( Element element )
196                                throws XMLParsingException {
197    
198            QualifiedName name = new QualifiedName( XMLTools.getRequiredNodeAsString( element, "@name", nsContext ),
199                                                    getTargetNamespace() );
200            if ( name.getLocalName().length() == 0 ) {
201                String msg = "Error in schema document. Empty name (\"\") in element declaration found.";
202                throw new XMLSchemaException( msg );
203            }
204    
205            boolean isAbstract = XMLTools.getNodeAsBoolean( element, "@abstract", nsContext, false );
206    
207            TypeReference typeReference = null;
208            Node typeNode = XMLTools.getNode( element, "@type", nsContext );
209            if ( typeNode != null ) {
210                typeReference = new TypeReference( parseQualifiedName( typeNode ) );
211            } else {
212                if ( LOG.isDebug() ) {
213                    LOG.logDebug( "Trying to find a complexType below the element named " + element.getAttribute( "name" )
214                                  + "." );
215                }
216                // inline type declaration
217                Element elem = (Element) XMLTools.getRequiredNode( element, getFullName( "complexType" ), nsContext );
218                TypeDeclaration type = parseComplexTypeDeclaration( elem );
219                typeReference = new TypeReference( type );
220            }
221    
222            int minOccurs = XMLTools.getNodeAsInt( element, "@minOccurs", nsContext, 1 );
223            int maxOccurs = -1;
224            String maxOccursString = XMLTools.getNodeAsString( element, "@maxOccurs", nsContext, "1" );
225            if ( !"unbounded".equals( maxOccursString ) ) {
226                try {
227                    maxOccurs = Integer.parseInt( maxOccursString );
228                } catch ( NumberFormatException e ) {
229                    throw new XMLParsingException( "Invalid value ('" + maxOccursString + "') in 'maxOccurs' attribute. "
230                                                   + "Must be a valid integer value or 'unbounded'." );
231                }
232            }
233    
234            QualifiedName substitutionGroup = null;
235            Node substitutionGroupNode = XMLTools.getNode( element, "@substitutionGroup", nsContext );
236            if ( substitutionGroupNode != null ) {
237                substitutionGroup = parseQualifiedName( substitutionGroupNode );
238            }
239    
240            Element annotationElement = (Element) XMLTools.getNode( element, getFullName( "annotation" ), nsContext );
241    
242            return new MappedElementDeclaration( name, isAbstract, typeReference, minOccurs, maxOccurs, substitutionGroup,
243                                                 annotationElement );
244        }
245    
246        /**
247         * Parses the given <code>Element</code> as an annotated 'xs:complexType' declaration (with mapping information).
248         *
249         * @param element
250         *            'xs:complexType' declaration to be parsed
251         * @return object representation of the declaration
252         * @throws XMLParsingException
253         *             if the document is not a valid XML Schema document or does not match the limitations of this class
254         */
255        @Override
256        protected MappedComplexTypeDeclaration parseComplexTypeDeclaration( Element element )
257                                throws XMLParsingException {
258    
259            QualifiedName name = null;
260            String localName = XMLTools.getNodeAsString( element, "@name", nsContext, null );
261            if ( localName != null ) {
262                name = new QualifiedName( localName, getTargetNamespace() );
263                if ( localName.length() == 0 ) {
264                    String msg = "Error in schema document. Empty name (\"\") for complexType " + "declaration found.";
265                    throw new XMLSchemaException( msg );
266                }
267            }
268    
269            List<Node> subElementList = null;
270            TypeReference extensionBase = null;
271            Node extensionBaseNode = XMLTools.getNode( element, getFullName( "complexContent/" )
272                                                                + getFullName( "extension/@base" ), nsContext );
273            if ( extensionBaseNode != null ) {
274                extensionBase = new TypeReference( parseQualifiedName( extensionBaseNode ) );
275                subElementList = XMLTools.getNodes( element, getFullName( "complexContent/" ) + getFullName( "extension/" )
276                                                             + getFullName( "sequence/" ) + getFullName( "element" ),
277                                                    nsContext );
278            } else {
279                subElementList = XMLTools.getRequiredNodes( element, getFullName( "sequence/" ) + getFullName( "element" ),
280                                                            nsContext );
281            }
282    
283            ElementDeclaration[] subElements = new ElementDeclaration[subElementList.size()];
284            for ( int i = 0; i < subElements.length; i++ ) {
285                Element subElement = (Element) subElementList.get( i );
286                subElements[i] = parseElementDeclaration( subElement );
287            }
288            Element annotationElement = (Element) XMLTools.getNode( element, getFullName( "annotation" ), nsContext );
289    
290            return new MappedComplexTypeDeclaration( name, extensionBase, subElements, annotationElement );
291        }
292    
293        /**
294         * Extracts the "gml:id" information from the given "xs:annotation" element.
295         *
296         * @param annotationElement
297         *            "xs:annotation" element
298         * @param defaultTableName
299         *            name for table if "deegreewfs:table"-element is missing
300         * @return "gml:id" information as MappedGMLId
301         * @throws XMLSchemaException
302         *             if a syntactic or semantic error is found
303         */
304        MappedGMLId extractGMLId( Element annotationElement, String defaultTableName )
305                                throws XMLSchemaException {
306            MappedGMLId gmlId = null;
307            try {
308                String table = XMLTools.getNodeAsString( annotationElement, "xs:appinfo/deegreewfs:table/text()",
309                                                         nsContext, defaultTableName );
310                Element gmlIdElement = (Element) XMLTools.getNode( annotationElement, "xs:appinfo/deegreewfs:gmlId",
311                                                                   nsContext );
312                if ( gmlIdElement != null ) {
313                    gmlId = parseGMLIdDefinition( gmlIdElement, table );
314                } else {
315                    MappingField[] idFields = new MappingField[] { new MappingField( table, "fid", Types.VARCHAR ) };
316                    IdGenerator idGenerator = IdGenerator.getInstance( IdGenerator.TYPE_UUID, new Properties() );
317                    gmlId = new MappedGMLId( defaultTableName.toUpperCase(), "_", idFields, idGenerator,
318                                             IDPART_INFO.notIDPart );
319                }
320            } catch ( XMLParsingException e ) {
321                throw new XMLSchemaException( e.getMessage(), e );
322            }
323            return gmlId;
324        }
325    
326        /**
327         * Extracts the mapping information for a simple property type from the given "xs:annotation" element.
328         *
329         * @param element
330         *            "xs:annotation" element
331         * @param propertyName
332         *            name of the property (local part is used as default field name if it is not specified explicitly in
333         *            the "MappingField" element)
334         * @param type
335         * @param minOccurs
336         * @param maxOccurs
337         * @param isIdentityPart
338         * @param table
339         *            name of the table that is associated with the feature type that this property belongs to
340         * @return simple property type with persistence information
341         * @throws XMLSchemaException
342         *             if a syntactic or semantic error is found
343         */
344        MappedSimplePropertyType parseMappedSimplePropertyType( Element element, QualifiedName propertyName, int type,
345                                                                int minOccurs, int maxOccurs, boolean isIdentityPart,
346                                                                String table )
347                                throws XMLSchemaException {
348    
349            MappedSimplePropertyType pt = null;
350            try {
351                Element contentElement = (Element) XMLTools.getRequiredNode( element, "xs:appinfo/deegreewfs:Content",
352                                                                             nsContext );
353                // sanity check (common user error)
354                Node typeNode = XMLTools.getNode( contentElement, "@type", nsContext );
355                if ( typeNode != null ) {
356                    String msg = "Content element for simple property type '" + propertyName
357                                 + "' must not contain a type attribute.";
358                    throw new XMLParsingException( msg );
359                }
360    
361                // table relations
362                List<Node> relationElements = XMLTools.getNodes( contentElement, "deegreewfs:Relation", nsContext );
363                TableRelation[] tableRelations = new TableRelation[relationElements.size()];
364                String fromTable = table;
365                for ( int i = 0; i < tableRelations.length; i++ ) {
366                    tableRelations[i] = parseTableRelation( (Element) relationElements.get( i ), fromTable );
367                    fromTable = tableRelations[i].getToTable();
368                }
369    
370                SimpleContent content = null;
371    
372                // check type of content
373                Node node = XMLTools.getNode( contentElement, "deegreewfs:MappingField", nsContext );
374                if ( node != null ) {
375                    String defaultField = propertyName.getLocalName();
376                    content = parseMappingField( (Element) node, defaultField, table );
377                } else {
378                    node = XMLTools.getNode( contentElement, "deegreewfs:Constant", nsContext );
379                    if ( node != null ) {
380                        content = parseConstantContent( (Element) node );
381                    } else {
382                        node = XMLTools.getNode( contentElement, "deegreewfs:SQLFunctionCall", nsContext );
383                        if ( node != null ) {
384                            content = parseSQLFunctionCall( (Element) node, table );
385                        } else {
386                            String msg = Messages.getMessage( "DATASTORE_ANNOTATION_SIMPLE_CONTENT_ERROR", propertyName );
387                            throw new XMLParsingException( msg );
388                        }
389                    }
390                }
391    
392                pt = new MappedSimplePropertyType( propertyName, type, minOccurs, maxOccurs, isIdentityPart,
393                                                   tableRelations, content );
394            } catch ( XMLParsingException e ) {
395                throw new XMLSchemaException( "Error in definition of simple property '" + propertyName + "': "
396                                              + e.getMessage() );
397            }
398            return pt;
399        }
400    
401        /**
402         * Parses the given element as a "deegreewfs:Constant" element.
403         *
404         * @param element
405         *            "deegreewfs:Constant" element
406         * @return java representation of element
407         * @throws XMLParsingException
408         */
409        ConstantContent parseConstantContent( Element element )
410                                throws XMLParsingException {
411            String constant = XMLTools.getRequiredNodeAsString( element, "text()", nsContext );
412            return new ConstantContent( constant );
413        }
414    
415        /**
416         * Parses the given "deegreewfs:SpecialContent" element.
417         *
418         * @param element
419         *            "deegreewfs:SpecialContent" element
420         * @return java representation of element
421         * @throws XMLParsingException
422         */
423        SpecialContent parseSpecialContent( Element element )
424                                throws XMLParsingException {
425    
426            SpecialContent content = null;
427            String variable = XMLTools.getRequiredNodeAsString( element, "text()", nsContext );
428    
429            try {
430                content = new SpecialContent( variable );
431            } catch ( Exception e ) {
432                String msg = Messages.getMessage( "DATASTORE_PARSING_SPECIAL_CONTENT", e.getMessage() );
433                throw new XMLParsingException( msg );
434            }
435            return content;
436        }
437    
438        /**
439         * Parses the given element as a "deegreewfs:SQLFunctionCall" element.
440         *
441         * @param element
442         *            "deegreewfs:SQLFunctionCall" element
443         * @param table
444         * @return java representation of element
445         * @throws XMLParsingException
446         */
447        SQLFunctionCall parseSQLFunctionCall( Element element, String table )
448                                throws XMLParsingException {
449    
450            String callString = XMLTools.getRequiredNodeAsString( element, "@call", nsContext );
451    
452            String typeName = XMLTools.getRequiredNodeAsString( element, "@type", nsContext );
453            int typeCode = -1;
454            try {
455                typeCode = Types.getTypeCodeForSQLType( typeName );
456            } catch ( UnknownTypeException e ) {
457                throw new XMLParsingException( "Invalid field type: " + e.getMessage(), e );
458            }
459    
460            List<Node> nl = XMLTools.getNodes( element, "deegreewfs:FunctionParam", nsContext );
461            List<FunctionParam> functionParams = new ArrayList<FunctionParam>();
462            Iterator<Node> iter = nl.iterator();
463            while ( iter.hasNext() ) {
464                Element paramElement = (Element) iter.next();
465                functionParams.add( parseFunctionParam( paramElement, table ) );
466            }
467    
468            // validate variable references
469            int maxVar = extractMaxVariableNumber( callString );
470            if ( maxVar > functionParams.size() ) {
471                String msg = "Error in FunctionCall definition ('" + callString + "') - call string uses variable $"
472                             + maxVar + ", but only has " + functionParams.size() + " FunctionParam elements.";
473                throw new XMLParsingException( msg );
474            }
475    
476            // check SRS for all function params (mapped geometry columns)
477            int internalSRS = -1;
478            for ( FunctionParam param : functionParams ) {
479                if ( param instanceof FieldContent ) {
480                    MappingField mf = ( (FieldContent) param ).getField();
481                    if ( mf instanceof MappingGeometryField ) {
482                        int thisSRS = ( (MappingGeometryField) mf ).getSRS();
483                        if ( internalSRS == -1 ) {
484                            internalSRS = thisSRS;
485                        } else {
486                            if ( internalSRS != thisSRS ) {
487                                String msg = Messages.getMessage( "DATASTORE_SQL_FUNCTION_CALL_INVALID_SRS", internalSRS,
488                                                                  thisSRS );
489                                throw new XMLParsingException( msg );
490                            }
491                        }
492                    }
493                }
494            }
495    
496            // set SRS for all 'SpecialContent' function params
497            for ( FunctionParam param : functionParams ) {
498                if ( param instanceof SpecialContent ) {
499                    ( (SpecialContent) param ).setSRS( internalSRS );
500                }
501            }
502    
503            return new SQLFunctionCall( callString, typeCode, functionParams );
504        }
505    
506        /**
507         * Extracts maximum variable numbers ('$i') used in the given call string.
508         *
509         * TODO: handle leading zeros
510         *
511         * @param callString
512         * @return maximum variable numbers used in the given call string
513         */
514        private int extractMaxVariableNumber( String callString )
515                                throws XMLParsingException {
516    
517            int maxVar = 0;
518    
519            int foundAt = callString.indexOf( '$' );
520            while ( foundAt != -1 ) {
521                foundAt++;
522                String varNumberString = "";
523                while ( foundAt < callString.length() ) {
524                    char numberChar = callString.charAt( foundAt++ );
525                    if ( numberChar >= '0' && numberChar <= '9' ) {
526                        varNumberString += numberChar;
527                    } else {
528                        break;
529                    }
530                }
531    
532                if ( varNumberString.length() == 0 ) {
533                    String msg = "Error in call attribute ('" + callString
534                                 + "') of FunctionCall definition - parameters must be specified by "
535                                 + "the '$' symbol, followed by a positive integer.";
536                    throw new XMLParsingException( msg );
537                }
538    
539                try {
540                    int varNo = Integer.parseInt( varNumberString );
541                    if ( varNo > maxVar ) {
542                        maxVar = varNo;
543                    }
544                    if ( varNo == 0 ) {
545                        String msg = "Error in call attribute ('" + callString
546                                     + "') of FunctionCall definition - $0 is not a valid variable "
547                                     + "identifier. Counting of variables starts with 1.";
548                        throw new XMLParsingException( msg );
549                    }
550                } catch ( NumberFormatException e ) {
551                    assert ( false );
552                }
553    
554                // find next '$' symbol
555                foundAt = callString.indexOf( '$', foundAt );
556            }
557            return maxVar;
558        }
559    
560        /**
561         * Parses the given "deegreewfs:FunctionParam" element.
562         * <p>
563         * Valid child elements:
564         * <ul>
565         * <li>deegreewfs:MappingField</li>
566         * <li>deegreewfs:ConstantContent</li>
567         * <li>deegreewfs:SpecialContent</li>
568         * </ul>
569         *
570         * @param element
571         *            "deegreewfs:FunctionParam" element
572         * @param table
573         * @return java representation of element
574         * @throws XMLParsingException
575         */
576        FunctionParam parseFunctionParam( Element element, String table )
577                                throws XMLParsingException {
578    
579            FunctionParam param = null;
580    
581            Element childElement = XMLTools.getFirstChildElement( element );
582            if ( childElement == null || !childElement.getNamespaceURI().equals( CommonNamespaces.DEEGREEWFS.toString() ) ) {
583                String msg = Messages.getMessage( "DATASTORE_PARSING_SQL_FUNCTION_CALL" );
584                throw new XMLParsingException( msg );
585            }
586    
587            if ( "MappingField".equals( childElement.getLocalName() ) ) {
588                // table relations
589                List<Node> relationElements = XMLTools.getNodes( element, "deegreewfs:Relation", nsContext );
590                TableRelation[] tablePath = new TableRelation[relationElements.size()];
591                String fromTable = table;
592                for ( int i = 0; i < tablePath.length; i++ ) {
593                    tablePath[i] = parseTableRelation( (Element) relationElements.get( i ), fromTable );
594                    fromTable = tablePath[i].getToTable();
595                }
596                // TODO do this a better way
597                String type = XMLTools.getRequiredNodeAsString( childElement, "@type", nsContext );
598                MappingField field;
599                if ( "GEOMETRY".equals( type ) ) {
600                    field = parseGeometryMappingField( childElement, null, fromTable );
601                } else {
602                    field = parseMappingField( childElement, null, fromTable );
603                }
604                param = new FieldContent( field, tablePath );
605            } else if ( "ConstantContent".equals( childElement.getLocalName() ) ) {
606                param = parseConstantContent( childElement );
607            } else if ( "SpecialContent".equals( childElement.getLocalName() ) ) {
608                param = parseSpecialContent( childElement );
609            } else {
610                String msg = Messages.getMessage( "DATASTORE_PARSING_SQL_FUNCTION_CALL" );
611                throw new XMLParsingException( msg );
612            }
613    
614            return param;
615        }
616    
617        /**
618         * Extracts the mapping information for a geometry property type from the given "xs:annotation" element.
619         *
620         * @param element
621         *            "xs:annotation" element
622         * @param propertyName
623         *            name of the property (local part is used as default field name if it is not specified explicitly in
624         *            the "MappingField" element)
625         * @param typeName
626         * @param type
627         * @param minOccurs
628         * @param maxOccurs
629         * @param isIdentityPart
630         * @param table
631         *            name of the table that is associated with the feature type that this property belongs to
632         * @return geometry property type with persistence information
633         * @throws XMLSchemaException
634         *             if a syntactic or semantic error is found
635         * @throws UnknownCRSException
636         */
637        MappedGeometryPropertyType parseMappedGeometryPropertyType( Element element, QualifiedName propertyName,
638                                                                    QualifiedName typeName, int type, int minOccurs,
639                                                                    int maxOccurs, boolean isIdentityPart, String table )
640                                throws XMLSchemaException, UnknownCRSException {
641    
642            MappedGeometryPropertyType pt = null;
643            try {
644                Element contentElement = (Element) XMLTools.getRequiredNode( element, "xs:appinfo/deegreewfs:Content",
645                                                                             nsContext );
646                // sanity check (common error)
647                Node typeNode = XMLTools.getNode( contentElement, "@type", nsContext );
648                if ( typeNode != null ) {
649                    throw new XMLParsingException( "Content element must not contain a type attribute." );
650                }
651    
652                URI srs = XMLTools.getNodeAsURI( element, "deegreewfs:SRS/text()", nsContext, this.defaultSRS );
653    
654                Element mfElement = (Element) XMLTools.getRequiredNode( contentElement, "deegreewfs:MappingField",
655                                                                        nsContext );
656                String defaultField = propertyName.getLocalName();
657                MappingGeometryField mappingField = parseGeometryMappingField( mfElement, defaultField, table );
658                List<Node> relationElements = XMLTools.getNodes( contentElement, "deegreewfs:Relation", nsContext );
659                TableRelation[] tableRelations = new TableRelation[relationElements.size()];
660                String fromTable = table;
661                for ( int i = 0; i < tableRelations.length; i++ ) {
662                    tableRelations[i] = parseTableRelation( (Element) relationElements.get( i ), fromTable );
663                    fromTable = tableRelations[i].getToTable();
664                }
665    
666                pt = new MappedGeometryPropertyType( propertyName, typeName, type, minOccurs, maxOccurs, isIdentityPart,
667                                                     srs, tableRelations, mappingField );
668            } catch ( XMLParsingException e ) {
669                throw new XMLSchemaException( "Error in definition of geometry property '" + propertyName + "': "
670                                              + e.getMessage() );
671            }
672            return pt;
673        }
674    
675        /**
676         * Extracts the mapping information for a feature property type from the given "xs:annotation" element.
677         *
678         * @param element
679         *            "xs:annotation" element
680         * @param propertyName
681         *            name of the property (local part is used as default field name if it is not specified explicitly in
682         *            the "MappingField" element)
683         * @param minOccurs
684         * @param maxOccurs
685         * @param isIdentityPart
686         * @param table
687         *            name of the table that is associated with the feature type that this property belongs to
688         * @param isReferenceType
689         *            true, if this property is of type "gml:ReferenceType", false otherwise
690         * @return feature property type with persistence information
691         * @throws XMLSchemaException
692         *             if a syntactic or semantic error is found
693         */
694        MappedFeaturePropertyType parseMappedFeaturePropertyType( Element element, QualifiedName propertyName,
695                                                                  int minOccurs, int maxOccurs, boolean isIdentityPart,
696                                                                  String table, boolean isReferenceType )
697                                throws XMLSchemaException {
698    
699            MappedFeaturePropertyType pt = null;
700            try {
701                Element contentElement = (Element) XMLTools.getRequiredNode( element, "xs:appinfo/deegreewfs:Content",
702                                                                             nsContext );
703    
704                // sanity check (common error)
705                Node mfNode = XMLTools.getNode( element, "deegreewfs:MappingField", nsContext );
706                if ( mfNode != null ) {
707                    throw new XMLParsingException( "Content element must not contain a MappingField element." );
708                }
709    
710                QualifiedName containedFT = parseQualifiedName( XMLTools.getRequiredNode( contentElement, "@type",
711                                                                                          nsContext ) );
712                MappedFeatureTypeReference containedFTRef = new MappedFeatureTypeReference( containedFT );
713    
714                List<Node> relationElements = XMLTools.getNodes( contentElement, "deegreewfs:Relation", nsContext );
715                TableRelation[] tableRelations = new TableRelation[relationElements.size()];
716                String fromTable = table;
717                for ( int i = 0; i < tableRelations.length; i++ ) {
718                    tableRelations[i] = parseTableRelation( (Element) relationElements.get( i ), fromTable );
719                    fromTable = tableRelations[i].getToTable();
720                }
721    
722                boolean allowExternalLinks = getNodeAsBoolean( contentElement, "@allowExternalLinks", nsContext, false );
723    
724                pt = new MappedFeaturePropertyType( propertyName, Types.FEATURE_PROPERTY_NAME, Types.FEATURE, minOccurs,
725                                                    maxOccurs, isIdentityPart, tableRelations, containedFTRef,
726                                                    isReferenceType, allowExternalLinks );
727            } catch ( XMLParsingException e ) {
728                throw new XMLSchemaException( "Error in definition of feature property '" + propertyName + "': "
729                                              + e.getMessage() );
730            }
731            return pt;
732        }
733    
734        /**
735         * Parses the given 'MappingField' element.
736         *
737         * @param element
738         *            'MappingField' element
739         * @param defaultField
740         *            if null, the element must have a 'field' attribute, otherwise the given value is used, if the element
741         *            misses a 'field' attribute
742         * @param defaultTable
743         *            if null, the element must have a 'table' attribute, otherwise the 'table' attribute must be left out
744         *            or match the given value
745         * @return class representation of 'MappingField' element
746         * @throws XMLParsingException
747         *             if a syntactic or semantic error is found
748         */
749        private MappingField parseMappingField( Element element, String defaultField, String defaultTable )
750                                throws XMLParsingException {
751    
752            MappingField mappingField = null;
753    
754            String field = null;
755            if ( defaultField == null ) {
756                field = XMLTools.getRequiredNodeAsString( element, "@field", nsContext );
757            } else {
758                field = XMLTools.getNodeAsString( element, "@field", nsContext, defaultField );
759            }
760    
761            String typeName = XMLTools.getRequiredNodeAsString( element, "@type", nsContext );
762            int typeCode = -1;
763            try {
764                typeCode = Types.getTypeCodeForSQLType( typeName );
765            } catch ( UnknownTypeException e ) {
766                throw new XMLParsingException( "Invalid field type: " + e.getMessage(), e );
767            }
768    
769            String table = null;
770            if ( defaultTable == null ) {
771                // if table is unspecified, this is resolved later (in MappedGMLSchema)
772                // TODO clean this up
773                table = XMLTools.getNodeAsString( element, "@table", nsContext, null );
774            } else {
775                table = XMLTools.getNodeAsString( element, "@table", nsContext, defaultTable );
776                if ( !table.equals( defaultTable ) ) {
777                    throw new XMLParsingException( "Specified 'table' attribute ('" + table
778                                                   + "') in 'MappingField' element is inconsistent; leave out or use '"
779                                                   + defaultTable + "' instead." );
780                }
781            }
782    
783            boolean auto = XMLTools.getNodeAsBoolean( element, "@auto", nsContext, false );
784            mappingField = new MappingField( table, field, typeCode, auto );
785    
786            return mappingField;
787        }
788    
789        /**
790         * Parses the given 'MappingField' element.
791         *
792         * @param element
793         *            'MappingField' element
794         * @param defaultField
795         *            if null, the element must have a 'field' attribute, otherwise the given value is used, if the element
796         *            misses a 'field' attribute
797         * @param defaultTable
798         *            if null, the element must have a 'table' attribute, otherwise the 'table' attribute must be left out
799         *            or match the given value
800         * @return class representation of 'MappingField' element
801         * @throws XMLParsingException
802         *             if a syntactic or semantic error is found
803         */
804        private MappingGeometryField parseGeometryMappingField( Element element, String defaultField, String defaultTable )
805                                throws XMLParsingException {
806    
807            MappingGeometryField mappingField = null;
808    
809            String field = null;
810            if ( defaultField == null ) {
811                field = XMLTools.getRequiredNodeAsString( element, "@field", nsContext );
812            } else {
813                field = XMLTools.getNodeAsString( element, "@field", nsContext, defaultField );
814            }
815    
816            String typeName = XMLTools.getRequiredNodeAsString( element, "@type", nsContext );
817            int typeCode = Types.OTHER;
818            if ( !( "GEOMETRY".equals( typeName ) ) ) {
819                try {
820                    typeCode = Types.getTypeCodeForSQLType( typeName );
821                } catch ( UnknownTypeException e ) {
822                    throw new XMLParsingException( "Invalid field type: " + e.getMessage(), e );
823                }
824            }
825    
826            String table = null;
827            if ( defaultTable == null ) {
828                // if table is unspecified, this is resolved later (in MappedGMLSchema)
829                // TODO clean this up
830                table = XMLTools.getNodeAsString( element, "@table", nsContext, null );
831            } else {
832                table = XMLTools.getNodeAsString( element, "@table", nsContext, defaultTable );
833                if ( !table.equals( defaultTable ) ) {
834                    String msg = "Specified 'table' attribute ('" + table
835                                 + "') in 'MappingField' element is inconsistent; leave out or use '" + defaultTable
836                                 + "' instead.";
837                    throw new XMLParsingException( msg );
838                }
839            }
840    
841            int internalSrs = XMLTools.getNodeAsInt( element, "@srs", nsContext, -1 );
842            mappingField = new MappingGeometryField( table, field, typeCode, internalSrs );
843            return mappingField;
844        }
845    
846        /**
847         * Parses the given 'gmlId' element.
848         *
849         * @param element
850         *            'gmlId' element
851         * @param table
852         *            the associated table of the FeatureType
853         * @return class representation of 'gmlId' element
854         * @throws XMLParsingException
855         *             if a syntactic or semantic error is found
856         */
857        private MappedGMLId parseGMLIdDefinition( Element element, String table )
858                                throws XMLParsingException {
859            String prefix = XMLTools.getNodeAsString( element, "@prefix", nsContext, "" );
860            String separator = XMLTools.getNodeAsString( element, "@separator", nsContext, "" );
861    
862            List<Node> mappingFieldElementList = XMLTools.getRequiredNodes( element, "deegreewfs:MappingField", nsContext );
863            MappingField[] mappingFields = new MappingField[mappingFieldElementList.size()];
864            for ( int i = 0; i < mappingFields.length; i++ ) {
865                Element mappingFieldElement = (Element) mappingFieldElementList.get( i );
866                mappingFields[i] = parseMappingField( mappingFieldElement,
867                                                      XMLTools.getRequiredNodeAsString( mappingFieldElement, "@field",
868                                                                                        nsContext ), table );
869            }
870    
871            IDPART_INFO idpart_info = IDPART_INFO.noIDInfo;
872            String identityPart = XMLTools.getNodeAsString( element, "deegreewfs:IdentityPart/text()", nsContext, null );
873            if ( identityPart != null ) {
874                if ( "false".equals( identityPart ) ) {
875                    idpart_info = IDPART_INFO.notIDPart;
876                } else {
877                    idpart_info = IDPART_INFO.isIDPart;
878                }
879            }
880    
881            IdGenerator idGenerator = null;
882            Element idGeneratorElement = (Element) XMLTools.getNode( element, "deegreewfs:IdGenerator", nsContext );
883            if ( idGeneratorElement != null ) {
884                idGenerator = parseGMLIdGenerator( idGeneratorElement );
885            } else {
886                idGenerator = IdGenerator.getInstance( IdGenerator.TYPE_UUID, new Properties() );
887            }
888            return new MappedGMLId( prefix, separator, mappingFields, idGenerator, idpart_info );
889        }
890    
891        /**
892         * Parses the given 'IdGenerator' element.
893         *
894         * @param element
895         *            'IdGenerator' element
896         * @return object representation of 'IdGenerator' element
897         * @throws XMLParsingException
898         *             if a syntactic or semantic error is found
899         */
900        private IdGenerator parseGMLIdGenerator( Element element )
901                                throws XMLParsingException {
902            String type = XMLTools.getRequiredNodeAsString( element, "@type", nsContext );
903            Properties params = new Properties();
904            List<Node> paramElementList = XMLTools.getNodes( element, "deegreewfs:param", nsContext );
905            Iterator<Node> iter = paramElementList.iterator();
906            while ( iter.hasNext() ) {
907                Element paramElement = (Element) iter.next();
908                String name = XMLTools.getRequiredNodeAsString( paramElement, "@name", nsContext );
909                String value = XMLTools.getRequiredNodeAsString( paramElement, "text()", nsContext );
910                params.setProperty( name, value );
911            }
912            IdGenerator idGenerator = IdGenerator.getInstance( type, params );
913            return idGenerator;
914        }
915    
916        private TableRelation parseTableRelation( Element element, String fromTable )
917                                throws XMLParsingException {
918            List<Node> fromMappingElements = XMLTools.getRequiredNodes( element, "deegreewfs:From/deegreewfs:MappingField",
919                                                                        nsContext );
920            List<Node> toMappingElements = XMLTools.getRequiredNodes( element, "deegreewfs:To/deegreewfs:MappingField",
921                                                                      nsContext );
922            if ( fromMappingElements.size() != toMappingElements.size() ) {
923                throw new XMLParsingException( "Error in 'Relation' element: number of 'MappingField' elements "
924                                               + "below 'From' and 'To' elements do not match." );
925            }
926            FK_INFO fkInfo = FK_INFO.noFKInfo;
927            boolean fromIsFK = XMLTools.getNodeAsBoolean( element, "deegreewfs:From/@fk", nsContext, false );
928            boolean toIsFK = XMLTools.getNodeAsBoolean( element, "deegreewfs:To/@fk", nsContext, false );
929            if ( fromIsFK && toIsFK ) {
930                throw new XMLParsingException( "Error in 'Relation' element: either 'To' or 'From' can "
931                                               + "have a 'fk' attribute with value 'true', but not both." );
932            }
933            if ( fromIsFK ) {
934                fkInfo = FK_INFO.fkIsFromField;
935            }
936            if ( toIsFK ) {
937                fkInfo = FK_INFO.fkIsToField;
938            }
939            MappingField[] fromMappingFields = new MappingField[fromMappingElements.size()];
940            MappingField[] toMappingFields = new MappingField[fromMappingFields.length];
941            for ( int i = 0; i < fromMappingFields.length; i++ ) {
942                fromMappingFields[i] = parseMappingField( (Element) fromMappingElements.get( i ), null, fromTable );
943                toMappingFields[i] = parseMappingField( (Element) toMappingElements.get( i ), null, null );
944            }
945    
946            // parse id generator
947            // TODO sanity checks
948            IdGenerator idGenerator = null;
949            if ( fromIsFK ) {
950                Element idGeneratorElement = (Element) XMLTools.getNode( element, "deegreewfs:To/deegreewfs:IdGenerator",
951                                                                         nsContext );
952                if ( idGeneratorElement != null ) {
953                    idGenerator = parseGMLIdGenerator( idGeneratorElement );
954                } else {
955                    idGenerator = IdGenerator.getInstance( IdGenerator.TYPE_UUID, new Properties() );
956                }
957            } else {
958                Element idGeneratorElement = (Element) XMLTools.getNode( element, "deegreewfs:From/deegreewfs:IdGenerator",
959                                                                         nsContext );
960                if ( idGeneratorElement != null ) {
961                    idGenerator = parseGMLIdGenerator( idGeneratorElement );
962                } else {
963                    idGenerator = IdGenerator.getInstance( IdGenerator.TYPE_UUID, new Properties() );
964                }
965            }
966    
967            return new TableRelation( fromMappingFields, toMappingFields, fkInfo, idGenerator );
968        }
969    
970        /**
971         * Returns the value of the "deegreewfs:visible" element.
972         *
973         * @param annotationElement
974         * @return -1 if it is not present, 0 if it is "false", 1 if it is "true"
975         * @throws XMLParsingException
976         */
977        public int parseVisible( Element annotationElement )
978                                throws XMLParsingException {
979            int visibleCode = -1;
980            String visible = XMLTools.getNodeAsString( annotationElement, "xs:appinfo/deegreewfs:visible/text()",
981                                                       nsContext, null );
982            if ( visible != null ) {
983                if ( "false".equals( visible ) ) {
984                    visibleCode = 0;
985                } else {
986                    visibleCode = 1;
987                }
988            }
989            return visibleCode;
990        }
991    
992        /**
993         * Parses the 'updatable' status of the given feature type annotation element.
994         *
995         * @param annotationElement
996         * @return true, if update transactions may be performed on the feature type, false otherwise
997         * @throws XMLParsingException
998         */
999        public boolean parseIsUpdatable( Element annotationElement )
1000                                throws XMLParsingException {
1001            return XMLTools.getNodeAsBoolean( annotationElement, "xs:appinfo/deegreewfs:transaction/@update", nsContext,
1002                                              false );
1003        }
1004    
1005        /**
1006         * Parses the 'deletable' status of the given feature type annotation element.
1007         *
1008         * @param annotationElement
1009         * @return true, if delete transactions may be performed on the feature type, false otherwise
1010         * @throws XMLParsingException
1011         */
1012        public boolean parseIsDeletable( Element annotationElement )
1013                                throws XMLParsingException {
1014            return XMLTools.getNodeAsBoolean( annotationElement, "xs:appinfo/deegreewfs:transaction/@delete", nsContext,
1015                                              false );
1016        }
1017    
1018        /**
1019         * Parses the 'insertable' status of the given feature type annotation element.
1020         *
1021         * @param annotationElement
1022         * @return true, if insert transactions may be performed on the feature type, false otherwise
1023         * @throws XMLParsingException
1024         */
1025        public boolean parseIsInsertable( Element annotationElement )
1026                                throws XMLParsingException {
1027            return XMLTools.getNodeAsBoolean( annotationElement, "xs:appinfo/deegreewfs:transaction/@insert", nsContext,
1028                                              false );
1029        }
1030    
1031        /**
1032         * Parses the 'isPseudoFeatureType' element of the given feature type annotation element.
1033         *
1034         * @param annotationElement
1035         * @return true, if feature type is a pseudo feature type, false otherwise
1036         * @throws XMLParsingException
1037         */
1038        public boolean parseIsPseudoFeatureType( Element annotationElement )
1039                                throws XMLParsingException {
1040            return XMLTools.getNodeAsBoolean( annotationElement, "xs:appinfo/deegreewfs:isPseudoFeatureType/text()",
1041                                              nsContext, false );
1042        }
1043    
1044        /**
1045         * Returns the value of the "deegreewfs:IdentityPart" element.
1046         *
1047         * @param annotationElement
1048         * @return -1 if it is not present, 0 if it is "false", 1 if it is "true"
1049         * @throws XMLParsingException
1050         */
1051        public int parseIdentityPart( Element annotationElement )
1052                                throws XMLParsingException {
1053            int identityCode = -1;
1054            String identityPart = XMLTools.getNodeAsString( annotationElement, "xs:appinfo/deegreewfs:IdentityPart/text()",
1055                                                            nsContext, null );
1056            if ( identityPart != null ) {
1057                if ( "false".equals( identityPart ) ) {
1058                    identityCode = 0;
1059                } else {
1060                    identityCode = 1;
1061                }
1062            }
1063            return identityCode;
1064        }
1065    
1066        /**
1067         * Returns the value of the "deegreewfs:DefaultSRS" element.
1068         *
1069         * @param annotationElement
1070         * @param defaultValue
1071         * @return default SRS of the feature type
1072         * @throws XMLParsingException
1073         */
1074        public URI parseDefaultSRS( Element annotationElement, URI defaultValue )
1075                                throws XMLParsingException {
1076            URI defaultSRS = XMLTools.getNodeAsURI( annotationElement, "xs:appinfo/deegreewfs:DefaultSRS/text()",
1077                                                    nsContext, defaultValue );
1078            return defaultSRS;
1079        }
1080    
1081        /**
1082         * Returns the values of the "deegreewfs:OtherSRS" elements.
1083         *
1084         * @param annotationElement
1085         * @return alternative SRS that may be used to query the feature type
1086         * @throws XMLParsingException
1087         */
1088        public URI[] parseOtherSRS( Element annotationElement )
1089                                throws XMLParsingException {
1090            URI[] otherSRS = XMLTools.getNodesAsURIs( annotationElement, "xs:appinfo/deegreewfs:OtherSRS/text()", nsContext );
1091            return otherSRS;
1092        }
1093    
1094        /**
1095         * @param annotationElement
1096         * @param table
1097         * @param schema
1098         * @return a list of default GML properties to include. The qualified name specified (if not null), after which
1099         *         property this one should be included.
1100         * @throws XMLParsingException
1101         */
1102        public LinkedList<Pair<PropertyType, QualifiedName>> parseGMLDefaultProps( Element annotationElement, String table,
1103                                                                                   MappedGMLSchema schema )
1104                                throws XMLParsingException {
1105            Element appinfo = getRequiredElement( annotationElement, XS_PREFIX + ":appinfo", nsContext );
1106    
1107            LinkedList<Pair<PropertyType, QualifiedName>> list = new LinkedList<Pair<PropertyType, QualifiedName>>();
1108    
1109            if ( appinfo == null ) {
1110                return list;
1111            }
1112    
1113            for ( Element e : getElements( appinfo, DEEGREEWFS_PREFIX + ":StandardGMLProps/" + XS_PREFIX + ":element",
1114                                           nsContext ) ) {
1115                try {
1116                    QualifiedName realName = getRequiredNodeAsQualifiedName( e, "@name", nsContext );
1117                    Pair<PropertyType, QualifiedName> p = new Pair<PropertyType, QualifiedName>();
1118                    p.first = schema.buildPropertyTypeRealName( parseElementDeclaration( e ), table, realName );
1119                    p.second = getNodeAsQualifiedName( e, "@insertAfter", nsContext, null );
1120                    list.add( p );
1121                } catch ( UnknownCRSException e1 ) {
1122                    throw new XMLParsingException( "Wrapped exception", e1 );
1123                }
1124            }
1125    
1126            return list;
1127        }
1128    }