Chapter 2 XML, XML Schema, XSLT, and XPath

Transcription

1 Summary Chapter 2 XML, XML Schema, XSLT, and XPath Ryan McAlister XML stands for Extensible Markup Language, meaning it uses tags to denote data much like HTML. Unlike HTML though it was designed to carry data, not to display it. XML is used to structure, store and transport data. Some of the extensions for XML help with this. The three we are going to look at are XML Schema, XSLT and XPath. XML Schema gives us a way to validate if a XML document follows a specific structure. XSLT gives us a way to convert XML documents into different formats. XPath gives us a way to extract data from XML documents in an easy format. Introduction XML and the standard extensions give us a way to design documents in a way that helps us work with data. Usually XML is used in conjunction with HTML. XML keeps all the data in a separate file that an HTML document can read and display. This is helpful if you need to display data that is constantly changing. Without XML we would have to edit the HTML every time the data changed. With XML we just keep the data in a separate file then have the HTML read it from there keeping it updated. XML Schema is used to describe the structure of XML documents. We do this by describing what elements and attributes can appear in the document. Elements are used to give a name and a type to describe and define the data contained in that instance. These are much like variables in programming languages. Attributes allow us to describe an element even further. Once we build our schema, we can then use it to validate XML documents, making sure they are in the format we want. XPath gives us a way to traverse XML documents and pull certain pieces of data out of the document. It works by taking an expression and returning the data that matches the location or locations described by the expression. We can then use this information in many different ways. XSLT allows us to transform our XML documents into other XML documents, HTML or XHTML. This works by creating a XSL Style Sheet which we will use to describe how to transform the different elements in the XML document. Then, we link the XSL Style Sheet with a XML Document. It will then transform the data and give us a new document and leave the old document unchanged. This is especially helpful if we wanted to only transform some of the data into one document, and then transform the part we did not use into another document. XML - Extensible Markup Language XML is an application of SGML (Standard Generalized Markup Language), a powerful markup language specified in the mid-1980s. XML was developed in 1996 and became a W3C Recommendation in W3C is the World Wide Web Consortium, the main standards organization of the Web.

2 XML documents are used in a variety of ways, but their main usage is to store and structure data to be used by other formats. XML draws many comparisons to HTML, because they are both markup languages, but they are used for different things and are generally used in conjunction with each other. XML is built to store data in an efficient way, not to display data. HTML is used to display data, but it is not adept at storing data. Usually XML is used to store the data and HTML pulls the data out of the XML file and displays it. This is helpful because the data in the XML document can change and the HTML file does not need to be adjusted. XML Basics If we look at the XML document in Figure 1.1 to the right, the first thing we will notice is that it looks very similar to HTML. This is because they are both markup languages and both use tags to describe the data present. There are a few key differences that we will discuss that makes XML different from HTML. The main difference we will look at is that XML allows the use of user defined tags, whereas HTML only allows for the user to use predefined tags. Figure 1.1: An Example of a XML Document The usage of user defined tags allows us to describe the data in any way see fit. This also allows the data to become not just machine readable, but also easily read by humans. Let us take a closer look at what this example. The first line is the XML declaration. It defines what XML version we are using in this case version 1.0. The next line describes the root element of the document. Here we are saying it is a note. The next 3 lines are the child elements of the root element, which we use describe the contents of the note. The final line defines the end of the root element. This just says that our note is finished. As you can see this makes it very easy for humans to read, because all the tags are descriptive enough to describe what is contained within them. Looking at this we can easily discern that this is a note, to a student, from a teacher, telling the student that there is a test next Tuesday. Through the use of tags, a machine can also be able to describe it in a way that is useful. For example, if we only needed the body of the note, a machine could easily look in the note root element for the <body> child element and return what is inside that element.

