PHP Handling of XML

Types of XML Parsers

• PHP provides three different built-in XML parsers
  1. Expat: This parser is a simple parser that linearly scans through an XML file and generates three types of "events": 1) start element events, 2) end element events, and 3) data content events. A program provides handlers for each of these three types of events.
     • Advantages
       1. Incrementally reads the file so large XML files can be easily accommodated
     • Disadvantages
       1. If you want to retain state information about the file you will need to allocate your own data structures
       2. If you want to be able to interpret data content then you typically must maintain your own stack of elements so that you know which element the data content belongs to.
       3. Even simple tasks require code that is more unwieldy than the simple XML parser discussed next
  2. SimpleXML: This parser creates a tree of objects from an XML file and provides a few simple commands that allow you to easily navigate through the tree.
     • Advantages
       1. It produces easy-to-read programs. It was the last addition to the PHP language and essentially exploits the 80-20 rule which is that 80% of the things you want to do with an XML file are simple and hence should be handled with a simple parser.

       2. It creates an easy to navigate tree
     • Disadvantages
       1. It can only be used to read an XML document or modify the contents of an element. It cannot be used to alter the structure of an XML document by adding or deleting elements.

       2. It must read the entire XML document into memory.

       3. The functions it creates for navigating the tree are named after the element tags so if the names of the element tags change, then you must also edit the names of all the function calls. Hence you should only use simpleXML with a relatively stable XML document.

  3. DOM (Document Object Model): This parser builds a tree from the XML specification and provides numerous operations for navigating the tree, modifying the data content, and modifying the structural content by either adding or deleting elements.
     • Advantages
       1. It builds an easy to navigate tree
       2. You can add/delete elements from the XML document
       3. You can build an XML document from scratch
     • Disadvantages
       1. It must read the entire XML file into memory
       2. The functions for generating a tree are more generic than for simpleXML and hence the code is less easy to read.

Expat Parser

• Creating the parser: $parser=xml_parser_create()
• Must specify three handler functions to handle each of the three events:
  1. function start_element($parser, $element, $attrs)
     • $parser is a reference to the parser
     • $element is a string in capital letters with the element name (e.g., 'CATALOG', 'ARTIST')
     • $attrs is a reference to an associative array of attributes for this element

  2. function end_element($parser, $element)
     • $parser is a reference to the parser
     • $element is a string in capital letters with the element name (e.g., 'CATALOG', 'ARTIST'): Note that the '/' is stripped
  3. function data_content($parser, $data)
     • $parser is a reference to the parser
     • $data is a reference to the data content of an element
• Associating functions with appropriate element handlers
  1. xml_set_element_handler($parser,"start_element","stop_element"): sets the handlers for the start and stop elements

  2. xml_set_character_data_handler($parser,"data_content"): sets the handler for the data content

• Template code for opening an XML file and parsing it--you would replace the test.xml filename with your own filename //Open XML file $fp=fopen("test.xml","r"); //Read data while ($data=fread($fp,4096)) { // 1) xml_parse returns true if it successfully // 2) feof($fp) tells the parser whether or not this will be the last // block of data that it processes--feof returns true if $fp is now // at end-of-file // 3) if the parse fails then print an appropriate error message and // terminate the program xml_parse($parser,$data,feof($fp)) or die (sprintf("XML Error: %s at line %d", xml_error_string(xml_get_error_code($parser)), xml_get_current_line_number($parser))); } //Free the XML parser xml_parser_free($parser);

SimpleXML

• $root = simplexml_load_file(filename): loads an xml document, converts all elements and attributes to objects, and returns a pointer to the root element

• Navigating simple xml trees
  1. Option 1: An element object's children function returns an array of all children associated with that object

  2. Option 2: Specific children objects can be accessed via their element tags. For each child element, an element has a variable that stores either the instance of that child element, or an array of child elements if there are more than one instance of that child element.

     Examples:

     1. $catalog->artist[0]: returns the first artist element in a catalog
     2. $catalog->artist: returns an array of artist elements that are children of catalog
     3. $catalog->artist[0]->cd[0]->price: returns the price element associated with the given cd

