Constantes pré-définies
Fonctions SDO DAS XML
SDO DAS XML
PHP Manual

# Exemples

La plupart des exemples suivants sont basés sur l'exemple de la lettre décrite dans la documentation SDO. Les exemples assument que le Schéma XML pour la lettre est contenu dans un fichier lettre.xsd et que l'instance de la lettre est dans le fichier lettre.xml. Ces deux fichiers sont reproduits ici :

    <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>

Exemple #1 Chargement, modification et sauvegarde d'un document XML

L'exemple suivant montre comment un document XML peut être chargé provenant d'un fichier, altéré et récrit.

`<?php
/**
* Charge, met à jour et sauvegarde un document XML
*/
try {
$xmldas = SDO_DAS_XML::create("letter.xsd");
$document = $xmldas->loadFile("letter.xml");
$root_data_object = $document->getRootDataObject();
$root_data_object->date = "September 03, 2004";
$root_data_object->firstName = "Anantoju";
$root_data_object->lastName = "Madhu";
$xmldas->saveFile($document, "letter-out.xml");
echo "New file has been written:\n";
print file_get_contents("letter-out.xml");
} catch (SDO_Exception $e) {
print($e->getMessage());
}
?>`

Une instance du XML DAS est la première obtenue de la méthode SDO_DAS_XML::create() qui est une méthode statique de la classe SDO_DAS_XML. L'emplacement du xsd est passé en paramètre. Une fois que nous avons une instance de XML DAS initialisée avec un schéma donné, nous pouvons l'utiliser pour charger l'instance du document en utilisant la méthode loadFile(). Il y a aussi la méthode loadString() si vous voulez charger une instance de document XML provenant d'une chaîne de caractères. Si l'instance du document se charge correctement, un objet de type SDO_DAS_XML_Document sera retourné sur lequel vous pourrez appeler la méthode getRootDataObject() pour obtenir l'objet de données SDO qui est la racine de votre graphique de données SDO. Vous pouvez alors utiliser les opérations SDO pour changer le graphique SDO. Dans cet exemple, nous modifions les propriétés date, prenom et nomFamille. Ensuite, nous utilisons la méthode saveFile() pour écrire les changements dans un fichier système. La méthode saveFile a un argument optionnel qui, s'il est spécifié, fera que le XML DAS va formate le code XML en utilisant cet argument pour indenter chaque changement dans le niveau du document.

Ceci va écrit ce qui suit dans le fichier letter-out.xml.

    <?xml version="1.0" encoding="UTF-8"?>
    <FormLetter xmlns="http://letterSchema" xsi:type="FormLetter" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <date>September 03, 2004</date>
      Mutual of Omaha
      Wild Kingdom, USA
      Dear
      <firstName>Anantoju</firstName>
      <lastName>Madhu</lastName>
      Please buy more shark repellent.
      Your premium is past due.
    </FormLetter>

Exemple #2 Création d'un nouveau document XML

L'exemple précédent charge le document depuis un fichier. Cet exemple montre comment créer un graphique de données SDO en mémoire. Dans cet exemple, il est sauvegardé dans une chaîne XML. En outre, vu que la lettre contient à la fois du contenu structuré et non-structuré, on utilise l'API séquence pour assigner les propriétés pour construire le graphique des données.

`<?php
/**
* Création d'un document XML
*/
try {
$xmldas = SDO_DAS_XML::create("letter.xsd");
try {
$doc = $xmldas->createDocument();
$rdo = $doc->getRootDataObject();
$seq = $rdo->getSequence();
$seq->insert("April 09, 2005", NULL, 'date');
$seq->insert("Acme Inc. ", NULL, NULL);
$seq->insert("United Kingdom. ");
$seq->insert("Dear", NULL, NULL);
$seq->insert("Tarun", NULL, "firstName");
$seq->insert("Nayaraaa", NULL, "lastName");
$rdo->lastName = "Nayar";
$seq->insert("Please note that your order number ");
$seq->insert(12345);
$seq->insert(" has been dispatched today. Thanks for your business with us.");
print($xmldas->saveString($doc));
} catch (SDO_Exception $e) {
print($e);
}
} catch (SDO_Exception $e) {
print("Problem creating an XML document: " . $e->getMessage());
}
?>`

La méthode createDocument() du XLM DAS retourne un objet document avec une donnée racine simple correspondant à un élément du document vide. Le nom de l'élément du document est connu du fichier de schéma. S'il y a le moindre doute quant à la valeur de l'élément du document, par exemple lorsque plus d'un schéma a été chargé dans le même XML DAS, le nom de l'élément et l'URI de l'espace de noms peuvent être passés à la méthode createDocument().

Ceci affichera (les retours à la ligne ont été insérés pour une meilleure lisibilité) :

    <?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>

Exemple #3 Définition des propriétés du document XML