3 Figure 1.2: Another example XML Document XML is not just for small datasets, we can apply the same principles we used for the note and create much larger datasets. For example, what if we wanted to create an XML document detailing all the computers in an computer lab. Say we wanted to know the computer's name, whether it is a Mac or PC, and the date it was purchased. Our root element would be <computerlab>, and it would be populated by child elements of <computer>. Figure 1.2 shows how this XML document would be formatted. In the example, we only list 3 computers, but we could continue to add <computer> elements for every computer in a large computer lab. The things to take away from this are relatively simple. Firstly, XML is a markup language, much like HTML, used to store data as opposed to displaying it. Secondly, that it allows for user defined tags that can be much more descriptive and easier to read. Lastly, that it is not just for small datasets but very large ones as well. XML Schema There are many Schemas out the for XML, but for the purpose of this text we will be describing the first one recommended by the W3C. XML Schema is a way for us to define how to build an XML document. We do this by describing what elements should be present, where in the document they are located, and what attributes they have. From there, we can build a document to the specifications laid out in our schema. We can also test a document against our schema to determine if it is a valid match or not.

4 The syntax of XML Schema Figure 1.3: Example of XML Schema Before we look at how to use an XML Schema, we need to first view the different pieces of the schema. If we take a look at Figure 1.3, we can see a XML Schema for our example from Figure 1.1. Looking at the first line we see a definition for a element called note with no type specified. There is no type specified in the element definition because the next line defines the note element as a complex type. A complex type is mainly used when an element will contain other elements. The next line is <xs.sequence> this simply means that the child elements follow this line must appear in the order that is in the schema. There is also <xs.all> and <xs.choice> that could be placed here instead. <xs.all> means that all the elements must be present, but in no particular order. <xs.choice> means that either one element or another can occur. The next 3 lines are definitions for the child elements. These are simple elements that only have a name and a type. The Figure 1.4: Common Data Types for Schemas most common types are listed in Figure 1.4. Then, we just close out the tags for the remaining open tags. There are many different data types available to use in XML Schema, but the most common ones are listed in Figure 1.4. These types are just used to describe what should be contained the element. "xs.string" for example should be used when the element will hold text data, such as a name or website address. This is why in the schema created in Figure 1.3 we used "xs.string" as our type. If we decided to add a date to our note element though, we would use "xs.date" for the type.

5 How to use XML Schema Now we can talk about how we can use a schema to help us create our XML documents. A schema describes what must be in an XML document. Looking at Figure 1.3, we can determine that we must have a note element that has 3 child elements: to, from, and body, in that specific order. Then, when we go to build our document we know that it must contain those elements to be considered a valid document. If it does not, then it is considered an invalid document. On the first row of Figure 1.5, we see the schema from Figure 1.3 and the XML document from Figure 1.1. Notice that all the elements are in the right place and the right order so we have a valid document. In the second row, we added a date element and swapped the first and second child elements. This gives us an invalid document, because the first two child elements do not Figure 1.5: A valid and invalid document according to their given schemas If we wanted to fix the invalid document, it is fairly easy to do. The first thing we would have to do is swap the to and from rows in our document. This eliminates one of our errors, but our document is still invalid because it is missing the date element. All we need to do in order to

6 fix that is add a date line in our document. Now we have a valid document we can use with the schema, as shown in Figure 1.6. Why we should use XML Schema Figure 1.6: The invalid document is now valid Now that we know what a schema is, why should we use it? There are three reasons we should use them. The first reason to use a schema is it allows us to determine quickly if the data is correct. Just like the example in Figure 1.5, by comparing the documents to the schema we were easily able to tell that the first document was correct, and that the second was incorrect. This enables us to quickly find our errors and correct them. For a much larger dataset than the one in the example, this becomes extremely helpful. Imagine if we forgot to add the date on one note element out of If we did not have the schema present, we would have to check each element on its own, which can take up a large amount of time. Having a schema present, we would be able to quickly tell where our error was and could fix it in a fraction of the time. It may take a while to set up a schema first, but it will save a lot of time in the long run. The next reason for using a schema is it allows us to easily describe the allowable data. Once again looking at Figure 1.6, we can easily describe a note as a complex element that has four simple elements: from, to, body and date. If someone wants to use our note element, they can quickly know what elements need to be present and what type they are. Then, our notes can become compatible and could be placed in the same database and all of them would have the same format. The last reason for using a schema is it allows us to restrict the data present in our documents. By defining what type is present in each element, we know exactly what will be in those elements. This ensures that someone cannot place a name where a price should go. This gives us greater control of the data present and continues to give us ways to detect errors in our documents. The main points out of this to remember are: how to build the schema, what having a schema does, and why we should use them. We build schemas by describing the elements and types that should be present in the XML document. We do this by building a list of all the elements present. Having a schema allows us to quickly validate a document to make sure all elements are there and in the right format. We should use schemas to allow us to have greater

