xp new perspectives on xml, 2nd edition tutorial 4 1 tutorial 4 working with schemas

XP

New Perspectives on XML, 2nd EditionTutorial 4

1

TUTORIAL 4

WORKING WITH SCHEMAS

XP


2

SCHEMAS

• A schema is an XML document that defines the content and structure of one or more XML documents.

• The XML document containing the content is called the instance document.

XP


3

COMPARING SCHEMAS AND DTDS

This figure compares schemas and DTDs

XP


4

SCHEMA VOCABULARIES

• There is no single schema form. Several schema “vocabularies” have been developed in the XML language.

• Support for a particular schema depends on the XML parser being used for validation.

XP


5

SCHEMA VOCABULARIES

This figure shows a few schema vocabularies

XP


6

STARTING A SCHEMA FILE

• A schema is always placed in a separate XML document that is referenced by the instance document.

XPExample Schema

<?xml version="1.0"?>< xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="note"> <xs:complexType> <xs:sequence> <xs:element name="to" type="xs:string"/> <xs:element name="from" type="xs:string"/> <xs:element name="heading" type="xs:string"/> <xs:element name="body" type="xs:string"/> </xs:sequence> </xs:complexType>< /xs:element>

< /xs:schema>


7

XP


8

ELEMENTS AND ATTRIBUTES OF THE PATIENTS DOCUMENT

This figure shows the elements and attributes of the patients.xml document

See pages 147 and

148

XP


9

SCHEMA TYPES

• XML Schema recognize two categories of types:– Simple type contains only a single value

• Value of an attribute• Or the textual content of an element

– Complex type• Contains a structure

XP


10

SCHEMA TYPES

This figure shows types of elements

XP


11

SIMPLE TYPE ELEMENTS

• Use the following syntax to declare a simple type element in XML Schema:

<element name=“name” type =“type”/>

name = the name of the element in the instance documenttype = the data type of the element.

• Example:<xs:element name = “lastName” type = “xs:string” />

Unlike DTD, schema isan XML language

XP


12

UNDERSTANDING DATA TYPES

• XML Schema supports two data types

– A built-in data type is part of the XML Schema specifications and is available to all XML Schema authors.

– A user-derived data type is created by the XML Schema author for specific data values in the instance document.

XP


13

DECLARING AN ATTRIBUTE

• An attribute is another example of a simple type. The syntax to define an attribute is

<xs:attribute name=“name” type="type” default=“default” fixed=“fixed” />

name = the name of the attribute

type = the data type,

default = the attribute’s default value

fixed = a fixed value for the attribute

• For examle:

<xs:attribute name=“Gender” type=“xs:string” default=“female” />

optional

By convention, use xs for namespace for XML Schma namespace

XP


14

ASSOCIATING ATTRIBUTES AND ELEMENTS

• The basic structure for defining a complex type with XML Schema is

<xs:element name="name"><xs:complexType>

declarations</xs:complexType>

</xs:element>name = the name of the element declarations = schema commands specific to the type of

complex element being defined.

XP


ASSOCIATING ATTRIBUTES AND ELEMENTS

• Four complex type elements that usually appear in an instance document are the following:

– The element is an empty element and contains only attributes.

– The element contains textual content and attributes but no child elements.

– The element contains child elements but not attributes.

– The element contains both child elements and attributes. The following slides

describe each of these

XP


16

EMPTY ELEMENTS AND ATTRIBUTES

• The code to declare the attributes of an empty element is<xs:element name="name">

<xs:complexType>attributes

</xs:complexType></xs:element>

attributes = the set of declarations that define the attributes associated with the element

XPEMPTY ELEMENTS AND ATTRIBUTES

• For example:

<xs: element name=“subject”>

<xs:complexType>

<xs:attriubute name=“name” type=“xs:string” />

<xs:attriubute name=“age” type=“xs:string” />

</xs: complexType>

</xs:element>

• describes the following empty element:

<subject name=“Cynthia Dibbs” age=“62” />


17

XP


18

SIMPLE CONTENT AND ATTRIBUTES

• If an element is not empty and contains textual content (but no child elements), the structure of the complex type element is slightly different.


<xs:simpleContent><xs:extension base="type">

attributes</xs:extension>

</xs:simpleContent></xs:complexType>

</xs:element>

XPSIMPLE CONTENT AND ATTRIBUTES

• For example:

<xs:element name=“performance”>

<xs:complexType>

<xs:simpleContent>

<xs:extension base=“xs:string”>

<xs:attribute name=“scale” type=“xs:string”/>

</xs:extension>

</xs:simpleContent>

</xs:complexType>

</xs:element>

• defines

• <performance scale=“Karnofskyk”>0.81</performance>


19

Indicates text but no child

Extended to include an attribute

XP


20

SPECIFYING THE USE OF AN ATTRIBUTE

