| ### Showing:
Annotations
Attributes
Diagrams
Facets
Instances
Model
Properties

Imported schema eml-constraint.xsd

Namespace | https://eml.ecoinformatics.org/constraint-2.2.0
Annotations |
    '$RCSfile: eml-constraint.xsd,v $'
           Copyright: 1997-2002 Regents of the University of California,
                                University of New Mexico, and
                                Arizona State University
            Sponsors: National Center for Ecological Analysis and Synthesis and
                      Partnership for Interdisciplinary Studies of Coastal Oceans,
                         University of California Santa Barbara
                      Long-Term Ecological Research Network Office,
                         University of New Mexico
                      Center for Environmental Studies, Arizona State University
       Other funding: National Science Foundation (see README for details)
                      The David and Lucile Packard Foundation
         For Details: http://knb.ecoinformatics.org/

            '$Author: obrien $'
              '$Date: 2009-02-25 23:51:54 $'
          '$Revision: 1.53 $'

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    moduleName: eml-constraint

    moduleDescription:

                The eml-constraint module - Relationships among and within
                dataset entities

    recommendedUsage: All datasets where there are logical constraints
            between entities

    standAlone: no
Properties |
attribute form default | unqualified
element form default | unqualified

Element ConstraintType / primaryKey

Namespace | No namespace
Annotations |
    tooltip: Primary Key

    summary: The primary key in the entity

    description: The primaryKey element declares the primary key in
                the entity to which the defined constraint
                pertains.

    example: date

    example: site
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , key
Children | constraintDescription, constraintName, key
Instance |
    <primaryKey>
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <key>{1,1}</key>
    </primaryKey>

Element ConstraintBaseGroup / constraintName

Namespace | No namespace
Annotations |
    tooltip: Name of the constraint

    summary: A meaningfull name of the constraint.

    description: The constraintName element is a name which
                represents a human readable and meaningful name for the
                constraint.

    example: PrimaryKey_birdSurvey
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ConstraintBaseGroup / constraintDescription

Namespace | No namespace
Annotations |
    tooltip: Description of the constraint

    summary: Descibes the purpose of the constraint.

    description: The constraintDescription element describes the
                nature of the constraint. It might be a description of a check
                condition, or a statement about the composition of a primary key or
                the nature of the relationship between two database tables or two
                ascii files.

    example: 1.Must be greater than 0 but less than 100 2. "The
                primary key of the table BIRD_SURVEY is composed of two
                attributes:speciesCode and observationDate 3. The species name
                associated with the species code in survey.txt can be found in the
                file speciesList.txt
Diagram |
Properties |
minOccurs | 0

Element ConstraintType / primaryKey / key

Namespace | No namespace
Annotations |
    tooltip: Key

    summary: The set of attributes to which this constraint
                      applies.

    description: The key element defines the set of attributes
                      to which this constraint applies. For a primary key or a
                      unique key, the set of attributes must be identifying. For a
                      foreign key, the set of attributes must match an identifying
                      key in the referenced entity. For a 'not null' constraint, the
                      key indicates the attribute which should not be
                      null.

    example: site

    example: plot
Diagram |
Properties |
content | complex
Model | attributeReference+
Children | attributeReference
Instance |
    <key>
      <attributeReference>{1,unbounded}</attributeReference>
    </key>

Element ConstraintType / primaryKey / key / attributeReference

Namespace | No namespace
Annotations |
    tooltip: Attribute Reference

    summary: The identifier of an attribute found
                            in the identified entity

    description: The attributeReference element is the
                            identifier of an attribute that can be found in the
                            identified entity. This id will be unique within an
                            entity and specifies that the attribute participates
                            in the key that is being defined.

    example: site
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
maxOccurs | unbounded
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ConstraintType / uniqueKey

Namespace | No namespace
Annotations |
    tooltip: Unique Key

    summary: A unique key in the entity

    description: The uniqueKey element represents a unique key
                within the referenced entity. This is different from a primary key
                in that it does not form any implicit foreign key relationships to
                other entities, however it is required to be unique within the
                entity.

    example: date
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , key
Children | constraintDescription, constraintName, key
Instance |
    <uniqueKey>
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <key>{1,1}</key>
    </uniqueKey>

Element ConstraintType / uniqueKey / key

Namespace | No namespace
Annotations |
    tooltip: Key

    summary: The set of attributes to which this constraint
                      applies.

    description: The key element defines the set of attributes
                      to which this constraint applies. For a primary key or a
                      unique key, the set of attributes must be identifying. For a
                      foreign key, the set of attributes must match an identifying
                      key in the referenced entity. For a 'not null' constraint, the
                      key indicates the attribute which should not be
                      null.

    example: date, site, plot