Ce troisième exemple montre comment définir la version XML ainsi que l'encodage de l'objet document. Ceci sera utilisé lors de l'écriture du document XML. Si aucune déclaration XML n'est désirée (peut-être voulez-vous générer du XML sous la forme d'une chaîne à incorporer quelque part), alors, vous pouvez utiliser la méthode setXMLDeclaration() pour supprimer la déclaration.

`<?php
/**
* Illustration des appels qui contrôlent la déclaration XML
*/
$xmldas = SDO_DAS_XML::create("letter.xsd");
$document = $xmldas->loadFile("letter.xml");
$document->setXMLVersion("1.1");
$document->setEncoding("ISO-8859-1");
print($xmldas->saveString($document));
?>`

La version et l'encodage du XML sont définis dans la déclaration XML en haut du document XML.

    <?xml version="1.1" encoding="ISO-8859-1"?>
    .../...

Exemple #4 Utilisation d'un type ouvert

Ce quatrième exemple illustre l'utilisation d'un type ouvert SDO ainsi que l'utilisation de la méthode createDataObject(). Pour cet exemple, nous utilisons les deux schémas suivants :

    <schema
      xmlns="http://www.w3.org/2001/XMLSchema">

      <element name="jungle">
        <complexType>
          <sequence>
            <any minOccurs="0" maxOccurs="unbounded"/>
          </sequence>
        </complexType>
      </element>

    </schema>

Notez la présence de l'élément any dans la définition. Ce premier schéma définit le type complexe jungle qui contient une séquence de n'importe quel autre type. Les autres types que cet exemple utilise, sont définis dans un second fichier de schéma :

    <schema xmlns= "http://www.w3.org/2001/XMLSchema">

       <complexType name="snakeType">
         <sequence>
           <element name= "name" type="string"/>
           <element name= "length" type="positiveInteger" />
         </sequence>
       </complexType>

       <complexType name="bearType">
         <sequence>
           <element name= "name" type="string"/>
           <element name= "weight" type="positiveInteger" />
         </sequence>
       </complexType>

       <complexType name="pantherType">
         <sequence>
           <element name= "name" type="string"/>
           <element name= "colour" type="string" />
         </sequence>
       </complexType>

    </schema>

Voici l'exemple de code PHP qui utilise ces deux fichiers de schéma :

`<?php
/**
* Illustration de types ouverts et de l'utilisaton de la méthode addTypes()
*/
$xmldas = SDO_DAS_XML::create();
$xmldas->addTypes("jungle.xsd"); // ceci est un type ouvert, i.e. la xsd spécifiée peut contenir le type "any"
$xmldas->addTypes('animalTypes.xsd');
$baloo = $xmldas->createDataObject('','bearType');
$baloo->name = "Baloo";
$baloo->weight = 800;
$bagheera = $xmldas->createDataObject('','pantherType');
$bagheera->name = "Bagheera";
$bagheera->colour = 'inky black';
$kaa = $xmldas->createDataObject('','snakeType');
$kaa->name = "Kaa";
$kaa->length = 25;
$document = $xmldas->createDocument();
$do = $document->getRootDataObject();
$do->bear = $baloo;
$do->panther = $bagheera;
$do->snake = $kaa;
print($xmldas->saveString($document,2));
?>`

Ces deux fichiers de schéma sont chargés dans le XML DAS avec les méthodes create() et addTypes(). La méthode createDataObject() est utilisée pour créer les trois objets de données. Dans chaque cas, l'URI de l'espace de noms et le nom du type sont passés à la méthode createDataObject() : dans cet exemple, l'URI de l'espace de nom est vide car aucun espace de noms n'est utilisé dans ce schéma. Une fois que les trois objets - représentant un ours, une panthère et un serpent - ont été créés, un objet document est créé avec la méthode createDocument(). Dans ce cas, il n'y a aucune ambiguïté sur l'élément document - vu que le second fichier de schéma définit uniquement des types complexes, l'élément document ne peut être que l'élément global jungle défini dans le premier schéma. Ce document aura un objet racine simple correspondant à un élément document jungle vide. Vu que c'est un type ouvert, les propriétés peuvent y être ajoutées. Lorsque la première assignation est effectuée avec $do->bear, une propriété bear est ajoutée à l'objet racine : de la même façon que pour les deux assignations suivantes. Lorsque le document est écrit via la méthode saveString(), le document résultant sera :

    <?xml version="1.0" encoding="UTF-8"?>
    <jungle xsi:type="jungle" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <bear xsi:type="bearType">
        <name>Baloo</name>
        <weight>800</weight>
      </bear>
      <panther xsi:type="pantherType">
        <name>Bagheera</name>
        <colour>inky black</colour>
      </panther>
      <snake xsi:type="snakeType">
        <name>Kaa</name>
        <length>25</length>
      </snake>
    </jungle>

Exemple #5 Trouver ce que vous voulez dans un document

Cet exemple illustre comment trouver un nom d'élément et l'espace de noms d'un élément du document depuis un objet XML Document, le type SDO et l'espace de noms depuis l'élément racine de données XML. Ceci peut être difficile à comprendre, car il y a 4 méthodes à appeler : deux peuvent être exécutées sur l'objet Document, et deux sur n'importe quelle donnée y compris l'objet racine. Parce que les règles qui définissent la façon dont le modèle SDO est dérivé du modèle XML, lorsque l'objet de données concerné est l'objet racine qui représente l'objet document pour le document, seulement trois valeurs possibles peuvent revenir de l'appels des quatre méthodes.

Les deux appels de méthodes qui peuvent être exécutés sur le document sont getRootElementName() et getRootEelementURI(). Elles retournent respectivement le nom de l'élément et l'espace de noms de l'élément document.

Les deux appels de méthodes qui peuvent être exécutés sur tous les objets de données sont getTypeName() et getTypeNamespaceURI(). Elles retournent respectivement le nom du type SDO et l'espace de noms du type de l'objet de données.

Dans tous les cas, l'appel à la méthode getRootElementURI() sur l'objet document retournera la même valeur que l'appel à la méthode getNamespaceURI() sur l'objet racine. Les informations sont toutes dérivées depuis les premières lignes du fichier schéma, où il y a trois sortes distinctes d'informations. Pour illustrer ceci, voici les premières lignes du fichier letter.xsd qui nous avons utilisé plus haut.

    <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">
        .../...

Les trois valeurs importantes sont :

- letters, le nom de l'élément document

- FormLetter, le nom du type complexe de l'élément document. C'est également le nom du type SDO de l'objet racine.

- http://letterSchema, l'espace de noms auquel l'élément document appartient. C'est également l'URI de l'espace de noms du type SDO de l'objet racine.

C'est une partie des règles XML-SDO qui, lorsque le modèle SDO est construit depuis le fichier schéma, sont utilisé pour récupérer le nom du type et l'URI de l'espace de noms des types SDO pour l'élément racine pour les types complexes de l'élément document, lorsqu'ils existent. Dans cet exemple, le nom du type de l'objet racine est FormLetter. Dans le cas où il n'y a pas de définition de type complexe séparé pour l'élément document, lorsque le type est défini en ligne et qu'il est anonyme, le nom du type SDO sera le même que le nom de l'élément.

Le programme suivant charge le document lettre et vérifie les valeurs retournées de chaque des quatre appels.

`<?php
$xmldas = SDO_DAS_XML::create("letter.xsd");
$document = $xmldas->loadFile("letter.xml");
$root_do = $document->getRootDataObject();
/**
* Le "root element name" est le nom de l'élément de l'élément document
* dans ce cas 'letters'
* Ceci correspond à l'attribut 'name' de l'élément document dans le fichier xsd et correspond
* au nom de l'élément depuis le XML
*/
echo "Le nom de l'élément document est " . $document->getRootElementName() . "\n";
assert($document->getRootElementName() == 'letters'); // une propriété du document
/**
* Le "root element URI" est l'espace de noms du nom de l'élément de l'élément document
* dans ce cas 'http://letterSchema' vu que 'letters' est dans l'espace de noms.
* Il est récupéré depuis le xsd et correspond à l'espace de noms récupéré du XML
*/
echo "L'élément document est dans l'espace de noms " . $document->getRootElementURI() . "\n";
assert($document->getRootElementURI() == 'http://letterSchema'); // une propriété du document
/**
* Le nom du type est récupéré depuis le modèle SDO
* Les règles XML-SDO utilisées pour cela sont :
* Le nom du type complexe s'il existe (ici, c'est le cas)
* Le nom de l'élément document s'il n'y a pas de type complexe
* Il est récupéré depuis le xsd
*/
echo "Le nom du type de l'objet racine est " . $root_do->getTypeName() . "\n";
assert($root_do->getTypeName() == 'FormLetter');
/**
* Le type de l'espace de noms est récupéré depuis le modèle SDO
* Les règles XML-SDO assurent que ce sera toujours le même que l'URI de
* l'espace de noms de l'élément document
*/
echo "L'URI de l'espace de noms de l'objet racine est " . $root_do->getTypeNamespaceURI() . "\n";
assert($root_do->getTypeNamespaceURI() == 'http://letterSchema');
?>`

Ce programme affichera :

    Le nom de l'élément document est letters
    L'élément document est dans l'espace de noms http://letterSchema
    Le nom du type de l'objet racine est FormLetter
    L'URI de l'espace de noms de l'objet racine est http://letterSchema

Exemple #6 Affichage du modèle SDO

Le XML DAS fournit une signification simple pour voir quels types et propriétés ont été chargés. L'instruction PHP "print" ou "echo" affichera les types et les propriétés.

`<?php
/**
* Affichage du modèle
*/
$xmldas = SDO_DAS_XML::create("letter.xsd");
print $xmldas;
?>`

L'affichage de ce programme sera :

    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://letterSchema:FormLetter
        - date (commonj.sdo:String)
        - firstName (commonj.sdo:String)
        - lastName (commonj.sdo:String)
    18. http://letterSchema:RootType
        - letters (http://letterSchema:FormLetter)

Constantes pré-définies
Fonctions SDO DAS XML
SDO DAS XML
PHP Manual