• Accessing element content: An element's value is obtained by type casting the element's object to the appropriate type.
  1. Example: $value += (double)$cd->price;
  2. When an element is used in a string context, then you do not even have to explicitly perform a type cast--PHP does it for you. For example:

     	  echo $cd->price;
     	  

     You must use implicit type casting with caution however. There are situations where you might think the string context is implicit but it is not. For example, the following conditional test will fail unexpectedly because a conditional test does not implicitly expect a string, even if one of the two values being compared is a string:

     	  Wrong: if ($artist->name == 'Bonnie Tyler')
     	  Right: if ((string)$artist->name == 'Bonnie Tyler')
     	  

  3. There is not a function for extracting the data content from an element. Type casting is the only way that you can obtain it.

• Accessing attribute values
  1. Option 1: You can obtain an individual attribute value by treating an element object as an associative array and providing the attribute's name as the keyword value:

          $artist = $catalog->artist[0];
          $retired = $artist['active'];
          

     This code fragment retrieves the value of the active attribute for an artist and stores it in the variable $retired.

  2. Option 2: An element object's attributes function will return an associative array containing all of the element's attributes.

• Modifying XML Documents: Simple XML does not allow one to structurally modify an XML document but you can modify either element or attribute values. To do so:
  1. Simply assign the new value to the appropriate object. For example:

     	  $cd->price = 10.50;
     	  $cd['country'] = 'usa';
     	  

  2. Save the XML document using the root object's asXML function:

               $root->asXML();
         

     The file will be saved as an ascii text file.

• Using XPath to Filter Objects: Let's say that you want to process all cds with a list price of $10 or more. You could retrieve an array of cd elements and then use a conditional to filter out those cds with a price of less than $10. Alternatively you can use an element's xpath function to submit a query that will filter out the objects you do not want. The syntax for an xpath query is:

       $obj->xpath('path[filter expression]')
       

  The path is a path that starts at $obj and returns a group of objects that we want to filter. The filter expression is applied to each object in the group and returns those objects that satisfy the expression. For example, the following query returns all cd objects whose price is greater than or equal to $10:

       foreach ($catalog->xpath('cd[price >= 10]') as $qualitycd)
       

  The xpath syntax can be a bit tricky. First note that you should use the regular inequality signs rather than their entity representations, as in XSLT. Second, you must always start the query expression with a path, such as 'cd' in the above example. For example, the following code will get an error message from php because the path is missing:

       foreach ($catalog->cd->xpath('price >= 10') as $qualitycd)
       

  If you want to perform a query on the current node you can type:

       foreach ($cd->xpath('./[price >= 10]') as $qualitycd)
       

  but this is unnecessarily complicated because all you are doing is asking whether this particular cd has a price greater than or equal to 10. In general you should reserve xpath queries for collections of objects.

The DOM Parser

• The DOM parser provides several types of objects that we will care about:
  1. document object: holds the XML tree
  2. element objects
  3. attribute objects
  4. text objects: hold data content
  5. xpath objects: allow you to make xpath queries against the document
  6. nodelist objects: these objects are lists of nodes and are returned by various element and attribute retrieval methods.
     • nodelists can be treated like arrays in foreach statements
     • nodelists cannot be treated like arrays outside foreach statements.
       1. You must use the item method to access an element of a nodelist.
       2. The elements of the list are numbered from 0
       3. Example: $artists->item(2) returns the third artist element in the nodelist pointed to by $artists.
  You create a document object, then load an XML file into the object, which creates a tree consisting of element objects. The element objects in turn have pointers to attribute objects and to text objects, which hold their data content. You can explicitly create xpath objects in order to retrieve nodes from the tree.

• Code for initializing the parser:

  //  create the document model 
  $catalogDoc = new DOMDocument();        
  
  //  The DOM parser typically treats whitespace between elements, such as
  //     line breaks, as text. Hence it will create children nodes for these
  //     "text elements", which is annoying. We can stop this behavior by setting
  //     the document's preserveWhiteSpace property to false 
  $catalogDoc->preserveWhiteSpace = false;    
  
  //  The load function reads an xml file and parses it into a tree 
  $catalogDoc->load("cdcatalog.xml");
  
  //  The documentElement variable is a pointer to the root object in the tree
  $catalog = $catalogDoc->documentElement;
  