Diagram |
Properties |
content | complex
Model | attributeReference+
Children | attributeReference
Instance |
    <key>
      <attributeReference>{1,unbounded}</attributeReference>
    </key>

Element ConstraintType / uniqueKey / key / attributeReference

Namespace | No namespace
Annotations |
    tooltip: Attribute Reference

    summary: The identifier of an attribute found
                            in the identified entity

    description: The attributeReference element is the
                            identifier of an attribute that can be found in the
                            identified entity. This id will be unique within an
                            entity and specifies that the attribute participates
                            in the key that is being defined.

    example: site
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
maxOccurs | unbounded
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ConstraintType / checkConstraint

Namespace | No namespace
Annotations |
    tooltip: Check Constraint

    summary: A constraint which checks a conditional clause
                within an entity.

    description: The checkConstraint element defines a constraint
                which checks a conditional clause within an
                entity.

    example: if site>1 then plot>10
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , checkCondition
Children | checkCondition, constraintDescription, constraintName
Instance |
    <checkConstraint language="">
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <checkCondition>{1,1}</checkCondition>
    </checkConstraint>
Attributes |
QName | Type | Use | Annotation
--- | --- | --- | ---
language | xs:string | optional |
    tooltip: Language

    summary: The language that the is used to express or
                    implement the check constraint.

    description: The language element declares the language
                    that is used to implement the check constraint.  This is
                    typically the name and version of a programming language such as
                    Java, C, Perl, Basic, or other.  Sometime it is the name and
                    version of a scriptable analysis system such as SAS, Matlab, R,
                    or SPlus.

    example: Perl 5.6.1

Element ConstraintType / checkConstraint / checkCondition

Namespace | No namespace
Annotations |
    tooltip: Check Condition

    summary: An SQL statement or other language
                      implementation of the condition for a check
                      constraint.

    description: The checkCondition element defines an SQL
                      statement or other language implementation of the condition
                      for a check constraint.  Generally this provides a means for
                      constraining the values within and among
                      entities.

    example: (year > 1900 and year <
                      1990)
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ConstraintType / foreignKey

Namespace | No namespace
Annotations |
    tooltip: Foreign Key

    summary: A foreign key relationship among entities

    description: The foreignKey element defines a foreign key
                relationship among entities which relates this entity to another's
                primary key.
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , key , entityReference , relationshipType{0,1} , cardinality{0,1}
Children | cardinality, constraintDescription, constraintName, entityReference, key, relationshipType
Instance |
    <foreignKey>
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <key>{1,1}</key>
      <entityReference>{1,1}</entityReference>
      <relationshipType>{0,1}</relationshipType>
      <cardinality>{0,1}</cardinality>
    </foreignKey>

Element ForeignKeyGroup / key

Namespace | No namespace
Annotations |
    tooltip: Key

    summary: The set of attributes to which this constraint
                applies.

    description: The key element defines the set of attributes to
                which this constraint applies. For a primary key or a unique key,
                the set of attributes must be identifying. For a foreign key, the
                set of attributes must match an identifying key in the referenced
                entity. For a 'not null' constraint, the key indicates the attribute
                which should not be null.
Diagram |
Properties |
content | complex
Model | attributeReference+
Children | attributeReference
Instance |
    <key>
      <attributeReference>{1,unbounded}</attributeReference>
    </key>

Element ForeignKeyGroup / key / attributeReference

Namespace | No namespace
Annotations |
    tooltip: Attribute Reference

    summary: The identifier of an attribute found
                      in the identified entity

    description: The attributeReference element is the
                      identifier of an attribute that can be found in the
                      identified entity. This id will be unique within an
                      entity and specifies that the attribute participates
                      in the key that is being defined.

    example: site
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
maxOccurs | unbounded
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ForeignKeyGroup / entityReference

Namespace | No namespace
Annotations |
    tooltip: Referenced Entity ID

    summary: The id of the parent-entity in a foreign key
                constraint.

    description: The entityReference element contains the id of the
                entity to which a foreign key refers, otherwise known as the
                parent-entity or parent-table. This should be an identifier that
                matches one of the "identifier" elements for an
                entity.

    example: knb.79.4
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ForeignKeyGroup / relationshipType

Namespace | No namespace
Annotations |
    tooltip: Relationship type: Identifying or
                non-identifying

    summary: Relationship type: Identifying or
                non-identifying

    description: The relationshipType element defines identifying
                relationships that propagate from the parent entity's primary key to
                the child's primary key. Non-identifying relationships propagate the
                parent's primary key as a non-key attribute of the child
                entity.

    example: relationshipType code