• An attribute may or may not be required with a particular element. To indicate whether an attribute is required, you add the use attribute to the element declaration or reference. The use attribute has the following values:– required—The attribute must always appear with the element– optional—(default) The use of the attribute is optional with the

element– prohibited—The attribute cannot be used with the element

• For example, the previous attribute declaration is modified as:<xs:attribute name=“scale” type=“xs:string” use=“required”/>

XP


21

REFERENCING AN ELEMENT OR ATTRIBUTE

• Rather than nesting the attribute declaration within the element, you can create a reference to it. The code to create a reference to an element or attribute declaration is

<xs:element ref="elemName" />

<xs:attribute ref="attName" />

where

elemName = the name used in an element declaration

attName = the name used in an attribute declaration

XPREFERENCING AN ELEMENT OR ATTRIBUTE

<xs:attribute name=“scale” type=“xs:string” />

<xs:element name=“performance”>

<xs:complexType>

<xs:simpleContent>

<xs:extension base = “xs:string>

<xs:attribute> ref=“scale” use=“required” />

</xs:extension>

</xs:simpleContent>

</xs:complexType>

</xs:element>


22

XP


23

WORKING WITH CHILD ELEMENTS

• Another kind of complex type element contains child elements, but no attributes. To define these child elements, use the code structure<xs:element name="name">

<xs:complexType><xs:compositor>

elements</xs:compositor>


whereelements =the list of simple type element declarations for each

child elementcompositor = defines how the child elements are organized.

XP


24

USING COMPOSITORS

• XML Schema supports the following compositors:

– sequence defines a specific order for the child elements

– choice allows any one of the child elements to appear in the instance document

– all allows any of the child elements to appear in any order in the instance document; however, they must appear either only once or not all.

XPUSING COMPOSITORS

<element name=“address”>

<xs:complexType>

<xs:sequence>

<xs:element name = “street” type = “xs:string”/>

<xs:element name = “city” type = “xs:string”/>

<xs:element name = “state” type = “xs:string”/>

</xs:sequence>

<xs:complexType>

</element>


25

Must be in sequence

XPUSING COMPOSITORS


26

<element name=“Family”>

<xs:complexType>

<xs:all>

<xs:element name = “Father” type = “xs:string”/>

<xs:element name = “Mother” type = “xs:string”/>

</xs:all>

<xs:complexType>

</element>Family may contain Father

and/or Mother in no particular order

XPSPECIFYING THE OCCURENCES OF AN ITEM

• <xs:element name=“patient” type=“xs:string” minOccurs=“1” maxOccurs=“3”/>


27

XP


28

WORKING WITH CHILD ELEMENTS AND ATTRIBUTES

• The code for a complex type element that contains both attributes and child elements is


<xs:compositor>elements

</xs:compositor></xs:complexType>

attributes</xs:element>

XPCHILD ELEMENTS AND ATTRIBUTES EXAMPLE

<xs:element name=“patient”>

<xs:complexType>

<xs:sequence>

<xs:element ref=“lastname”/>

<xs:element ref=“firstName”/>

</xs:sequence>

<xs:attribute ref=“patID use=“required”>

</xs:complexType>

<xs:element>


29

XP


30

SPECIFYING MIXED CONTENT

<Summary>Patient <Name>Cynthia Davis</Name> was enrolled inthe <Study>Tamoxifen Study</Study> on 8/15/2003.

</Summary>

can be declared in the schema file using the following complex type:

<element name="Summary"><complexType mixed="true">

<sequence><element name="Name" type="string"/><element name="Study" type="string"/>

</sequence></complexType>

</element>

element contains both text and child

elements

XP


31

APPLYING A SCHEMA

• To attach a schema to the document, you must do the following:

– Declare a namespace for XML Schema in the instance document.

– Indicate the location of the schema file.

• Example:

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xsi=SchemaLocation=“pschema.xsd”>

Commonly used for XML Schema

instances

Schema instance namespace

XP


32

APPLYING A SCHEMA

• Specifying a schema in an XML document – is treated only as a hint by validating parsers– ignored by some parsers

• Not allowed to prevent improper financial documents from being fraudulently submitted

• If there is no namespace for the contents of the instance document, add the following attribute to the root element:

xsi:noNamespaceSchemaLocation="schema"Schema instance

namespace

XPPause and breath


33

XP


34


• A primitive data type, also called a base type, is one of 19 fundamental data types not defined in terms of other types.

• A derived data type is a collection of 25 data types that the XML Schema developers created based on the 19 primitive types.

XP


35


This figure shows the 44 built-in data types

Page XML 168

Premitivetypes

DerivedTypes

Dates & times

XP


36


This figure shows a partial description of XML string data types

Page XML 169

XPUSING DATA TYPES

Examples:

<xs:attribute name=“patID” type=“xs:ID” />

