Varios de los siguientes ejemplos están basados en el ejemplo de la carta descrito en la documentación de SDO. En los ejemplos se asume que el Esquema XML de la carta está contenido en el fichero carta.xsd y la instancia de la carta está en el fichero carta.xml. Estos dos ficheros se reproducen aquí:
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:carta="http://esquemaCarta"
targetNamespace="http://esquemaCarta">
<xsd:element name="cartas" type="carta:ModeloCarta"/>
<xsd:complexType name="ModeloCarta" mixed="true">
<xsd:sequence>
<xsd:element name="fecha" minOccurs="0" type="xsd:string"/>
<xsd:element name="nombre" minOccurs="0" type="xsd:string"/>
<xsd:element name="apellido" minOccurs="0" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
<carta:cartas xmlns:carta="http://esquemaCarta"> <fecha>March 1, 2005</fecha> Mutual of Omaha Wild Kingdom, USA Estimado/a <nombre>Casy</nombre> <apellido>Crocodile</apellido> Por favor, compre más repelente de tiburones. Su prima ha vencido. </carta:cartas>
Ejemplo #1 Cargar, alterar, y guardar un documento XML
El siguiente ejemplo muestra cómo un documento XML se puede cargar desde un fichero, alterar, y volver a escribir.
<?php
/**
* Cargar, actualizar, y guardar un documento XML
*/
try {
$dasxml = SDO_DAS_XML::create("carta.xsd");
$documento = $dasxml->loadFile("carta.xml");
$objeto_datos_raíz = $documento->getRootDataObject();
$objeto_datos_raíz->fecha = "September 03, 2004";
$objeto_datos_raíz->nombre = "Anantoju";
$objeto_datos_raíz->apellido = "Madhu";
$dasxml->saveFile($documento, "salida-carta.xml");
echo "Se ha escrito un nuevo fichero:\n";
print file_get_contents("salida-carta.xml");
} catch (SDO_Exception $e) {
print($e->getMessage());
}
?>
Una instancia del DAS XML se obtiene primero desde el método SDO_DAS_XML::create(), que es un método estático de la clase SDO_DAS_XML. Se pasa la ubicación del xsd como un parámetro. Una vez que se tiene inicializada la instancia del DAS XML con un esquema dado, se puede usar para cargar el documento instancia usando el método loadFile(). Existe tambíen un método loadString() si se quiere cargar un un documento instancia XML desde una cadena. Si el documento instancia se carga con éxito, se devolverá un objeto de tipo SDO_DAS_XML_Document, sobre el que se puede llamar al método getRootDataObject() para obtener el objeto de datos SDO que es el raíz del grafo de datos SDO. También se pueden usar operaciones SDO para cambiar el grafo. En este ejemplo se alteran las propiedades fecha, nombre, y apellido. Después se utiliza el método saveFile() para escribir el documento cambiado en el sistema de ficheros. El método saveFile tiene unargumento extra opcional de tipo integer que si se especifica hará que el DAS XML dé formato al XML, uando este integer como la cantidad a indentar cada vez que ocurra un cambio de nivel en el documento.
Esto escribirá lo siguiente en salida-carta.xml.
<?xml version="1.0" encoding="UTF-8"?> <ModeloCarta xmlns="http://esquemaCarta" xsi:type="ModeloCarta" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <fecha>September 03, 2004</fecha> Mutual of Omaha Wild Kingdom, USA Estimado/a <nombre>Anantoju</nombre> <apellido>Madhu</apellido> Por favor, compre más repelente de tiburones. Su prima ha vencido. </ModeloCarta>
Ejemplo #2 Crear un nuevo documento XML
El ejemplo anterior cargaba el documento desde un fichero. Este ejemplo muestra cómo crar un grafo de datos SDO en memoria. En este ejemplo, luego es guardado en una cadena XML. Además, ya que la letra contiene contenido estructurado y no estructurado, usa la API Sequence así como asignaciones a propiedades para construir el grafo de datos.
<?php
/**
* Crear un documento XML desde cero
*/
try {
$dasxml = SDO_DAS_XML::create("carta.xsd");
try {
$doc = $dasxml->createDocument();
$odr = $doc->getRootDataObject();
$sec = $odr->getSequence();
$sec->insert("April 09, 2005", NULL, 'fecha');
$sec->insert("Acme Inc. ", NULL, NULL);
$sec->insert("United Kingdom. ");
$sec->insert("Estimado/a", NULL, NULL);
$sec->insert("Tarun", NULL, "nombre");
$sec->insert("Nayaraaa", NULL, "apellido");
$odr->apellido = "Nayar";
$sec->insert("Porfavor, observe que su pedido número ");
$sec->insert(12345);
$sec->insert(" ha sido enviado hoy. Gracias por hacer negocios con nosotros.");
print($dasxml->saveString($doc));
} catch (SDO_Exception $e) {
print($e);
}
} catch (SDO_Exception $e) {
print("Problema creando un documento XML: " . $e->getMessage());
}
?>
El método createDocument() del DAS XML devuelve un objeto documento con un único objeto raíz que corresponde a un elemento de documento vacío. El nombre de elemento del elemento documento es conocido desde el fichero de esquema. Si existiera ambigüedad sobre cuál es el elemento documento, ya que pueden haber más cuando se ha cargado más de un esquema en el mismos DAS XML, se pueden pasar el nombre del elemento y el URI del espacio de nombres al método createDocument().
Esto emitirá la siguiente salida (se han insertado saltos de línea para una mejor legibilidad):
<?xml version="1.0" encoding="UTF-8"?> <ModeloCarta xmlns="http://esquemaCarta" xsi:type="ModeloCarta" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <fecha>April 09, 2005</fecha> Acme Inc. United Kingdom. Estimado/a <nombre>Tarun</nombre> <apellido>Nayar</apellido> Porfavor, observe que su pedido número 12345 ha sido enviado hoy. Gracias por hacer negocios con nosotros. </ModeloCarta>
Ejemplo #3 Establecer las propiedades del documento XML
Este tercer ejemplo muestra cómo establecer la versión de XML y y la codificación del objeto documento. Serán usados cuando se escriba el XML. Si no se desea ninguna declaración XML (quizás quiera generar el XML como cadena para embeberlo en algo) se puede usar el método setXMLDeclaration() para suprimirla.
<?php
/**
* Ilustrar las llamadas que controlan la declaración XML
*/
$dasxml = SDO_DAS_XML::create("carta.xsd");
$documento = $dasxml->loadFile("carta.xml");
$documento->setXMLVersion("1.1");
$documento->setEncoding("ISO-8859-1");
print($dasxml->saveString($documento));
?>
La versión de XML y la codificación son establecidas en la declaración XML al inicio del documento XML.
<?xml version="1.1" encoding="utf-8"?> .../...
Ejemplo #4 Utilizar un tipo abierto
Este cuarto ejemplo ilustra el uso de un tipo abierto de SDO y el uso del método createDataObject(). Para este ejemplo se usan los dos siguientes esquemas:
<schema
xmlns="http://www.w3.org/2001/XMLSchema">
<element name="jungla">
<complexType>
<sequence>
<any minOccurs="0" maxOccurs="unbounded"/>
</sequence>
</complexType>
</element>
</schema>
Observe la presencia del elemento any en la definición. El primer esquema define el tipo complejo jungla como contendor de una secuencia de cualquier otro tipo. Los otros tipos que usará el ejemplo están definidos en un segundo fichero de esquema:
<schema xmlns= "http://www.w3.org/2001/XMLSchema">
<complexType name="tipoSerpiente">
<sequence>
<element name= "nombre" type="string"/>
<element name= "longitud" type="positiveInteger" />
</sequence>
</complexType>
<complexType name="tipoOso">
<sequence>
<element name= "nombre" type="string"/>
<element name= "peso" type="positiveInteger" />
</sequence>
</complexType>
<complexType name="tipoPantera">
<sequence>
<element name= "nombre" type="string"/>
<element name= "color" type="string" />
</sequence>
</complexType>
</schema>
Aquí está el código de PHP de ejemplo que utiliza estos dos ficheros de esquema:
<?php
/**
* Ilustrar tipos abiertos y el uso del método addTypes()
*/
$dasxml = SDO_DAS_XML::create();
$dasxml->addTypes("jungla.xsd"); // este es un tipo abierto, es decir, el xsd especifica que pueden contener cualquier ("any") tipo
$dasxml->addTypes('tiposAnimales.xsd');
$baloo = $dasxml->createDataObject('','tipoOso');
$baloo->nombre = "Baloo";
$baloo->peso = 800;
$bagheera = $dasxml->createDataObject('','tipoPantera');
$bagheera->nombre = "Bagheera";
$bagheera->color = 'negro';
$kaa = $dasxml->createDataObject('','tipoSerpiente');
$kaa->nombre = "Kaa";
$kaa->longitud = 25;
$documento = $dasxml->createDocument();
$od = $documento->getRootDataObject();
$od->oso = $baloo;
$od->pantera = $bagheera;
$od->serpiente = $kaa;
print($dasxml->saveString($documento,2));
?>
Estos dos fichero de esquemas son cargados primero en el DAS XMLThese con los métodos create() y addTypes(). El método createDataObject() se usa para crear tres objetos por separado. En cada caso se pasan el URI del espacio de nombres y el nombre del tipo al método createDataObject(): en este ejemplo el URI del espacio de nombres está enblanco ya que no se usa un espacio de nombres en el esquema. Una vez que los tres objetos de datos - que representan un oso, una pantera y una serpiente - han sido creados, se crea un objeto documento con el método createDocument(). En este caso no existen ambigüedad sobre lo que debería ser el elemento documento del documento - ya que el segundo fichero de esquema sólo define tipos complejos, por lo que el elemento documento solo puede ser el elemento global jungla definido en el primer esquema. Este documento tendrá un único objeto de datos raíz que se corresponde con un elemento documento vacío jungla. Ya que es un tipo abierto, las propiedades se pueden añadir a voluntad. Cuando la primera asignación se hace a $od->oso, se añade una propiedad oso al objeto de datos raíz: lo mismo ocurre con las dos asignaciones siguientes. Cual el documento es escrito por el método saveString(), el documento resultante es:
<?xml version="1.0" encoding="UTF-8"?>
<jungla xsi:type="jungla" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<oso xsi:type="tipoOso">
<nombre>Baloo</nombre>
<peso>800</peso>
</oso>
<pantera xsi:type="tipoPantera">
<nombre>Bagheera</nombre>
<color>negro</color>
</pantera>
<serpiente xsi:type="tipoSerpiente">
<nombre>Kaa</nombre>
<longitud>25</longitud>
</serpiente>
</jungla>
Ejemplo #5 Averiguar lo que se desee del documento
Con este ejemplo se pretende ilustrar cómo encontrar el nombre del elemento y el espacio de nombre del elemento documento desde el Objeto Documento XML, y el typo de SDO y el espacio de nombre desde el objeto de datos raíz del objeto de datos XML, y cómo se relacionan entre ellos. Esto puede ser difícil de entender debido a que exsten cuatro llamadas a métodos: dos se pueden realizar sobre el objeto Documento, y las otras dos se puede realizar sobre cualquier objeto de datos incluyendo el objeto de datos raíz. Debido a que las reglas que definen cómo deriva el modelo SDO del modelo XML, cuando el objeto de datos concerniente es el objeto raíz que representa el objeto documento para el documento, only three possible values can come back from these four method calls.
Las dos llamadas a métodos que se pueden hacer en el documento son getRootElementName() y getRootEelementURI(). Devuelven el nombre de elemento y el espacio de nombres del elemento documento, respectivamente.
Las dos llamadas a métodos que se pueden hacer en el objeto de datos son getTypeName() y getTypeNamespaceURI(). Devuelve el nombre del tipo SDO y el espacio de nombres del tipo del objeto de datos, respectivamente.
Siempre que se llame a getRootElementURI() sobre el objeto documento devolverá el mismo valor que si se llama a getNamespaceURI() sobre el objeto de datos raíz. Esencialmente, la información está derivada de las primeras líneas del fichero de esquema, donde existen tres piezas distintas de información. Para ilustrarlo, aquí están de nuevo las primeras líneas de carta.xsd que se usaron arriba.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:carta="http://esquemaCarta"
targetNamespace="http://esquemaCarta">
<xsd:element name="cartas" type="carta:ModeloCarta"/>
<xsd:complexType name="ModeloCarta" mixed="true">
.../...
Los tres valores más importantes son:
cartas, el nombre del elemento documento
ModeloCarta, el nombre del tipo complejo del elemento documento. También es el nombre del tipo de SDO del objeto de datos raíz.
http://esquemaCarta, el espacio de nombres al que pertenece el elemento documento. Tabién es el URI del espacio de nombres del tipo de SDO del objeto de datos raíz.
El siguiente programa carga el documento carta document y comprueba los valores devueltos de cada una de las cuatro llamadas.
<?php
/**
* Averiguar lo que se desee sobre el documento y el elemento documento
* Esto puede ser difícil de entender debido a que exsten cuatro llamadas
* Dos llamadas se realizan sobre el documento
* Dos llamadas se realizan sobre el objeto de datos raíz y su modelo
* Debido a las reglas de referenciación SDO-XML y a cómo es derivado el modelo SDO
* del modelo XML, only three possible values can come back from these four calls.
* Siempre, $documento->getRootElementURI() == (tipo del objeto de datos raíz)->namespaceURI
* Esencialmente, todas provienen de las primeras líneas del xsd:
* <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
* xmlns:carta="http://esquemaCarta"
* targetNamespace="http://esquemaCarta">
* <xsd:element name="cartas" type="carta:ModeloCarta"/>
*/
$dasxml = SDO_DAS_XML::create("carta.xsd");
$documento = $dasxml->loadFile("carta.xml");
$od_raíz = $documento->getRootDataObject();
/**
* El "nombre del elemento raíz" es el nombre de elemento del elemento documento
* en este caso 'cartas'
* Coincide con el atributo 'nombre' del elemento documento en el xsd y también
* con el nombre de elemetno del xml
*/
echo "El nombre del elemento documento es " . $documento->getRootElementName() . "\n";
assert($documento->getRootElementName() == 'cartas'); // una propiedad del documento
/**
* El "URI del elemento raíz" es la parte del espacio de nombres del nombre de elemento del elemento documento
* en este caso 'http://esquemaCarta' ya que 'cartas' está en ese espacio de nombres
* Se toma des xsd y coincide con el espacio de nombres tomado del xml
*/
echo "El elemento documento está en el espacio de nombres " . $documento->getRootElementURI() . "\n";
assert($documento->getRootElementURI() == 'http://esquemaCarta'); // una propiedad del documento
/**
* El nombre de tipo es tomado del modelo SDO
* Las reglas de referenciación XML-SDO realizan esto:
* El nombre del tipo complejo si existe uno (en este caso existe)
* El nombre del elemento documento si no hay tipo comlejo
* Esto es tomado del xsd
*/
echo "El nombre del tipo del objeto de datos raíz es " . $od_raíz->getTypeName() . "\n";
assert($od_raíz->getTypeName() == 'ModeloCarta');
/**
* El URI del espacio de nombres es tomado del modelo SDO
* Las reglas de referenciación XML-SDO se aseguran de que siempre sea el mismo que
* el URI del espacio de nombres del elemento documento
*/
echo "El URI del espacion de nombres del objeto de datos raíz es " . $od_raíz->getTypeNamespaceURI() . "\n";
assert($od_raíz->getTypeNamespaceURI() == 'http://esquemaCarta');
?>
The output from this program is as follows:
El nombre del elemento documento es cartas El elemento documento está en el espacio de nombres http://esquemaCarta El nombre del tipo del objeto de datos raíz es ModeloCarta El URI del espacion de nombres del objeto de datos raíz es http://esquemaCarta
Ejemplo #6 Imprimir el modelo SDO
El DAS XML proporciona un sencillo medio para ver los tipo y propiedades que has sido cargador. La instrucción de PHP "print" o "echo" imprimirá los tipos y las propiedades.
<?php
/**
* Ilustrar la impresión del modelo
*/
$dasxml = SDO_DAS_XML::create("carta.xsd");
print $dasxml;
?>
The output from this program is as follows:
object(SDO_XML_DAS)#1 {
18 types have been defined. The types and their properties are::
1. commonj.sdo:BigDecimal
2. commonj.sdo:BigInteger
3. commonj.sdo:Boolean
4. commonj.sdo:Byte
5. commonj.sdo:Bytes
6. commonj.sdo:ChangeSummary
7. commonj.sdo:Character
8. commonj.sdo:DataObject
9. commonj.sdo:Date
10. commonj.sdo:Double
11. commonj.sdo:Float
12. commonj.sdo:Integer
13. commonj.sdo:Long
14. commonj.sdo:Short
15. commonj.sdo:String
16. commonj.sdo:URI
17. http://esquemaCarta:ModeloCarta
- fecha (commonj.sdo:String)
- nombre (commonj.sdo:String)
- apellido (commonj.sdo:String)
18. http://esquemaCarta:RootType
- cartas (http://esquemaCarta:ModeloCarta)