Diagram |
Type | restriction of xs:string
Properties |
content | simple
minOccurs | 0
Facets |
enumeration | identifying |
enumeration | non-identifying |

Element ForeignKeyGroup / cardinality

Namespace | No namespace
Annotations |
    tooltip: Cardinality of the relationship between two
                entities.

    summary: Cardinality of the relationship between a parent
                entity and a child entity.

    description: The cardinality element represents a statement of
                the relationship between parent and child entities. Cardinality is
                expressed as the ratio of related parent and child
                entities. Cardinality 1 to N is a specific form of cardinality in
                which zero or one parent records are related to a specified number
                of child records. The cardinality ratio for the parent entity
                depends on whether the "existence" is mandatory (one or more) or
                optional (zero to ...).

    example: One to many

    example: One to 10

    example: Zero or One to Many
Diagram |
Properties |
content | complex
minOccurs | 0
Model | parentOccurences , childOccurences
Children | childOccurences, parentOccurences
Instance |
    <cardinality>
      <parentOccurences>{1,1}</parentOccurences>
      <childOccurences>{1,1}</childOccurences>
    </cardinality>

Element ForeignKeyGroup / cardinality / parentOccurences

Namespace | No namespace
Annotations |
    tooltip: Parent portion of a 1 to exactly N
                      cardinality

    summary: Parent portion of a 1 to exactly N cardinality.
                      May have a value of either 0 or 1.

    description: The parentOccurences element describes the
                      Parent portion of a 1 to exactly N cardinality. May have a
                      value of either 0 or 1. Value of 0 implies that the
                      "existence" of a child record is optional.  Value of 1 implies
                      that the "existence" of a child record is
                      mandatory.

    example: One to 10, Zero or One to Many
Diagram |
Type | restriction of xs:integer
Properties |
content | simple
Facets |
enumeration | 0 |
enumeration | 1 |

Element ForeignKeyGroup / cardinality / childOccurences

Namespace | No namespace
Annotations |
    tooltip: Child portion of the cardinality
                      expression

    summary: Child portion of a cardinality expression
                      Allowed values are positive integers including zero or the
                      string value "many".

    description: The childOccurences element describes the
                      child portion of a cardinality expression Allowed values are
                      positive integers including zero or the string value
                      "many"

    example: 2, 15, many
Diagram |
Type | CardinalityChildOccurancesType
Properties |
content | simple

Element ConstraintType / joinCondition

Namespace | No namespace
Annotations |
    tooltip: Join Condition

    summary: A non primary/foreign key join

    description: The joinCondition element describes any join of two
                tables that is not done with a primary/foreign key
                relationship.

    example: JOIN code
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , key , entityReference , relationshipType{0,1} , cardinality{0,1} , referencedKey
Children | cardinality, constraintDescription, constraintName, entityReference, key, referencedKey, relationshipType
Instance |
    <joinCondition>
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <key>{1,1}</key>
      <entityReference>{1,1}</entityReference>
      <relationshipType>{0,1}</relationshipType>
      <cardinality>{0,1}</cardinality>
      <referencedKey>{1,1}</referencedKey>
    </joinCondition>

Element ConstraintType / joinCondition / referencedKey

Namespace | No namespace
Annotations |
    tooltip: Key

    summary: The set of attributes to which a foreign key
                      constraint refers.

    description: The referencedKey element defines set of
                      attributes to which a foreign key constraint refers. If the
                      key refers to the primary key in the referenced entity, then
                      the "referencedKey" is optional.  For a foreign key, the set
                      of attributes must match an identifying key in the referenced
                      entity.

    example: site, plot
Diagram |
Properties |
content | complex
Model | attributeReference+
Children | attributeReference
Instance |
    <referencedKey>
      <attributeReference>{1,unbounded}</attributeReference>
    </referencedKey>

Element ConstraintType / joinCondition / referencedKey / attributeReference

Namespace | No namespace
Annotations |
    tooltip: Attribute Reference

    summary: The identifier of an attribute found
                            in the identified entity

    description: The attributeReference element is the
                            identifier of an attribute that can be found in the
                            identified entity. This id will be unique within an
                            entity and specifies that the attribute participates
                            in the key that is being defined.

    example: site
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
maxOccurs | unbounded
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Element ConstraintType / notNullConstraint

Namespace | No namespace
Annotations |
    tooltip: Not Null Constraint

    summary: A constraint that indicates that no null values
                should be present for an attribute.

    description: The notNullConstraint element defines a constraint
                that indicates that no null values should be present for an
                attribute in this entity.
