This extension is EXPERIMENTAL. The behaviour of this extension -- including the names of its functions and anything else documented about this extension -- may change without notice in a future release of PHP. Use this extension at your own risk.
In order to use the XML Data Access Service for Service Data Objects, you will need to understand some of the concepts behind SDO: the data graph, the data object, XPath and property expressions, and so on. If you are not familiar with these ideas, you might want to look first at the section on SDO.
The job of the XML DAS is to move data between the application and an XML data source, which can be either a file or a URL. SDOs are always created and maintained according to a model which defines type names and what property names each type may have. For data which is from XML, this SDO model is built from a schema file written in XML schema language (an xsd file). This schema file is usually passed to the create method when the XMLDAS is initialised. The SDO 2.0 specification defines the mapping between XML types and SDO types. There are a number of small limitations in the PHP support - not everything which is in the specification can be done - and these limitations are summarised in a later section.
The SDO XML Data Access Service requires PHP 5.1.0 or higher. It is packaged with the SDO extension and requires SDO to have been installed. See the SDO installation instructions for the details of how to do this.
Several of the following examples are based on the letter example described in the SDO documentation. The examples assume the XML Schema for the letter is contained in a file letter.xsd and the letter instance is in the file letter.xml. These two files are reproduced here:
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:letter="http://letterSchema" targetNamespace="http://letterSchema"> <xsd:element name="letters" type="letter:FormLetter"/> <xsd:complexType name="FormLetter" mixed="true"> <xsd:sequence> <xsd:element name="date" minOccurs="0" type="xsd:string"/> <xsd:element name="firstName" minOccurs="0" type="xsd:string"/> <xsd:element name="lastName" minOccurs="0" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:schema>
<letter:letters xmlns:letter="http://letterSchema"> <date>March 1, 2005</date> Mutual of Omaha Wild Kingdom, USA Dear <firstName>Casy</firstName> <lastName>Crocodile</lastName> Please buy more shark repellent. Your premium is past due. </letter:letters>
Example 1. Loading, altering, and saving an XML document
The following example shows how an XML document can be loaded from a file, altered, and written back.
An instance of the XML DAS is first obtained from the
which is a static method of the
The location of the xsd is passed as a parameter.
Once we have an instance of the XML DAS initialised
with a given schema,
we can use it to load the instance document using the
There is also a
method if you want to load an XML
instance document from a string.
If the instance document loads successfully,
you will be returned an object of type
on which you can call the
method to get the SDO data object which is the root
of the SDO data graph.
You can then use SDO operations to change the graph.
In this example we alter the
This will write the following to letter-out.xml.
Example 2. Creating a new XML document
The previous example loaded the document from a file. This example shows how to create an SDO data graph in memory. In this example it is then saved to an XML string. Furthermore, because the letter contains both structured and unstructured content, it uses the Sequence API as well assignments to properties to construct the data graph.
The createDocument() method on the XML DAS returns a document object with a single root data object corresponding to an empty document element. The element name of the document element is known from the schema file. If there is any ambiguity about what the document element is, as there can be when more than one schema has been loaded into the same XML DAS, the element name and the namespace URI can be passed to the createDocument() method.
This will emit the following output (line breaks have been inserted for readability):
<?xml version="1.0" encoding="UTF-8"?> <FormLetter xmlns="http://letterSchema" xsi:type="FormLetter" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <date>April 09, 2005</date> Acme Inc. United Kingdom. Dear <firstName>Tarun</firstName> <lastName>Nayar</lastName> Please note that your order number 12345 has been dispatched today. Thanks for your business with us. </FormLetter>
Example 3. Setting XML document properties
This third example shows you how to set the XML version and encoding on the document object. These will be used when the XML is written out. If no XML declaration is wanted at all (perhaps you want to generate the XML as a string to embed in something) then you can use the setXMLDeclaration() method to suppress it.
The XML version and encoding are set in the XML declaration at the top of the XML document.
Example 4. Using an open type
This fourth example illustrates the use of an SDO open type and the use of the createDataObject() method. For this example we use the following two schema:
Note the presence of the
Here is the example PHP code that uses these two schema files:
These two schema files are loaded into the XML DAS with first the
method is used to create three separate data objects.
In each case the namespaceURI and typename of the type are passed to the
method: in this example the namespace URI is blank because no
namespace is used in the schema.
Once the three data objects - representing a bear, a panther and a snake -
have been created, a document object is created with the
In this case there is no ambiguity about what the document element of the
document should be - as the second schema file only defines complex types,
the document element can only be the global
Example 5. Finding out what you can from the document
This example is intended to illustrate how you can find the element name and namespace of the document element from the XML Document object, and the SDO type and namespace from the root data object of the XML data object, and how they relate to one another. This can be difficult to understand because there are four method calls: two can be made against the Document object, and two that can be made against any data object including the root data object. Because of the rules that define how the SDO model is derived from the XML model, when the data object concerned is the root object that represents the document object for the document, only three possible values can come back from these four method calls.
The two method calls that can be made against the document are getRootElementName() and getRootEelementURI(). These return the element name and namespace of the document element, respectively.
The two method calls that can be made against any data object are getTypeName() and getTypeNamespaceURI(). These return the SDO type name and type namespace of the data object, respectively.
Always, calling getRootElementURI() on the document object will return the same value as calling getNamespaceURI() on the root data object. Essentially, the information is all derived from the first few lines of the schema file, where there are three distinct pieces of information. For illustration, here again are the first few lines of the letter.xsd that we used above.
The three important values are:
The following program loads the letter document and checks the return values from each of the four calls.
The output from this program is as follows:
Example 6. Printing the SDO model
The XML DAS provides a simple means to see what types and properties have been loaded. The php "print" or "echo" instruction will print out the types and properties.
The output from this program is as follows:
The XML DAS provides two main classes. The first is SDO_DAS_XML which is the main class used to fetch the data from the XML source and used to write the data back. The second is the SDO_DAS_XML_Document class, which represents the data in the XML document.
There are also some exception classes which can be thrown if errors are found when looking for or parsing the xsd or xml files.
This is the main class of the XML DAS, which is used fetch the data from the xml source and also used to write the data back. Other than the methods to load and save xml files,
create This is a static method available in the SDO_DAS_XML class. Used to construct an SDO_DAS_XML object.
addTypes Works in much the same way as create() but used to add the contents of a second or subsequent schema file to an XML DAS that has already been created.
createDataObject Can be used to construct an SDO data object of a given type.
createDocument Can be used to construct an XML Document object from scratch.
loadFile Loads the xml instance document from a file. This file can be at local file system or it can be on a remote host.
loadString same as the above method. Loads the xml instance which is available as string.
saveFile save SDO_DAS_XML_Document object as a xml file.
saveString save SDO_DAS_XML_Document object as a xml string.
This class can be used to get to the name and namespace of the document element, and to get to the root data object of the document. Lastly, it can also be used to set the XML version and encoding of a document on output.
getRootDataObject gets the root DataObject.
getRootElementName gets the root DataObject's name.
getRootElementURI gets the root DataObject's URI.
setEncoding sets the encoding string with the given value.
setXMLDeclaraion to set/unset the xml declaration.
setXMLVersion sets the xml version with the given value.
Is a subclass of SDO_Exception. Thrown for any parser errors while loading the xsd/xml file.
Is a subclass of SDO_Exception. Thrown by any of the methods that load data from a file, when the file cannot be found.
The SDO 2.0 specification defines the mapping between XML types and SDO types. With Java SDO, this mapping is implemented by the XMLHelper. With SDO for PHP, this mapping is implemented by the XML Data Access Service. The XML DAS implements the mapping described in the SDO 2.0 specification with some restrictions. A detailed list is of the limitations is:
Simple Type with sdoJava:instanceClass - no PHP equivalent provided.
Simple Type with sdoJava:extendedInstanceClass - no PHP equivalent provided.
Simple Type with list of itemType.
Simple Type with union.
Attribute with sdo:aliasName - no PHP support for SDO property aliases.
Attribute with default value - no PHP support for SDO property defaults.
Attribute with fixed value - no PHP support for SDO read-only properties or default values.
Attribute referencing a DataObject with sdo:propertyType - no support for sdo:propertyType="...".
Attribute with bi-directional property to a DataObject with sdo:oppositeProperty and sdo:propertyType - no PHP support for SDO opposite.
Element with sdo:aliasName - no PHP support for SDO property aliases.
Element with substitution group.
Element of SimpleType with default - no PHP support for SDO defaults
Element of SimpleType with fixed value - no PHP support for SDO read-only properties or default values.
Element of SimpleType with sdo:string - no support for sdo:string="true".
Element referencing a DataObject with sdo:propertyType - no support for sdo:propertyType="..."
Element with bi-directional reference to a DataObject with sdo:oppositeProperty and sdo:propertyType - no PHP support for SDO opposite.