7 control over our data and to keep it in a format that is easily read and understood by both machine and humans. XPath XPath is the language we use to find information in XML documents. It uses expressions to select a node, or multiple nodes, based on a given criteria. Nodes and elements are synonymous within an XML document. This works by comparing the criteria given in the XPath against the elements, and for all matches it returns them, all others are ignored. This becomes useful for selecting given elements when using XSLT to create new documents from data contained in a separate document. Once again we take a look at our note element to further explain nodes. The element <note> is considered our root node, because it is the root element of the document. Then <to>, <from>, and <body> are all considered both element nodes and child nodes. They are child nodes because they are children of the <note> element node. The opposite is also true, the <note> node is considered a parent node for the <to>, <from>, and <body> nodes. The Syntax of XPath Figure 1.7: Our <note> element With XPath we can write expressions in order to select any node or nodes in this document. We can select the entire <note> element, or we can select just parts of the element that we wanted. For example, if we wanted to just know who the note was going to, we could use an expression to select only that part of the element. The expression would Operator / Description Child have to show that first we want to first select the <note> // Any Depth element. The next part of the expression would then. Current node describe that we only want the <to> element. The expression we would end up with is: /note/to... Parent of current node * Wildcard Before we get into our next example, let us take a look at some of the syntax for XPath. In Figure 1.8, we Figure 1.8: Sample of Operators in XPath describe the most important syntax for creating an expression. The first operator (/) will simply tell the expression that we want the child element of whatever is on the left side of the operator. The following operator (//) will be used to select an element, or elements, at any depth. We would use this when we want to select a node, or nodes, that could be in either child nodes, grandchild nodes, or even further than that. The third operator (.), is used to select the current node. The next operator (..) will be used to select the parent of the current node. The final operator (*) is used as a wildcard. This can be used to select all child nodes, or even all nodes in a document depending on where it is used. These are just a fraction of the operators available in XPath, but they are the most important ones to know.

8 Now we have the basics of syntax and what a node is, we will look at a more complex example. For this, we are going to use the computer lab element we used earlier in the chapter. The <computerlab> element is our root element. Our root element then has three child elements that are each a <computer> element. Then each of the <computer> elements has three more simple elements: <name>, <os>, and <purchased>. In the next section, we will go over some more complex expressions and how they work. XPath Expressions Figure 1.9 : The <computerlab> element Looking at Figure 1.10, we can see a list of expressions on the right and the nodes the expressions select on the left. It is important to note here that there are multiple ways to write an Figure 1.10: Example demonstrating and expression and the nodes it selects expression and using the correct expression is crucial. The first expression is quite simple in that all it does is select the root element. The next two expressions, while they end up selecting the same nodes, find the nodes in different ways. The expression "/computerlab/computer" will only select <computer> elements that are children of the <computerlab> element. The other expression, "//computer" selects all <computer> elements anywhere in the document. This means

