Data Typing in XML

If you are familiar with databases or programming, you know that generally a piece of data possesses certain characteristics or conforms to a specific format that brands it a string, a number, a date, a currency, or another data type. So far, the XML data we've worked with in previous chapters has been of the single type string, or text data. However, XML data types allow authors to specify element data as objects that can be interpreted as different types.

It is important to distinguish the element type from its data type. Chapter 4 looked at how to define element types in a Document Type Definition (DTD). You will remember that an element can contain data that is either parsed character data (#PCDATA) or character data (CDATA). The DTD can further define the element by its context or position in the structure. This method of element typing indicates the semantics of the element (such as Age representing how old a person is) but does not describe the type of data the element contains (such as Age containing a number). Parsed character data and character data are both string data types. You'll recall from Chapter 4 that additional types can be specified for XML attributes. These types are restated in the table below:

The attribute types in the above table are known as primitive data types. The Microsoft XML processor (Msxml) also supports rich data types, which represent the kinds of data types found in traditional programming languages and database systems. Data typing, as discussed in this chapter, focuses on rich data types and indicates the parser class that is used to interpret the data as something other than just a string.

Data typing falls into two basic contexts: strong typing and weak typing. In strong typing, an element must always contain a single type of data. The content in the element must conform to a strict set of rules regarding its type. For example, you might have an element named Part that must always contain an integer. It could not contain a string, a date, or even a decimal. Data is usually strongly typed in database APIs such as ODBC (Open Database Connectivity) or JDBC (Java Database Connectivity).

Weak typing, as you might guess, allows multiple types of data to exist in a single element. So if our Part element was specified to have a weak type, it might contain an integer, a string, a name, a date, or some combination of types.

You specify data types in an XML document using the dt:dt attribute in an element. The syntax is dt:dt="datatype", where datatype represents one of the supported data types. In the following example, the Id element is of type number.

<?xml version="1.0"?>
<PRODUCT xmlns:dt="urn:schemas-microsoft-com:datatypes">
  <PART>
    <ID dt:dt="number">4535645.234</ID>
    <NAME>widget</NAME>
  </PART>
</PRODUCT>

The table below identifies some of the more common data types. For a complete list of supported data types, see the section "Supported Data Types" in Appendix B of this book.

Whenever a node is assigned a type, the data in that node will conform to the specified type, despite the data's original format. Consider this Number element, for example:

<NUMBER dt:dt="int">-255</NUMBER>

This element will be processed as its typed value: the integer 255. It will not be processed as -255. This type conversion is important to understand when working with data types, because unexpected results can occur if you are not careful.

The XML object model allows scripts access to data types. As is true of other objects in the object model, the data type object is exposed and available to the script code. The element node properties dataType and nodeTypedValue allow the content author to access the data types of any node in the content tree. Let's look at how these properties work in script code, using the XML document shown in Code Listing 6-1.

Code Listing 6-1.

<CATALOG xmlns:dt="urn:schemas-microsoft-com:datatypes">
  <PLANT>
    <COMMON>Bloodroot</COMMON>
    <BOTANICAL>Sanguinaria canadensis</BOTANICAL>
    <ZONE>4</ZONE>
    <LIGHT>Mostly Shady</LIGHT>
    <PRICE dt:dt="fixed.14.4">2.44</PRICE>
    <AVAILABILITY dt:dt="dateTime">1999-03-15</AVAILABILITY>
  </PLANT>
  
  <PLANT>
    <COMMON>Columbine</COMMON>
    <BOTANICAL>Aquilegia canadensis</BOTANICAL>
    <ZONE>3</ZONE>
    <LIGHT>Mostly Shady</LIGHT>
    <PRICE dt:dt="fixed.14.4">9.37</PRICE>
    <AVAILABILITY dt:dt="dateTime">1999-03-06</AVAILABILITY>
  </PLANT>
  
  <PLANT>
    <COMMON>Marsh Marigold</COMMON>
    <BOTANICAL>Caltha palustris</BOTANICAL>
    <ZONE>4</ZONE>
    <LIGHT>Mostly Sunny</LIGHT>
    <PRICE dt:dt="fixed.14.4">6.81</PRICE>
    <AVAILABILITY dt:dt="dateTime">1999-05-17</AVAILABILITY>
  </PLANT>
</CATALOG>

Next we'll create an HTML page to work with the data in our XML document. Code Listing 6-2 (Chap06\Lst6_2.htm on the companion CD) uses the XML object model to walk through elements in the document tree and pull out the data we want.

In Code Listing 6-2, the dataType property is used to get the data type of the price node.

Code Listing 6-2.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>

  <HEAD>
    <SCRIPT LANGUAGE="JavaScript" FOR=window EVENT=onload>
      loadDoc();
    </SCRIPT>

    <SCRIPT LANGUAGE="JavaScript">
      var xmlDoc = new ActiveXObject("microsoft.xmldom");
      xmlDoc.load("lst6_1.xml");

      function loadDoc()
        {
        if (xmlDoc.readyState == "4")
          start();
        else
          window.setTimeout("loadDoc()", 4000);
        }

      function start()
        {
        var rootElem = xmlDoc.documentElement;
        var plantNode = rootElem.childNodes.item(0);
        var plantLength = plantNode.childNodes.length;
        for (cl=0; cl<plantLength; cl++)
          {
          currNode = plantNode.childNodes.item(cl);
          switch (currNode.nodeName)
            {
            case "PRICE":
              alert("The data type of this node is " +


                currNode.dataType + ".");
              break;
            }
          }
        }
    </SCRIPT>

    <TITLE>Code Listing 6-2</TITLE>
  </HEAD>

  <BODY>
  </BODY>

</HTML>

When you run the code in Code Listing 6-2, the start function displays the value fixed.14.4 because fixed.14.4 is the data type specified in the XML document.

This property is the typed value of a node, which may differ from the value as it is formatted in the document. Code Listing 6-3 (Chap06\Lst6_3.htm on the companion CD) uses the nodeTypedValue property to display the typed value.

Code Listing 6-3.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>

  <HEAD>
    <SCRIPT LANGUAGE="JavaScript" FOR=window EVENT=onload>
      loadDoc();
    </SCRIPT>

    <SCRIPT LANGUAGE="JavaScript">
      var xmlDoc = new ActiveXObject("microsoft.xmldom");
      xmlDoc.load("Lst6_1.xml");

      function loadDoc()
        {
        if (xmlDoc.readyState == "4")
          start();
        else window.setTimeout("loadDoc()", 4000);
        }



      function start()
        {
        var rootElem = xmlDoc.documentElement;
        var plantNode = rootElem.childNodes.item(0);
        var plantLength = plantNode.childNodes.length;
        for (cl=0;cl<plantLength;cl++)
          {
          currNode = plantNode.childNodes.item(cl);
          switch (currNode.nodeName)
            {
            case "AVAILABILITY":
              alert("The typed value of this node is " +
                currNode.nodeTypedValue + ".");
              break;
            }
          }
        }
    </SCRIPT>

    <TITLE>Code Listing 6-3</TITLE>
  </HEAD>

  <BODY>
  </BODY>

</HTML>

This code displays the value Mon Mar 15 00:00:00 PST 1999 rather than 1999-03-15 because the type specified is dateTime. Even though the data can appear as a date (without a time) when the XML document is displayed, the nodeTypedValue property for the node is its typed value, not just a date.

You can change the data type of an element or attribute through a process called data type coercion, or casting. However, you can convert only from a primitive data type to a rich data type. XML does not support conversions between different rich data types. To change the data type of an element or attribute, you set its dataType property to a different rich data type. You can also use the dataType property to retrieve the current rich data type of an element or attribute. Note that the dataType property can be used to retrieve a rich data type only. If an element or attribute is a primitive data type, its dataType property will be the null value. Code Listing 6-4 (Chap06\Lst6_4.htm on the companion CD) shows an example of how this works.

Code Listing 6-4.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>

  <HEAD>
    <SCRIPT LANGUAGE="JavaScript" FOR=window EVENT=onload>
      loadDoc();
    </SCRIPT>

    <SCRIPT LANGUAGE="JavaScript">
      var xmlDoc = new ActiveXObject("microsoft.xmldom");
      xmlDoc.load("Lst6_1.xml");

      function loadDoc()
        {
        if (xmlDoc.readyState == "4")
          start();
        else
          window.setTimeout("loadDoc()", 4000);
        }

      function start()
        {
        var rootElem = xmlDoc.documentElement;
        var plantNode = rootElem.childNodes.item(0);
        var plantLength = plantNode.childNodes.length;
        for (cl=0; cl<plantLength; cl++)
          {
          currNode = plantNode.childNodes.item(cl);
          switch (currNode.nodeName)
            {
            case "ZONE":
              alert("The data type of this node is " +
                currNode.dataType + ".");
              currNode.dataType = "number";
              alert("The new data type of this node is " +
                currNode.dataType + ".");
              break;
            }
          }
        }
    </SCRIPT>

    <TITLE>Code Listing 6-4</TITLE>
  </HEAD>

  <BODY>
  </BODY>

</HTML>

This example changes the data type of the Zone element from its default primitive data type (#PCDATA) to a number. The processor will now treat the value of this element as a numeric value instead of just text.

The table below lists the rich data type coercions supported by Msxml. Note that these coercions might not work with other XML processors.