Sams Teach Yourself XML in 21 Days

Recommended Book

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

Recommended Book

Recommended Book 

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

Valid Documents

Besides being well-formed, XML documents may also be valid. A valid document must conform to a number of syntax rules. There are two ways to specify the syntax of XML documents[md]by using DTDs and XML schemas, each of which has its own syntax.

To declare a DTD, you use the <!DOCTYPE> element. That DTD can either be internal to the XML document (in which case you set the XML declaration's standalone attribute to "yes"), external to the XML document (in which case you give the DTD's URI and set the XML declaration's standalone attribute to "no"), or a combination of the two.

You can use <!ELEMENT> elements to declare XML elements in a DTD. When we use <!ELEMENT>, the syntax for elements is <!ELEMENT name content_model >. There are also various content models possible when declaring an element. You can use the content model ANY to allow any content and to turn off syntax checking, and we can use EMPTY to declare an empty element.

You can list possible child elements of an element this way:

<!ELEMENT document (client)>

This allows a <document> element to contain a <client> element. In addition, you can list the child elements that an element can contain like this:

<!ELEMENT client (name, contractDate, contracts)>

And you can specify that an element contains parsed character data by using #PCDATA.

In the DTD syntax, you can use the symbols + (one or more), * (zero or more), ? (one or none), and | (choices) to work with multiple child elements. And you can also use these symbols in sequences to specify exactly what child elements, or combinations of child elements, an element can contain.

In Part I you also saw that you declare attributes in a DTD by using an <!ATTLIST> element and that you can assign default values to attributes when you declare them. When you declare an attribute, you can assign an explicit default value enclosed in quotation marks, use #IMPLIED to make the attribute optional, use #FIXED to give it a fixed value, or use #REQUIRED to make an attribute required.

And you've also seen in Part I that you can declare the type of an attribute in an <!ATTLIST> element. The allowed types are CDATA, ENTITY, ENTITIES, an enumeration, an ID value, an IDREF value, IDREFS, NMTOKEN, NMTOKENS, and NOTATION. Here's what a DTD for your sample document might look like:

<?xml version = "1.0" encoding="UTF-8" standalone="yes"?>
<!DOCTYPE document [

   <!ELEMENT document (client)*>

   <!ELEMENT client (name, contractDate, contracts)>

   <!ELEMENT name (lastname, firstname)>

   <!ELEMENT lastname (#PCDATA)>

   <!ELEMENT firstname (#PCDATA)>

   <!ELEMENT contractDate (#PCDATA)>

   <!ELEMENT contracts (contract)*>

   <!ELEMENT contract (app, id, fee)>

   <!ELEMENT app (#PCDATA)>

   <!ELEMENT id (#PCDATA)>

   <!ELEMENT fee (#PCDATA)>

   <!ATTLIST liaison CDATA #IMPLIED>

   ]>
<document>
    <liaison="no">
        <name>
            <lastname>Kirk</lastname>
            <firstname>James</firstname>
        </name>
        <contractDate>September 5, 2092</contractDate>
        <contracts>
            <contract>
                <app>Comm</app>
                <id>111</id>
                <fee>$111.00</fee>
            </contract>
            <contract>
                <app>Accounting</app>
                <id>222</id>
                <fee>$989.00</fee>
            </contract>
        </contracts>
    </client>
    <liaison="yes">
        <name>
            <lastname>McCoy</lastname>
            <firstname>Leonard</firstname>
        </name>
        <contractDate>September 7, 2092</contractDate>
        <contracts>
            <contract>
                <app>Stocker</app>
                <id>333</id>
                <fee>$2995.00</fee>
            </contract>
            <contract>
                <app>Dialer</app>
                <id>444</id>
                <fee>$200.00</fee>
            </contract>
        </contracts>
    </client>
</document>

In Part I you also got an introduction to creating XML schemas. You saw that you start an XML schema with an XML declaration and an <xsd:schema> element, and in this element, you declare a namespace prefix such as xsd, which is assigned the URI setting "http://www.w3.org/2001/XMLSchema".

To declare elements and attributes in an XML document using an XML schema, you can use the XML schema elements <xsd:element> and <xsd:attribute>. Both <xsd:element> and <xsd:attribute> support an attribute named type, which lets you specify an element's or attribute's type.

There are two main types you can use: simple types and complex types. Simple types cannot enclose any child elements or have any attributes, but complex types can. As you've seen, elements can be declared by using simple or complex types, but attributes can only be declared by using simple types.

There are a number of simple types built into the XML schema specification, including xsd:string for strings, xsd:int for integers, and xsd:date for dates. You can also create your own simple types by using <xsd:simpleType>.

You can create complex types by using <xsd:complexType>, which may enclose the declarations of child elements. You saw on Day 6 that enclosing those child elements in an <xsd:sequence> element creates an element sequence and that the elements declared in sequence must appear in that sequence in the XML document.

You also saw that the <xsd:element> element has a minOccurs attribute to indicate the minimum number of times an element may appear at the location where it has been declared, and a maxOccurs attribute to set the maximum number of times it may occur. In addition, you saw that you can use the fixed and default attributes to specify whether an element has a fixed or default value.

To review how XML schemas work, let's take a look at an XML document that holds data about a property owner who wants to sell his properties:

<?xml version="1.0" encoding="UTF-8"?>
<document documentDate="2005-12-02">
    <evaluation>Wants to sell soon.</evaluation>
    <prospect>
        <name>Ralph Kramden</name>
        <location>311 Chauncey Street</location>
        <city>New York</city>
        <state>NY</state>
    </prospect>
    <properties>
        <house listingNumber="111 111 111">
            <address>19 Oak Place</address>
            <sellingPrice>200000</sellingPrice>
            <listingPeriod>3</listingPeriod>
        </house>
        <house listingNumber="222 222 222">
            <address>23 Maple Street</address>
            <sellingPrice>180000</sellingPrice>
            <listingPeriod>3</listingPeriod>
        </house>
        <house listingNumber="333 333 333">
            <address>77 Chestnut Drive</address>
            <sellingPrice>160000</sellingPrice>
            <listingPeriod>6</listingPeriod>
        </house>
        <house listingNumber="444 4444 444">
            <address>677 Pine Place</address>
            <sellingPrice>220000</sellingPrice>
            <listingPeriod>6</listingPeriod>
        </house>
    </properties>
    <broker>
        <name>XML Broker</name>
        <location>484 Ginko Street</location>
        <city>New York</city>
        <state>NY</state>
    </broker>
</document>

The XML schema specifies the syntax of every element in this example in a natural XML way, where elements that enclose various child elements in the XML document also enclose those child elements in the XML schema. Here's what the XML schema that will validate the XML document looks like:

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="document" type="documentType"/>
    <xsd:complexType name="documentType">
        <xsd:sequence>
            <xsd:element ref="evaluation" minOccurs="1"/>
            <xsd:element name="prospect" type="recordType"/>
            <xsd:element name="properties" type="propertiesType"/>
            <xsd:element name="broker" type="recordType"/>
        </xsd:sequence>
        <xsd:attribute name="documentDate" type="xsd:date"/>
    </xsd:complexType>
    <xsd:complexType name="recordType">
        <xsd:sequence>
            <xsd:element name="name" type="xsd:string"/>
            <xsd:element name="location" type="xsd:string"/>
            <xsd:element name="city" type="xsd:string"/>
            <xsd:element name="state" type="xsd:string"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="propertiesType">
        <xsd:sequence>
            <xsd:element name="house" minOccurs="1" maxOccurs="8">
                <xsd:complexType>
                    <xsd:sequence>
                        <xsd:element name="address" type="xsd:string"/>
                        <xsd:element name="sellingPrice" type="xsd:decimal"/>
                        <xsd:element name="listingPeriod">
                        <xsd:simpleType>
                            <xsd:restriction base="xsd:integer">
                                <xsd:maxInclusive value="6"/>
                            </xsd:restriction>
                        </xsd:simpleType>
                        </xsd:element>
                    </xsd:sequence>
                    <xsd:attribute name="listingNumber"
                        type="listingNumberType"/>
                </xsd:complexType>
            </xsd:element>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:simpleType name="listingNumberType">
        <xsd:restriction base="xsd:string">
            <xsd:pattern value="\d{3} \d{3} \d{3}"/>
        </xsd:restriction>
    </xsd:simpleType>
    <xsd:element name="evaluation" type="xsd:string"/>
</xsd:schema>

XML schemas like this aren't necessarily easy to create. However, there are a number of tools out there that can create XML schema for you.

And that's it. Part I helped get you started creating XML documents and making sure they're well-formed and valid. In Part II, you're going to start working on formatting the data in XML documents for presentation.