9 that if we had any <computer> elements outside of the <computerlab> element, then the first expression would not select them, but the second expression would. The last three expressions work in a similar fashion. While the first expression will only select <os> elements that are children of a <computer> element, the second expression will select any <os> element in the <computerlab> element, and the third expression will select all <os> elements in the document. It may not seem useful to have so many ways to select the same information, but it actually comes in handy quite frequently. For example, if instead of <computerlab> only having <computer> child elements it had <computer> and <notebook> elements. When selecting <os> elements, the first expression allows us to restrict the selection to only <computer> elements, and the second and third expressions would give us a list of all the <os> elements in both the <computer> and <notebook> elements. In the next example, we will look at other ways to further restrict our selection by applying filters to our expressions. Figure 1.11: Example of more complex expressions and the nodes they select As we can see from Figure 1.11, we can write more complex expressions to help us define what we are searching for. The first expression "/computerlab/computer[1]" uses the [1] to filter the selection to only the first <computer> element under <computerlab>. We could replace the 1 with any other number to get the matching element under <computerlab>. The second expression works in a similar manner using [last()] to select only the last <computer> element in <computerlab>. The third expression "/computerlab/computer[os="mac"]" also uses this same principle to select only the <computer> whose <os> element is equal to "Mac". The final example shows that we can select a child element after narrowing the parent element down with a filter. In this case, we want only want to know the name of any computer that was purchased before 2012.

10 Benefits of XPath So why should we use XPath to retrieve the data we need? The answer is quite simple--- it saves time. Without XPath as an option, we would have to search through all the elements by hand and compile a list manually. On small documents this would not be much of an issue, but on much larger documents with thousands of elements, it becomes essential to have a way to compile a list quickly and efficiently. Also, the syntax is relatively simple which allows us to write an expression to select the data we need in mere seconds. XPath also has the benefit of allowing us to work with dynamic data easily. If we did not use XPath, we would have to change data not only in the original XML document, but also every place that data is referenced. This could lead to many problems if all the references were not changed accordingly. However, with XPath, we are able to write an expression that will help us keep all our data up to date so we do not have to worry about keeping up with every reference, as long as our expressions are correct. To reiterate, XPath is an extremely helpful tool that allows us to select specific elements of a XML document. We do this by creating both simple and complex expressions, depending on our needs. It also has the benefits of saving us time and making working with dynamic data that much easier. Extensible Stylesheet Language (XSLT) XSLT, or Extensible Stylesheet Language, is a powerful tool we have that allows us to transform our XML documents into other XML documents, HTML, and other formats. Transforming an XML document into another XML document is helpful if we want a document with only parts of the original. This also has the advantage of leaving the original document unchanged. This allows us to use the same data in many different references. We know that XML is useful for storing data but does not do a good job at displaying data. One of the other main uses for XSLT enables us to fix that problem. By allowing us to transform a XML document into HTML or XHTML, we are then able to display the data in a more readable manner. This enables many places to store data in XML documents, and then use XSLT to transform it into HTML to be viewed as a webpage. Before we start looking into how XSLT transforms documents, remember that XML and HTML are markup languages. Both use tags to denote data, but the difference is XML has user defined tags, while HTML has predefined tags. This means that XSLT needs to change our user defined tags into equivalent tags in HTML. How XSLT Transforms Data The way XSLT transforms the tags from one to the other is through the use of a Stylesheet. A Stylesheet is written by the user, and its purpose is to map the tags from our XML document into different HTML tags. For example, in our <note> element we might want to change our <to> element tag into a <p> tag if we were going to HTML. Stylesheets allow us to automate this process, so we do not have to change every tag by hand. Looking at Figure 1.12, we have a rough idea on how this process work. We need to link an XML document with an XSLT Stylesheet, and it will give us our new document. We know

11 what a XML document and an XSLT Stylesheet is, but what is inside an XSLT Stylesheet and how does it work? The answer depends on whether we are transforming to XML or to HTML. If we are transforming one XML document into another, then the Stylesheet will look very similar to an XML document. On the other hand, if we are going from XML to HTML, the document will look more like HTML. The main difference we will notice is that instead of hard coding that data into the sheet, we give it an address to pull the data from a XML document. After creating our Stylesheet, we need to link the XML document to our Stylesheet. We do this by adding a reference to the top of our document to the location of the Stylesheet. XSLT Example Figure 1.12: A Quick Look at the XSLT process What if we wanted to output our <note> example into HTML so that we could use it in a webpage? The first thing we would have to do is create the Stylesheet. We do this by first using a template match to find the <note> element. This actually uses XPath in order to select the right element. From there we start building like we would be build a HTML file. The difference is that we would take the value of the different child elements from the XML document. Once again, Figure 1.13: Our <note> element and a Stylesheet converting it into HTML