<xs:attribute name=“onStudy” type=“xs:string” />

<xs:attribute name=“scale” type=“xs:string” />


37

XP


38


This figure shows a partial description of XML numeric data types

Page XML 170

XP


39


This figure shows a partial description of XML date and time data types

Page XML 171

XP


40

DERIVING NEW DATA TYPES

• Three components are involved in deriving new data types:– Value space: the set of values that correspond

to the data type.– Lexical space: the set of textual representations

of the value space.– Facets: the properties of the data type that

distinguish one data type from another.• Text string length, range of allowable values,

XP


41

USER DERIVED DATA

• New data types fall into three categories:– List: a list of values where each list is derived

from a base type.– Union: the combination of two or more data

types.– Restriction: a limit placed on the facet of a

base type.

XPLIST

• List data type is a list of values separated by white space

• To create a list data type:

<xs:simpleType name=wbcList”>

<xs:list itemType=xs:decimal” />

<xs:simpleType>

• To use the data type:

<xs:element name=“wbc” type=“wbcList” />

<wbe>15.1 15.8. 20.0 9.3 7.1 5.2 </wbc>


42

XP


43

DERIVING A RESTRICTED DATA TYPE

• The most common way to derive a new data type is to restrict the properties of a base type. XML Schema provides twelve constraining facets for this purpose.

XP


44

CONSTRAINING FACETS

This figure shows the 12 constraining facets

XPCONSTRAINING FACETS EXAMPLE

<xs:simpleType name=“ageType”>

<xs:restriction base=“xs:integer”>

<xs:minInclusive value = “21” />

</xs:restriction>

</xs:simpleType>


45

Constrains the data type to be greater than or equal to the value

XP


46

The Patterns Facet

• A pattern can be created with a formatted text string called a regular expression or regex.

• To apply a regular expression in a data type, you use the code

<xs:simpleType name="name">

<xs:restriction base="type">

<xs:pattern value="regex"/>

</xs:restriction>

</xs:simpleType>

• Where regex is a regular expression pattern.

XPRegular Expressions

• Figure 4-30 page 184 shows character types, for example

– \d a digit from 0 to 9

– \D non digit character

– Etc.

• Figure 4-31 page 185 shows character sets, for example

– [chars] Match any character in the chars list

– [a-z] Match any lower case letter

– [0-9] matach any digit form 0-9

– Etc.


47

XP


48

PATTERN QUANTIFIERS

This figure shows pattern quantifiers

XPEXAMPLE REGULAR EXPRESSIONS

• <xs:pattern value=“\d{3}” />

• <xs:pattern value=“[A-Z]*” />

• <xs:pattern value=“[A-Z]{0,10}*” /}

<xs:ximpleType name=“mrType”>

<sx:restrictiion base=“xs:ID”>

<xs:pattern value=“MR\d{3}-\d{3}-d2{2}” />

</xs:restriction>

<xs:simpleType>


49

XP


50

WORKING WITH NAMED TYPES

• Schema authors can create customized complex types. – Advantage: reuse the complex structure in several places in the document.

• For example:<xs:element name=“fullName">

<xs:complexType><xs:sequence>

<xs:element name="firstName" type="xs:string"/><xs:element name="lastName" type="xs:string" />

</xs:sequence></xs:complexType>

</xs:element>• Use

<xs:element name=“client” type=“fullName”/><xs:element name=“salesperson” type=“fullName”/>

XP


51

NAMED MODEL GROUPS

• A named model group is a collection, or group, of elements.

• Syntax<xs:group name="name">

elements

</xs:group>

• Where name is the name of the model group, and elements is a collection of element declarations

XPNAMED MODEL GROUPS EXAMPLE

• Definition<xs:group name=“fullName”>

<xs:sequence><xs:element name="firstName" type="xs:string"/><xs:element name="lastName" type="xs:string" />

</xs:sequence></xs:group>

• Use<xs:element name=“client">

<xs:complexType><xs:group ref=“fullName”/>>



52

XP


53

WORKING WITH NAMED ATTRIBUTE GROUPS

• Attributes can be grouped into collections called named attribute groups.

• This is particularly useful for attributes that you want to use with several different elements in a schema. The syntax for a named attribute group is

<xs:attributeGroup name="name">attributes

</xs:attributeGroup>• Where name is the name of the attribute group and

attributes is a collection of attributes assigned to the group.

XPWORKING WITH NAMED ATTRIBUTE GROUPS

• Example:

<xs:attributeGroup name=“DRInfo”>

<xs:attribute name=“DRID” type=“xs:string” use=“required” />

<xs:attribute name=“dept” type=“xs:string” use=“required” />

<xs:attributeGroup>

<xs:element name=“doctor” type=“deptData”/>

<xs:complexType name = “deptData”>

