an introduction to xml and web technologies schema languages anders møller & michael i....

An Introduction to XML and Web TechnologiesAn Introduction to XML and Web Technologies

Schema LanguagesSchema Languages

Anders Møller & Michael I. Schwartzbach

2006 Addison-Wesley

MessagesMessages

Thank you for your feedback! About lecture preparation: apologies! About exercise preparation:

2An Introduction to XML and Web Technologies

Please do the exercises before class!Please do the exercises before class!

(With apologies and thanks to those (few!) who do or try.)

ObjectivesObjectives

The purpose of using schemas The schema languages DTD and XML Schema

(and DSD2 and RELAX NG) Regular expressions – a commonly used

formalism in schema languages

So, why schemas?So, why schemas?

MotivationMotivation

We have designed our Recipe Markup Language ...but so far only informally described its syntax

How can we make tools that check that an XML document is a syntactically correct Recipe Markup Language document (and thus meaningful)?

Implementing a specialized validation tool for Recipe Markup Language is not the solution...

Recipe (1/2)Recipe (1/2)

<collection> <description>Recipes suggested by Jane Dow</description>

<recipe id="r117"> <title>Rhubarb Cobbler</title> <date>Wed, 14 Jun 95</date>

<preparation> <step> Combine all and use as cobbler, pie, or crisp. </step> </preparation>

Recipe (2/2)Recipe (2/2)

<comment> Rhubarb Cobbler made with bananas as the main sweetener. It was delicious. </comment>

<nutrition calories="170" fat="28%" carbohydrates="58%" protein="14%"/> <related ref="42">Garden Quiche is also yummy</related> </recipe></collection>

XML LanguagesXML Languages

XML language: a set of XML documents with some semantics

schema:a formal definition of the syntax of an XML language

schema language:a notation for writing schemas

ValidationValidation

instancedocument

schemaprocessor

schema

valid invalid

normalized instance document

errormessage

Why use Schemas?Why use Schemas?

Formal but human-readable descriptions

Data validation can be performed with existing schema processors

General RequirementsGeneral Requirements

Expressiveness

Efficiency

Comprehensibility

Interlude: regular expressionsInterlude: regular expressions

(Very briefly.)

ExamplesExamples

A regular expression describing integers:

0|-?(1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*

A regular expression describing the valid contents of table elements in XHTML:

caption? ( col* | colgroup* ) thead? tfoot? ( tbody+ | tr+ )

Regular ExpressionsRegular Expressions

Commonly used in schema languages to describe sequences of characters or elements

: an alphabet (typically Unicode characters or element names)

matches the string ? matches zero or one * matches zero or more ’s + matches one or more ’s matches any concatenation of an and a | matches the union of and

DTDDTD

(Simple and insufficient)

DTD – Document Type DefinitionDTD – Document Type Definition

Defined as a subset of the DTD formalism from SGML

Specified as an integral part of XML 1.0

A starting point for development of more expressive schema languages

Considers elements, attributes, and character data – processing instructions and comments are mostly ignored

RecipeML with DTD (1/2)RecipeML with DTD (1/2)

<!ELEMENT collection (description,recipe*)><!ELEMENT description (#PCDATA)><!ELEMENT recipe

(title,date,ingredient*,preparation,comment?, nutrition,related*)>

<!ATTLIST recipe id ID #IMPLIED><!ELEMENT title (#PCDATA)><!ELEMENT date (#PCDATA)><!ELEMENT ingredient (ingredient*,preparation)?><!ATTLIST ingredient name CDATA #REQUIRED amount CDATA #IMPLIED unit CDATA #IMPLIED>

<!ELEMENT preparation (step*)><!ELEMENT step (#PCDATA)><!ELEMENT comment (#PCDATA)><!ELEMENT nutrition EMPTY><!ATTLIST nutrition calories CDATA #REQUIRED carbohydrates CDATA #REQUIRED fat CDATA #REQUIRED protein CDATA #REQUIRED alcohol CDATA #IMPLIED><!ELEMENT related EMPTY><!ATTLIST related ref IDREF #REQUIRED>

Element DeclarationsElement Declarations

<!ELEMENT element-name content-model >

Content models: EMPTY ANY mixed content: (#PCDATA|e1|e2|...|en)* element content: regular expression over element names

(concatenation is written with “,”)

Example:<!ELEMENT table (caption?,(col*|colgroup*),thead?,tfoot?,(tbody+|tr+)) >

Exercise: DTD Element DescriptionExercise: DTD Element Description

(You have plenty of time)

Attribute-List DeclarationsAttribute-List Declarations

<!ATTLIST element-name attribute-definitions >

Each attribute definition consists of an attribute name an attribute type a default declaration

Example:<!ATTLIST input maxlength CDATA #IMPLIED tabindex CDATA #IMPLIED>

Attribute TypesAttribute Types

CDATA: any value enumeration: (s1|s2|...|sn) ID: must have unique value IDREF (/ IDREFS): must match some ID attribute(s) ...

Examples:<!ATTLIST p align (left|center|right|justify) #IMPLIED>

<!ATTLIST recipe id ID #IMPLIED><!ATTLIST related ref IDREF #IMPLIED>

Attribute Default DeclarationsAttribute Default Declarations

#REQUIRED #IMPLIED (= optional)

”value” (= optional, but default provided)

#FIXED ”value” (= required, must have this value)

Examples: <!ATTLIST form action CDATA #REQUIRED onsubmit CDATA #IMPLIED method (get|post) "get" enctype CDATA "application/x-www-form-urlencoded" >

<!ATTLIST html xmlns CDATA #FIXED "http://www.w3.org/1999/xhtml">

Exercise: DTD Attribute DescriptionExercise: DTD Attribute Description

(You have plenty of time)

Document Type DeclarationsDocument Type Declarations

Associates a DTD schema with the instance document

<?xml version="1.1"?><!DOCTYPE collection SYSTEM "http://www.brics.dk/ixwt/recipes.dtd"><collection>...</collection>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN” "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<!DOCTYPE collection [ ... ]>

Exercise: Add a doctype &Exercise: Add a doctype &validate your solution atvalidate your solution at

validator.w3.orgvalidator.w3.org

(Still plenty of time)

Entity Declarations (1/3)Entity Declarations (1/3)

Internal entity declarations – a simple macro mechanism

Example:• Schema:

• Input:

A gadget has a medium size head and a big gizmo subwidget.&copyrightnotice;

• Output:

Internal parameter entity declarations – apply to the DTD, not the instance document

Example:• Schema:

<!ENTITY % Shape "(rect|circle|poly|default)">

• <!ATTLIST area shape %Shape; "rect">

corresponds to

<!ATTLIST area shape (rect|circle|poly|default) "rect">

External parsed entity declarations – references to XML data in other filesExample:• <!ENTITY widgets

SYSTEM "http://www.brics.dk/ixwt/widgets.xml">

External unparsed entity declarations – references to non-XML dataExample:• <!ENTITY widget-image

SYSTEM "http://www.brics.dk/ixwt/widget.gif” NDATA gif >

• <!NOTATION gif SYSTEM "http://www.iana.org/assignments/media-types/image/gif">

• <!ATTLIST thing img ENTITY #REQUIRED>

not widely used!

Checking Validity with DTDChecking Validity with DTD

A DTD processor (also called a validating XML parser)

parses the input document (includes checking well-formedness)

checks the root element name for each element, checks its contents and

attributes checks uniqueness and referential constraints

(ID/IDREF(S) attributes)

Exercise: what didn’t we check?Exercise: what didn’t we check?

<!ELEMENT collection (description,recipe*)><!ELEMENT description (#PCDATA)><!ELEMENT recipe

(title,date,ingredient*,preparation,comment?, nutrition,related*)>

<!ATTLIST recipe id ID #IMPLIED><!ELEMENT title (#PCDATA)><!ELEMENT date (#PCDATA)><!ELEMENT ingredient (ingredient*,preparation)?><!ATTLIST ingredient name CDATA #REQUIRED amount CDATA #IMPLIED unit CDATA #IMPLIED>

<!ELEMENT preparation (step*)><!ELEMENT step (#PCDATA)><!ELEMENT comment (#PCDATA)><!ELEMENT nutrition EMPTY><!ATTLIST nutrition calories CDATA #REQUIRED carbohydrates CDATA #REQUIRED fat CDATA #REQUIRED protein CDATA #REQUIRED alcohol CDATA #IMPLIED><!ELEMENT related EMPTY><!ATTLIST related ref IDREF #REQUIRED>

Problems with the DTD descriptionProblems with the DTD description

calories should contain a non-negative number protein should contain a value on the form N% where

N is between 0 and 100; comment should be allowed to appear anywhere in the

contents of recipe unit should only be allowed in an elements where

amount is also present nested ingredient elements should only be allowed

when amount is absent

– our DTD schema permits in some cases too much and in other cases too little!

Ritter Sport Winners:Ritter Sport Winners:Morten & PerMorten & Per

Note: The Ritter Sport exercises should be within reach of everyone.

(Even if maybe they weren’t so far.)

XML SchemaXML Schema

(Complex and insufficient)

Requirements for XML SchemaRequirements for XML Schema

- W3C’s proposal for replacing DTD

Design principles: More expressive than DTD Use XML notation Self-describing Simplicity

Technical requirements: Namespace support User-defined datatypes Inheritance (OO-like) Evolution Embedded documentation ...

Example (1/3)Example (1/3)

<b:card xmlns:b="http://businesscard.org"> <b:name>John Doe</b:name> <b:title>CEO, Widget Inc.</b:title> <b:email>john.doe@widget.com</b:email> <b:phone>(202) 555-1414</b:phone> <b:logo b:uri="widget.gif"/></b:card>

Instance document:

Schema:

Connecting Schemas and InstancesConnecting Schemas and Instances

<b:card xmlns:b="http://businesscard.org“ xmlns:xsi="http://www.w3.org/2001/XMLSchema-

instance" xsi:schemaLocation="http://businesscard.org business_card.xsd"> <b:name>John Doe</b:name> <b:title>CEO, Widget Inc.</b:title> <b:email>john.doe@widget.com</b:email> <b:phone>(202) 555-1414</b:phone> <b:logo b:uri="widget.gif"/></b:card>

Types and DeclarationsTypes and Declarations

Simple type definition:defines a family of Unicode text strings

Complex type definition: defines a content and attribute model

Element declaration: associates an element name with a simple or complex type

Attribute declaration: associates an attribute name with a simple type

ELEMENT DECLARATIONSELEMENT DECLARATIONSATTRIBUTE DECLARATIONSATTRIBUTE DECLARATIONS

Element and Attribute DeclarationsElement and Attribute Declarations

Examples:

• <element name="serialnumber" type="nonNegativeInteger"/>

• <attribute name=”alcohol" type=”r:percentage"/>

SIMPLE TYPE DEFINITIONSSIMPLE TYPE DEFINITIONS

Simple Types (Datatypes) – PrimitiveSimple Types (Datatypes) – Primitive

string any Unicode string

boolean true, false, 1, 0decimal 3.1415float 6.02214199E23double 42E970dateTime 2004-09-26T16:29:00-

05:00time 16:29:00-05:00date 2004-09-26hexBinary 48656c6c6f0abase64Binary SGVsbG8KanyURI http://www.brics.dk/ixwt/QName rcp:recipe, recipe...

Exercise: Exercise: write an attribute declaration for the write an attribute declaration for the

“name” attribute of <club>. “name” attribute of <club>.

(Hint, “<attribute name=? type=? />”)

ExamplesExamples

<simpleType name="percentage"> <restriction base="string"> <pattern value="([0-9]|[1-9][0-9]|100)%"/> </restriction></simpleType> regular expression

“no” attribute of <club>. “no” attribute of <club>.

(Hint, “<attribute name=? type=’clubno’ />””<simpleType name=’clubno’> ...”)

Derivation of Simple Types – RestrictionDerivation of Simple Types – Restriction

Constraining facets:

• length• minLength• maxLength

• pattern• enumeration• whiteSpace

• maxInclusive• maxExclusive• minInclusive• minExclusive

• totalDigits• fractionDigits

Simple Type Derivation – EnumerationSimple Type Derivation – Enumeration

</restriction>

</simpleType>

“type” attribute of <club>. “type” attribute of <club>. (Values: iron, wood, putter)(Values: iron, wood, putter)

(Hint, “<attribute name=? type=’clubtype’ />””<simpleType name=’clubtype’> ...”)

Simple Type Derivation – UnionSimple Type Derivation – Union

Built-In Derived Simple TypesBuilt-In Derived Simple Types

• normalizedString• token• language• Name• NCName• ID• IDREF• integer

• nonNegativeInteger• unsignedLong• long• int• short• byte• ...

COMPLEX TYPE DEFINITIONSCOMPLEX TYPE DEFINITIONS

ExampleExample

<complexType name="order_type" mixed="true"> <choice> <element ref="n:address"/> <sequence> <element ref="n:email"

minOccurs="0" maxOccurs="unbounded"/> <element ref="n:phone"/> </sequence> </choice> <attribute ref=”n:id" use="required"/></complexType>

Exercise: Exercise: write an element declaration for <club>write an element declaration for <club>

(“<element name=? type=’clubelem’ />” and”<complexType name=’clubelem’> <attribute ...”</complexType>)

Complex Types with Complex ContentsComplex Types with Complex Contents

Content models as regular expressions:

• Element reference <element ref=”name”/>• Concatenation <sequence> ... </sequence>• Union <choice> ... </choice>• All <all> ... </all>• Element wildcard: <any namespace=”...”

processContents=”...”/> Attribute reference: <attribute ref=”...”/> Attribute wildcard: <anyAttribute namespace=”...”

processContents=”...”/>

Cardinalities: minOccurs, maxOccurs, useMixed content: mixed=”true”

Exercise:Exercise:Write an element declaration for Write an element declaration for

<clubs>

<club no="p" type="putter"

name="Extreme Precision Pro 1998"/>

</clubs>

Extended Example:Extended Example:Business CardsBusiness Cards

(click)

Thank you for listeningThank you for listening

Next week:

Beyond the Basics of XML Schema

Complex Types with Simple ContentComplex Types with Simple Content

Derivation with Complex ContentDerivation with Complex Content

Note: restriction is not the opposite of extension!

Global vs. Local DescriptionsGlobal vs. Local Descriptions

Global (toplevel) style:

Local (inlined) style:

inlined

Global vs. Local DescriptionsGlobal vs. Local Descriptions

Local type definitions are anonymous

Local element/attribute declarations can be overloaded – a simple form of context sensitivity (particularly useful for attributes!)

Only globally declared elements can be starting points for validation (e.g. roots)

Local definitions permit an alternative namespace semantics (explained later...)

Requirements to Complex TypesRequirements to Complex Types

Two element declarations that have the same name and appear in the same complex type must have identical types

• This requirement makes efficient implementation easier

all can only contain element (e.g. not sequence!)• so we cannot use all to solve the problem with comment in RecipeML

NamespacesNamespaces

Prefixes are also used in certain attribute values!

Unqualified Locals: • if enabled, the name of a locally declared element

or attribute in the instance document must have no namespace prefix (i.e. the empty namespace URI)

• such an attribute or element “belongs to” the element declared in the surrounding global definition

• always change the default behavior usingelementFormDefault="qualified"

Uniqueness, Keys, ReferencesUniqueness, Keys, References

unique: as key, but fields may be absent

in every widget, each part must have unique (manufacturer, productid)

in every widget, for each annotation,(manu, prod) must match a my_widget_key

only a “downward” subset of XPath is used

Other Features in XML SchemaOther Features in XML Schema

Groups Nil values Annotations Defaults and whitespace Modularization

– read the book chapter

RecipeML with XML Schema (1/5)RecipeML with XML Schema (1/5)

<element name="preparation"> <complexType> <sequence> <element name="step" type="string“ minOccurs="0“

maxOccurs="unbounded"/> </sequence> </complexType> </element>

</schema>

Problems with the XML Schema descriptionProblems with the XML Schema description

calories should contain a non-negative number protein should contain a value on the form N% where N

is between 0 and 100; comment should be allowed to appear

anywhere in the contents of recipe unit should only be allowed in an elements

where amount is also present nested ingredient elements should only be

allowed when amount is absent

– even XML Schema has insufficient expressiveness!

solved

Strengths of XML SchemaStrengths of XML Schema

Namespace support

Data types (built-in and derivation)

Modularization

Type derivation mechanism

SummarySummary

schema: formal description of the syntax of an XML language

DTD: simple schema language• elements, attributes, entities, ...

XML Schema: more advanced schema language• element/attribute declarations• simple types, complex types, type derivations• global vs. local descriptions• ...

Essential Online ResourcesEssential Online Resources

http://www.w3.org/TR/xml11/ http://www.w3.org/TR/xmlschema-1/ http://www.w3.org/TR/xmlschema-2/

an introduction to xml and web technologies schema languages anders møller & michael i....

Documents

anders møller hoare logic - computer science...

inspire - møller institute

a case study from denmark - irse.org 30032012... · a case...

langual™ 2012 the langual™ thesaurus 2012...norwich,...

berit møller scenarie og risikoanalyser

distributed systems 2006 web services (with material from...

michael i. schwartzbach copyright © 2000 brics, university...

design by thomas brinch møller ggv

jacob møller, kiloo

lars mØller · lars møller group and various big bands...

langualfood product indexer : tutorial · langualfood...

xsugar: dual syntax for xml languagestōkyō daigaku [ july...

compilation 2011 static type checking ian zerny michael i....

stateless model checking of event-driven applications ·...

compilation 2007 abstract syntax trees michael i....

the pointer assertion logic engine - cornell university ·...

compilation 2007 code generation michael i. schwartzbach...

an introduction to xml and web technologies xml...

an introduction to xml and web technologies the xpath...

reax -- a reactive programming language for multimodal...