12 this uses XPath to find the correct value. This is done with the use of an XSLT function value-of. Figure 1.13 gives us a look at what a Stylesheet for <note> might look like, and Figure 1.14 shows the resulting webpage generated from our Stylesheet. Creating a Stylesheet for this element was fairly simple since the XML document only contains four elements. If we needed to create a Stylesheet on a much larger scale, it would be a nightmare to tell the Stylesheet where to find each individual element. Luckily, XSLT has functions that can help in that regard. One of the most important ones is the ability to loop through each element present and apply the same template to each. The XSLT element for this is called the <for-each> element, and is done much like a for loop in most programming languages. We could use this for our <computerlab> element. We would have it loop through each <computer> adding the value of the <name>, <os>, and <purchased> into an HTML or XML file. XSLT has a few other elements worth mentioning. The first is the <sort> element. Adding this function to the for-each element and specifying the element to sort by will sort the output by the element you choose. The next is the <if> element. This allows us to add only elements that pass the conditional statement in the <if> element. For example, this would enable us to add only <computer> elements whose <os>="pc". The last one is the <choose> element. This works much like an if-then statement, where if it passes the test, it will do one thing, and if it fails it will do another. For our <computerlab> element, we could use this to make PC's one color and then make Mac's another color to easily differentiate between them. As we can see, XSLT is a very handy tool. Through the use of Stylesheets we are able to transform a XML document into different forms. Through the different element XSLT provides we can make a Stylesheet quickly, and adjust it to every situation. Once we have a Stylesheet, we can then take our data out of XML document into HTML so that it can be displayed in a more readable format. Conclusion Figure 1.14: Results of our Stylesheet XML is a powerful tool that we can use to store data. Through the use of user-defined tags we can make it much more descriptive than HTML. This also makes it easier for humans to read, but still allows machines to quickly understand it as well. Technically, XML does not do anything to the data. It simply stores it. Through the use of some very powerful extensions we can actually do things with that data. XSchema gives us a way to describe the structure of our data. When using a schema, we can quickly develop a format and then, later check the correctness of our data against the format we created. Using a schema also allows us to describe the data allowed in the document in a descriptive manner. This way we can look at a schema and determine exactly what elements this document needs to have in order to be correct. Once we determine the data is correct, we can then begin to use the data.

13 XPath is how we begin to access the data in our XML document. With XPath, we have a way to select specific pieces of data from a document. Using expressions, we can select all of a given element, or narrow down the selected elements by placing restrictions. Once we find the information, it is normally passed on to another extension, like XSLT, in order to be processed. XSLT is used to transform an XML document to another XML document or other formats like HTML. It accomplishes this task through the use of Stylesheets. Stylesheets allow the user to create a template that is used to convert the file. By converting a XML document into HTML, it allows us to display the data. This way we can share the data inside the XML document with the world. References [1] XML Tutorial, accessed: 04/17/2014 [2] XML Schema Tutorial, accessed: 04/17/2014 [3] XPath Tutorial, accessed: 04/18/2014 [4] XSLT Tutorial, accessed: 04/19/2014 [5] Understanding XML Schema, msdn.microsoft.com/en-us/library/aa aspx, accessed: 04/20/2014 [6] Practical XML: Parsing, accessed: 04/19/2014 [7] XPath Reference, msdn.microsoft.com/en-us/library/ms256115(v=vs.110).aspx, accessed: 04/18/2014 [8] Markup Language Definition, accessed 04/16/2014 [9] Transforming XML Data with XSLT, docs.oracle.com/javaee/1.4/tutorial/doc/jaxpxslt6.html accessed: 04/23/2014