<xs:simplecontent>

<xs: extension base = “string”>

<xs:attributegroup ref=“DRIinfo”/>

</xs:extenson>

</xs:simplecontent>

</xs:complexType>


54

<doctor DRID=“DR251” dept=“Pediatrics”> curt Hurley<doctor>

XPSCOPE

• An item has global scope = it is a child of a root schema element

– Can be referenced and reused anywhere in the schema

• An item has local scope = it is nested within another element

– Can be referenced and reused only within the item in which it is declared


55

XPSTRUCTURING A SCHEMA

• Schemas can be structured in several ways:

• Flat catalog (also called salami slice)

– All declarations are made globally

• Russian doll

– Has only one global element

– Everything else is nested inside of that element

• Venetian Blind Design

– Similar to flat catalog, except

– Creates types and references within a single global element


56

XP


57

STRUCTURING A SCHEMA

• One schema design is a Flat Catalog Design.– Sometimes called salami slice design

• In this design, all element declarations are made globally.

• The structure of the instance document is created by referencing the global element declarations.

XP


58

FLAT CATALOG DESIGN

This figure shows a Flat Catalog design

Figure 4-36 page 192

XP


59

STRUCTURING A SCHEMA

• Schemas can be structured in a number of ways. One structure is called a Russian Doll design. This design involves sets of nested declarations.

• While this design makes it easy to associate the schema with the instance document, it can be confusing and difficult to maintain.

XP


60

RUSSIAN DOLL DESIGN

This figure shows a Russian Doll design


XP


61

VENETIAN BLIND DESIGN

• A Venetian blind design

• Compromise between flat catalogs and Russian dolls

– Element and attribute groups and named types are declared globally (and can be reused throughout the schema)

– Elements and attributes for the instance document are local and nested

XP


62

VENETIAN BLIND DESIGNFigure 4-38 page 194

XP


63

COMPARING SCHEMA DESIGNS

This figure compares the three schema designs


XP


64

PLACING A SCHEMA IN A NAMESPACE: TARGETING A

NAMESPACE

• To associate a schema with a namespace

– declare the namespace

prefix:xmlns="uri"

– make that namespace the target of the schema.

targetNamespace="uri"

• Where

prefix = prefix of the XML Schema namespace

uri = URI of the target namespace

XPPLACING A SCHEMA IN A NAMESPACE: TARGETING A

NAMESPACE

• Example (Figure 4-40):<xs:schema xmlns:xs=http://www.ww3.org/2001/XMLSchema

xmlns=“http:/uhosp.edu/patients/na”

targetNamespace=“http://uhosp.edu/patients/na>

<xs: element name=“patients”>

<xs:complexType>

<xs:sequence>

<xs:element name=“patient” type=“pType”

Minoccurs = “1” maxoccurs=“unbounded” />

</xs:sequence>

</xs:complexType>

</xs:element>

…


65

Declare the namespace

Make the new namespace the target

of the schema

XP


66

APPLYING A SCHEMA TO A DOCUMENT WITH A NAMESPACE

• To apply a schema to a document with a namespace, add the following attributes to the instance document’s root element:

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="uri schema"

• Where uri is the URI of the namespace and schema is the location and name of the schema file.

• All global elements and attributes from the schema must be qualified in the instance document.

XPAPPLYING A SCHEMA TO A DOCUMENT WITH A NAMESPACE

Example: <patients xmlns:xsi=http://www.W3.org/200/XMLSchema-instance

xmlns=“http://uhosp.edu/patients/ns

xsi:schemaLocation=http://uhosp.edu/patients/ns patvb.xsd>

<patient patID = “MR890-041-02” …

….

</patient>


67

XP


68

INCLUDING AND IMPORTING SCHEMAS

• To include a schema from the same namespace, add the following element as a child of the schema element:

<xs:include schemaLocation="schema" />

Where schema is the name and location of the schema file.

• To import a schema from a different namespace, use the syntax

<xs:import namespace="uri" schemaLocation="schema" />

• Where uri is the URI of the imported schema’s namespace and schema is the name and location of the schema file.

XP


69

REFERENCING OBJECTS FROM OTHER SCHEMAS

• Once a schema is imported, any objects it contains with global scope can be referenced

• To reference an object from an imported schema, you must declare the namespace of the imported schema in the schema element

• You can then reference the object using the ref attribute or the type attribute for customized simple and complex types

XPAssignment: Tutorial 4 Case Problem 1

• Perform the tasks listed on pages 212 and 213

• Create a CSS for the resulting jw.xml

• Post your work, including the CSS on your web site.

• End an e-mail with the subject: Tutorial 4 Case Problem 1 by <your name> to [email protected] by Wednesday 11:50 May 1


70

xp new perspectives on xml, 2nd edition tutorial 4 1 tutorial 4 working with schemas

Documents