XML/Database e XML

Obiettivi di apprendimento

• Introduzione ai database XML nativi
• Imparare la tecnologia conversione
• Creare tabelle e recuperare informazioni

Database XML nativi

Il termine "database XML nativo" è diventato popolare dal 1999, dopo che la società Software AG ha rilasciato la prima versione del proprio server XML nativo Tamino, che includeva un database XML nativo. Una definizione di un database nativo è che:

Definizione

Un database nativo è un database che definisce un modello (logico) per un documento XML e memorizza e recupera i documenti in base a quel modello.

Per modellare i dati in XML, vengono utilizzati principalmente due approcci: documenti incentrati sui dati e documenti incentrati sui documenti.

• I documenti incentrati sui dati (per il trasporto dei dati) hanno una struttura abbastanza regolare, l'ordine in genere non ha importanza e il contenuto misto è scarso o nullo.
• I documenti incentrati sui documenti (di solito per il consumo umano) hanno una struttura meno regolare o irregolare, un ordine significativo degli elementi e un sacco di contenuti misti.

Esempi di database nativi

Prodotto	Sviluppatore	Licenza	Tipo di DB
Tamino	Software AG	commerciale, proprietaria	relazionale tramite ODBC
XediX Multimedia Solution	XediX Tera Solution	commerciale	proprio
eXist	Wolfgang Meier	open source	relazionale
dbXML	dbXML Group	open source	proprio
Xindice	Apache Software Foundation	open source	proprietario (basato su modello)

eXist

eXist è un progetto open source che si propone di sviluppare un sistema di database XML nativo, strettamente integrato con strumenti di sviluppo XML già esistenti, come Apache Cocoon. Il database può essere facilmente implementato, sia in modalità standalone, sia all'interno di un motore servlet o direttamente integrato in un'applicazione.

Alcune funzionalità disponibili in eXist e che possono essere trovate nella maggior parte dei database XML nativi sono:

• archiviazione schema-less: i documenti non devono essere associati allo schema o al tipo di documento, il che significa che devono essere solo ben formati;
• raccolte: una raccolta svolge un ruolo simile a una directory in un file system; quando si invia una query, l'utente può scegliere una parte distinta della gerarchia della raccolta o anche tutti i documenti contenuti nel database;
• linguaggi di query: tra i più diffusi, quelli supportati dai database XML nativi sono XPath (con estensioni per le query su più documenti) e XQuery.

Database relazionali

I fornitori di database come IBM, Microsoft, Oracle e Sybase hanno sviluppato strumenti per assistere nella conversione di documenti XML in tabelle relazionali. Diamo un'occhiata a IBM e Oracle.

Tecnologia IBM

DB2 XML Extender consente di accedere, archiviare e trasformare dati XML tramite funzioni definite dall'utente e procedure di archiviazione. Offre 2 modelli di archiviazione chiave: XML Colums e XML Collections.

1. XML Colums: memorizza e recupera interi documenti XML come dati di colonna DB2. L'uso di XML Colums è consigliato quando esistono documenti XML e/o quando è necessario archiviare documenti XML nella loro entità.
2. XML Collections: compone documenti XML da una raccolta di tabelle relazionali.

Un file di definizione di accesso ai dati (Data Access Definition, DAD) viene utilizzato sia da XML Column sia da XML Collection per definire la "mappatura" tra le tabelle del database e la struttura del documento XML.

<Xcollection> specifica che i dati XML devono essere scomposti dai documenti XML in una raccolta di tabelle relazionali o essere composti in documenti XML da una raccolta di tabelle relazionali.

Il file DAD definisce la struttura ad albero del documento XML, utilizzando i seguenti tipi di nodi:

• root_node: specifica l'elemento radice del documento;
• element_node: identifica un elemento, che può essere l'elemento radice o un elemento figlio;
• text_node: Rappresenta il testo CDATA di un elemento;
• attribute_node: Rappresenta un attributo di un elemento.

<?xml version="1.0"?> 
<!DOCTYPE DAD SYSTEM ""c:\dxx\samples\db2xml\dtd\dad.dtd"> 
<DAD> 
  ...