• Methods for accessing element content
  1. string element->nodeName: returns the element's tag
  2. string element->nodeValue: returns the element's value. Technically this returns a text node but you can type cast it to the appropriate type.

• Methods for retrieving elements: You retrieve the children of an element by navigating to that element's object in the tree and then using one of the two following options:
  1. Option 1: you can retrieve all of the child elements of an element via its childNodes variable:

     $children = $catalog->childNodes;
     

     $children points to a nodelist.

  2. Option 2: You can use the getElementsByTagName function to retrieve all children elements with a specific tag name:

     $cds = $catalog->getElementsByTagName('cd');
              

     Since there are multiple cds, $cds will be a nodelist.

• Using XPath to retrieve elements: You can also create an xpath object and use it to retrieve elements from the tree. The relevant methods are:
  • $xpath = new DOMXPath(document object): creates an xpath object and returns a pointer to it.

  • $xpath->evaluate(string expression[, context element]): evaluates an xpath query relative to the optional element. If the optional context element is omitted then the query is evaluated relative to the root node of the document. evaluate returns either a single node or a nodelist.

  • $xpath->query(string expression[, context element]): identical to evaluate except that it always returns an nodelist, even if only a single node matches the expression.

  Here are several examples:

  • $xpath = new DOMXPath($catalogDoc): create the xpath object
  • $price = $xpath->evaluate('//price'): return all price elements in the document
  • $price = $xpath->evaluate('cd[last()]/price'): return all price elements that belong to the last cd element in the document
  • $price = $xpath->evaluate('price[. < 6]', $cd): return all price elements for $cd whose price is less than 6.
  • $price = $xpath->evaluate('artist[name/last = "Tyler" and name/first = "Bonnie"]'): find the artist whose last name is Tyler and whose first name is Bonnie.
    • Note that even though the query expression is in single quotes, the element content, Tyler and Bonnie, must still be quoted.

• Retrieving Attributes
  1. element->getAttribute(string name): returns the value of the named attribute
  2. bool element->hasAttribute(string name): indicates whether or not the element has an attribute with the given name.

• Editing an XML Document
  1. Creating New Nodes
     1. document->createElement(tagname, value): creates a new leaf element with the indicated value. document is a pointer to a document object.
     2. document->createElement(tagname): creates a new interior node without a value. We can use the node insertion methods described below to add either leaf elements or composite elements to the new element.
     3. attribute document->createAttribute(string name): creates an attribute with the given name. You will need to add the attribute to an element and then edit the attribute's value using element->setAttribute in order to create a value for this attribute.

  2. Inserting New Nodes
     1. element->appendChild(element): Appends an element object to the end of the element's current children
     2. element->insertBefore(element newElement, element child): inserts the newElement before the given child element
     3. element->replaceChild(element newChild, element oldChild): replaces the old child with the new child element
     4. element->setAttributeNode(attribute): sets/replaces an attribute in element.

  3. Editing the Content of an XML Document
     1. changing element content
        1. the right way: create a new element node and then call replaceChild.

        2. the wrong ways
           1. assign a string to an element's nodeValue variable: the php interpreter will not complain but the value does not get changed
           2. try to create a text node and assign it to an element's nodeValue variable. Again the php interpreter does not complain but the value does not get changed

     2. element->setAttribute(string name, string value): Sets the named attribute to value in this element.

  4. Deleting Nodes
     1. element->removeChild(childElement): removes the indicated child element from element
     2. bool element->removeAttribute(string name): removes the attribute with the given name from element.

• Saving an XML Document
  1. document->saveXML(): converts an XML document object to an ascii string. This string can then be written to a file by one of the file writing commands.

  2. document->formatOutput = true: It is a good idea to set a document object's formatOutput property to true before calling saveXML. Doing so causes the saveXML command to nicely format/indent the output.

• Validating an XML Document
  1. bool document->schemaValidate(string schemafile): validates the document against the given schemafile and returns true or false depending on whether or not validation succeeds.

  2. bool document->validate(): validates the document according to either its internal or external DTD.