Diagram |
Properties |
content | complex
Model | constraintName , constraintDescription{0,1} , key
Children | constraintDescription, constraintName, key
Instance |
    <notNullConstraint>
      <constraintName>{1,1}</constraintName>
      <constraintDescription>{0,1}</constraintDescription>
      <key>{1,1}</key>
    </notNullConstraint>

Element ConstraintType / notNullConstraint / key

Namespace | No namespace
Annotations |
    tooltip: Key

    summary: The set of attributes to which this constraint
                      applies.

    description: The key element defines the set of attributes
                      to which this constraint applies. For a primary key or a
                      unique key, the set of attributes must be identifying. For a
                      foreign key, the set of attributes must match an identifying
                      key in the referenced entity. For a 'not null' constraint, the
                      key indicates the attribute which should not be
                      null.
Diagram |
Properties |
content | complex
Model | attributeReference+
Children | attributeReference
Instance |
    <key>
      <attributeReference>{1,unbounded}</attributeReference>
    </key>

Element ConstraintType / notNullConstraint / key / attributeReference

Namespace | No namespace
Annotations |
    tooltip: Attribute Reference

    summary: The identifier of an attribute found
                            in the identified entity

    description: The attributeReference element is the
                            identifier of an attribute that can be found in the
                            identified entity. This id will be unique within an
                            entity and specifies that the attribute participates
                            in the key that is being defined.

    example: site
Diagram |
Type | NonEmptyStringType
Properties |
content | simple
maxOccurs | unbounded
Facets |
minLength | 1 |
pattern | [\s]*[\S][\s\S]* |

Complex Type ConstraintType

Namespace | https://eml.ecoinformatics.org/constraint-2.2.0
Annotations |
    tooltip: Relational integrity constraint descriptors

    summary: Describes the relational integrity constraints of a
            relational database.

    description: The ConstraintType type describes the relational
            integrity constraints of a relational database. This includes primary
            keys, foreign keys, unique keys, etc. When an eml-constraint module is
            created, it should be linked into a dataset using the "triple" element,
            and all of the entities that are referenced in the constraints should be
            accessible within that same package.
Diagram |
Model | primaryKey | uniqueKey | checkConstraint | foreignKey | joinCondition | notNullConstraint
Children | checkConstraint, foreignKey, joinCondition, notNullConstraint, primaryKey, uniqueKey
Attributes |
QName | Type | Default | Use |
--- | --- | --- | --- | ---
id | IDType |  | optional |
scope | ScopeType | document | optional |
system | SystemType |  | optional |

Simple Type CardinalityChildOccurancesType

Namespace | https://eml.ecoinformatics.org/constraint-2.2.0
Annotations |
    tooltip: Child portion of a cardinality expression

    summary: Child portion of a cardinality expression Allowed values
            are positive integers including zero or the string value
            "many".

    description: The CardinalityChildOccurancesType element defines the
            child portion of a cardinality expression.  Allowed values are positive
            integers including zero or the string value "many".

    example: 0,1, 2, 15,many
Diagram |
Type | union of(xs:integer, restriction of xs:string)

Attribute ConstraintType / checkConstraint / @language

Namespace | No namespace
Annotations |
    tooltip: Language

    summary: The language that the is used to express or
                    implement the check constraint.

    description: The language element declares the language
                    that is used to implement the check constraint.  This is
                    typically the name and version of a programming language such as
                    Java, C, Perl, Basic, or other.  Sometime it is the name and
                    version of a scriptable analysis system such as SAS, Matlab, R,
                    or SPlus.

    example: Perl 5.6.1
Type | xs:string
Properties |
use | optional

Attribute ConstraintType / @id

Namespace | No namespace
Type | IDType
Properties |
use | optional

Attribute ConstraintType / @system

Namespace | No namespace
Type | SystemType
Properties |
use | optional

Attribute ConstraintType / @scope

Namespace | No namespace
Type | ScopeType
Properties |
use | optional
default | document
Facets |
enumeration | system |
enumeration | document |

Element Group ConstraintBaseGroup

Namespace | https://eml.ecoinformatics.org/constraint-2.2.0
Diagram |
Model | constraintName , constraintDescription{0,1}
Children | constraintDescription, constraintName

Element Group ForeignKeyGroup

Namespace | https://eml.ecoinformatics.org/constraint-2.2.0
Diagram |
Model | constraintName , constraintDescription{0,1} , key , entityReference , relationshipType{0,1} , cardinality{0,1}
Children | cardinality, constraintDescription, constraintName, entityReference, key, relationshipType