<Xcollection> 
<SQL_stmt> 
       ...
</SQL_stmt> 
<prolog>?xml version="1.0"?</prolog> 
<doctype>!DOCTYPE Order SYSTEM
                  ""c:\dxx\samples\db2xml\dtd\getstart.dtd""</doctype>
<root_node> 
 <element_node name="Order">      --> Identifies the element <Order>
  <attribute_node name="key">     --> Identifies the attribute "key" 
   <column name="order_key"/>     --> Defines the name of the column, 
                                      "order_key", to which the
                                      element and attribute are
                                      mapped
  </attribute_node> 
  <element_node name="Customer">  --> Identifies a child element of 
                                      <Order> as <Customer>
   <text_node>                    --> Specifies the CDATA text for
                                      the element <Customer>
    <column name="customer">      --> Defines the name of the column,
                                      "customer", to which the child
                                      element is mapped
   </text_node> 
  </element_node> 
        ...
 </element_node>

      ...
</root_node> 
</Xcollection>
</DAD>

Oracle

XML SQL Utility (XSU) di Oracle utilizza una mappatura schematica che definisce come associare tabelle e viste, incluse le caratteristiche relazionali degli oggetti, ai documenti XML. Oracle traduce la catena dei riferimenti agli oggetti dal database nella struttura gerarchica degli elementi XML.

CREATE TABLE Customers 
{
     FIRSTNAME      VARCHAR,
     LASTNAME       VARCHAR,
     PHONENO      INT,
     ADDRESS        AddressType, // object reference
     
}

CREATE TYPE AddressType as OBJECT
{  
     ZIP       VARCHAR (100),
     CITY      VARCHAR (100),
     STREET    VARCHAR (100),
}

Un documento XML corrispondente generato da un dato modello object-relational si presenta così:

<?xml version="1.0"?>
<ROWSET>
     <ROW num="1"> 

        <FIRSTNAME>JOHN</FIRSTNAME>
        <LASTNAME>SMITH</LASTNAME>
        <PHONENO>7061234567</PHONENO>
       
        <ADDRESS>
   <ZIP>30601</ZIP>
   <CITY>ATHENS</CITY>
   <STREET>123 MAIN STREEET</STREET>
        </ADDRESS>

    </ROW>

    <!-- additional rows ... -->

 </ROWSET>

XSU può essere utilizzato per eseguire query in un ambiente Java e recuperare XML dal database.

import oracle.jdbc.driver.*;
import oracle.xml.sql.query.OracleXMLQuery;
import java.lang.*;
import java.sql.*;

// class to test XML document generation as String
class testXMLSQL {

   public static void main(String[] args)
   {
     try {
      // Create the connection
      Connection conn  = getConnection("root","");

      // Create the query class
      OracleXMLQuery qry = new OracleXMLQuery(conn,
         "SELECT  * FROM Customers");

      // Get the XML string
      String str = qry.getXMLString();

      // Print the XML output
      System.out.println("The XML output is:\n"+str);

      // Always close the query to get rid of any resources..
      qry.close();
     } catch(SQLException e) {
      System.out.println(e.toString());
     }
   }

   // Get the connection given the user name and password.!
   private static Connection getConnection(String username,
        String password)
        throws SQLException
   {
      // register the JDBC driver..
       DriverManager.registerDriver(new 
          oracle.jdbc.driver.OracleDriver());

      // Create the connection using the OCI8 driver
       Connection conn =
        DriverManager.getConnection(
           "jdbc:oracle:thin:@dlsun489:1521:ORCL",username,password);

      return conn;
   }
}

Linguaggi per le query

XPath

XPath è un linguaggio per indirizzare parti di un documento XML ed è il localizzatore comune utilizzato da XSLT e XPointer. Un'espressione XPath è una serie di passi di posizione separati da "/". Ogni passaggio seleziona un insieme di nodi che diventano i nodi correnti per il passaggio successivo. L'insieme di nodi selezionati dall'espressione sono i nodi rimanenti dopo l'elaborazione di ogni passaggio nell'ordine.

XQuery

XQuery è un linguaggio di query in fase di sviluppo da parte del World Wide Web Consortium (W3C). Il compito ambizioso è quello di sviluppare il primo standard mondiale per l'interrogazione di documenti Web. XQuery è un linguaggio di marcatura versatile, in grado di etichettare il contenuto informativo di diverse fonti di dati, inclusi documenti strutturati e semi-strutturati, database relazionali e repository di oggetti.

MySQL 5.1

MySQL ha una utility da riga di comando per eseguire query su un database MySQL e ha un'opzione per l'utilizzo di XML come formato di output. Consente anche la conversione in XML. Ulteriori informazioni possono essere trovate in Convertire MySQL in XML.

MySQL consente agli utenti di eseguire qualsiasi query SQL. mysqldump consente agli utenti di specificare quali tabelle eseguire il dump e di specificare una clausola where per limitare le righe che vengono scaricate. Nella sua versione Beta di MySQL 5.1, sono state aggiunte diverse funzionalità incluse le nuove funzioni XML .

Per comprendere queste nuove funzioni, utilizzeremo la seguente tabella:

CREATE TABLE Customers (doc VARCHAR(150));

INSERT INTO Customers VALUES
('
<person id="1">
      <firstname>John</firstname>
      <lastname>Smith</lastname>
      <phoneno>123-5678</phoneno>
</person>
');

INSERT INTO Customers VALUES
('
<person id="2">
      <firstname>Aminata</firstname>
      <lastname>Cisse</lastname>
      <phoneno>123-5679</phoneno>
</person>
');

INSERT INTO Customers VALUES
('
<person id="3">
      <firstname>Lamine</firstname>
      <lastname>Smith</lastname>
      <phoneno>123-5680</phoneno>
</person>
');

Funzioni XML

MySQL versione 5.1 ha funzioni per la ricerca e la modifica di documenti XML: ExtractValue() e UpdateXML().

EXTRACTVALUE (XML_document, XPath_string);

Questa funzione richiede 2 argomenti di stringa: il primo parametro corrisponde alla stringa XML_document e il secondo parametro XPath_string (XPath expression / locator). Questo restituirà una stringa contenente un valore preso dal documento.

mysql> SELECT EXTRACTVALUE(doc,'//firstname') FROM Customers;

+------------------------------------------+
| EXTRACTVALUE(doc,'//firstname')          |
+------------------------------------------+
| John                                     | 
| Aminata                                  | 
| Lamine                                   | 
+------------------------------------------+
3 rows in set (0.01 sec)

mysql> SELECT ExtractValue(doc,'/person[@id="3"]/firstname') as fname FROM Customers;

+---------+
| fname   |
+---------+
|         | 
|         | 
| Lamine  | 
+---------+
3 rows in set (0.02 sec)

UPDATEXML (XML_document, XPath_string, new_value);

Questa funzione richiede tre argomenti di stringa: i primi due parametri sono simili a quelli usati con extractValue(), XML_document e XPath_string. Il terzo parametro è il nuovo valore che sostituirà quello trovato. Questa funzione restituirà quindi l'XML modificato.

mysql> SELECT UpdateXML(doc,'/person[@id="3"]/phoneno', '<phoneno>111-2233<phoneno>') FROM Customers;


+-------------------------------------------------------------------------------
----------------------------------------------------+
| UpdateXML(doc,'/person[@id="3"]/phoneno','<phoneno>111-2233<phoneno>')
                                                    |
+-------------------------------------------------------------------------------
----------------------------------------------------+
|
<person id="1">
      <firstname>John</firstname>
      <lastname>Smith</lastname>
      <phoneno>123-5678</phoneno>
</person>
         |
|
<person id="2">
      <firstname>Aminata</firstname>
      <lastname>Cisse</lastname>
      <phoneno>123-5679</phoneno>
</person>
      |
|
<person id="3">
      <firstname>Lamine</firstname>
      <lastname>Smith</lastname>
      <phoneno>111-2233<phoneno>
</person>
 |
+-------------------------------------------------------------------------------
----------------------------------------------------+
3 rows in set (0.00 sec)