3 XML Parser for Java

Enabling DTD Caching

DTD caching is optional and is not enabled automatically.

The XML Parser for Java provides for validating and non-validating DTD caching through the setDoctype() function. After you set the DTD using this function, XMLParser will cache this DTD for further parsing.

If your application has to parse several XML documents with the same DTD, after you parse the first XML document, you can get the DTD from parser and set it back:

dtd = parser.getDoctype();
parser.setDoctype(dtd);

The parser will cache this DTD and use it for parsing the following XML documents.

Set the DOMParser.USE_DTD_ONLY_FOR_VALIDATION attribute, if the cached DTD Object is used only for validation by:

parser.setAttribute(DOMParser.USE_DTD_ONLY_FOR_VALIDATION,Boolean.TRUE);

Otherwise, the XML parser will copy the DTD object and add it to the result DOM tree.

The method to set the DTD is setDoctype(). Here is an example:

// Test using InputSource 
parser = new DOMParser(); 
parser.setErrorStream(System.out); 
parser.showWarnings(true); 
 
FileReader r = new FileReader(args[0]); 
InputSource inSource = new InputSource(r); 
inSource.setSystemId(createURL(args[0]).toString()); 
parser.parseDTD(inSource, args[1]); 
dtd = (DTD)parser.getDoctype(); 
 
r = new FileReader(args[2]); 
inSource = new InputSource(r); 
inSource.setSystemId(createURL(args[2]).toString()); 
// ********************
parser.setDoctype(dtd); 
// ********************
parser.setValidationMode(DTD_VALIDATION); 
parser.parse(inSource); 

doc = (XMLDocument)parser.getDocument(); 
doc.print(new PrintWriter(System.out)); 

Recognizing External DTDs

To recognize external DTDs, the XML Parser for Java has the setBaseURL() method.

The way to redirect the DTD is by using resolveEntity():

1. Parse your External DTD using a DOM parser's parseDTD() method.

2. Call getDoctype() to get an instance of oracle.xml.parser.v2.DTD.

3. On the document where you want to set your DTD programmatically, use the call setDoctype(yourDTD). Use this technique to read a DTD out of your product's JAR file.

Loading External DTDs from a JAR File

The parser supports a base URL method (setBaseURL()), but that just points to a place where all the DTDs are exposed.

Do the following steps:

1. Load the DTD as an InputStream:

   InputStream is =      YourClass.class.getResourceAsStream("/foo/bar/your.dtd");
   
   

   This opens ./foo/bar/your.dtd in the first relative location on the CLASSPATH that it can be found, including out of your JAR if it is in the CLASSPATH.

2. Parse the DTD:

   DOMParser d = new DOMParser();
   d.parseDTD(is, "rootelementname");
   d.setDoctype(d.getDoctype());
   
   

3. Parse your document:

   d.parse("yourdoc");
   

Checking the Correctness of Constructed XML Documents

No validation is done while creating the DOM tree using DOM APIs. So setting the DTD in the document does not help validate the DOM tree that is constructed. The only way to validate an XML file is to parse the XML document using the DOM parser or the SAX parser.

Parsing a DTD Object Separately from an XML Document

The parseDTD() method enables you to parse a DTD file separately and get a DTD object. Here is some sample code to do this:

DOMParser domparser = new DOMParser();
domparser.setValidationMode(DTD_VALIDATION); 
/* parse the DTD file */
domparser.parseDTD(new FileReader(dtdfile));
DTD dtd = domparser.getDoctype();

XML Parsers Case-Sensitivity

XML is inherently case-sensitive, therefore the parsers enforce case sensitivity in order to be compliant. When you run in non-validation mode only well-formedness counts. However <test></Test> signals an error even in non-validation mode.

Allowed File Extensions in External Entities

The file extension for external entities is unimportant so you can change it to any convenient extension, including no extension.

Creating a DOCUMENT_TYPE_NODE

There is no way to create a new DOCUMENT_TYPE_NODE object using the DOM APIs. The only way to get a DTD object is to parse the DTD file or the XML file using the DOM parser, and then use the getDocType() method.

The following statement does not create a DTD object. It creates an XMLNode object with the type set to DOCUMENT_TYPE_NODE, which in fact is not allowed. The ClassCastException is raised because appendChild expects a DTD object (based on the type).

appendChild(New XMLNode("test",Node.DOCUMENT_TYPE_NODE));

Standard DTDs That Can be Used for Orders, Shipments, and So On

Basic, standard DTDs to build on for orders, shipments, and acknowledgements are found on this Web site, which has been set up for that purpose:

http://www.xml.org/

DOM

• Use the DOM API when you need to use random access.

• Use DOM when you are performing XSL Transformations.

• Use DOM when you are calling XPath. SAX does not support it.

• Use DOM when you want to have tree iterations and need to walk through the entire document tree.

• Customize DOM tree building: org.w3c.dom.Is.DOMBuilderFilter.

• Avoid parsing external DTDs if no validation is required: DOMParser.set.Attribute(DOMParsser.STANDALONE, Boolean.TRUE);.

• Avoid including the DTD object in DOM unless necessary: DOMParser.setAttribute(DOMParser.USE_DTD_ONLY_FOR_VALIDATION, Boolean.TRUE);.

• Use DTD caching for DTD validations: DOMParser.setDoctype(dtd);.

• Build DOM asynchronously using DOM 3.0 Load and Save: DOMImplementationLS.MODE_ASYNCHRONOUS.

• A unified DOM API supports both XMLType columns and XML documents.

• When using the DOM interface, use more attributes than elements in your XML to reduce the pipe size.

  
  

  See Also: "DOM Specifications" for information on what is supported for this release

  
  

SAX

• Use the SAX API when your data is mostly streaming data.

• Use SAX to save memory. DOM consumes more memory.

• To increase the speed of retrieval of XML documents from a database, use the SAX interface instead of DOM. Make sure to select the COUNT(*) of an indexed column (the more selective the index the better). This way the optimizer can satisfy the count query with a few inputs and outputs of the index blocks instead of a full-table scan.

• Use SAX 2.0, because SAX 1.0 is deprecated.

• There are output options for SAX: print formats, XML declaration, CDATA, DTD.

• Multi-task the SAX processing to improve throughput (using multi-handlers and enabling multiple processing in callbacks). Multiple handler registrations per SAX parsing: oracle.xml.parser.V2.XMLMultiHandler.

• Use the builtin XML serializer to simplify output creation: oracle.xml.parser.V2.XMLSAXSerializer.

Using the DOM API to Count Tagged Elements

To get the number of elements in a particular tag using the parser, you can use the getElementsByTagName() method that returns a node list of all descent elements with a given tag name. You can then find out the number of elements in that node list to determine the number of the elements in the particular tag.

Creating a Node with a Value to Be Set Later

If you check the DOM specification, referring to the table discussing the node type, you will find that if you are creating an element node, its node value is null, and cannot be set. However, you can create a text node and append it to the element node. You can then put the value in the text node.

Traversing the XML Tree Using XPATH

You can traverse the tree by using the DOM API. Alternately, you can use the selectNodes() method which takes XPath syntax to navigate through the XML document. selectNodes() is part of oracle.xml.parser.v2.XMLNode.

Finding the First Child Node Element Value

Here is how to efficiently obtain the value of first child node of the element without going through the DOM tree. If you do not need the entire tree, use the SAX interface to return the desired data. Since it is event-driven, it does not have to parse the whole document.

Using the XMLNode.selectNodes() Method

The selectNodes() method is used in XMLElement and XMLDocument nodes. This method is used to extract contents from the tree or subtree based on the select patterns allowed by XSL. The optional second parameter of selectNodes, is used to resolve namespace prefixes (that is, it returns the expanded namespace URL given a prefix). XMLElement implements NSResolver, so it can be sent as the second parameter. XMLElement resolves the prefixes based on the input document. You can use the NSResolver interface, if you need to override the namespace definitions. The following sample code uses selectNodes.

public class SelectNodesTest  {
public static void main(String[] args) throws Exception {
String pattern = "/family/member/text()";
String file    = args[0];

if (args.length == 2)
  pattern = args[1];

DOMParser dp = new DOMParser();

dp.parse(createURL(file));  // Include createURL from DOMSample
XMLDocument xd = dp.getDocument();
XMLElement e = (XMLElement) xd.getDocumentElement();
NodeList nl = e.selectNodes(pattern, e);
for (int i = 0; i < nl.getLength(); i++) {
   System.out.println(nl.item(i).getNodeValue());
    }
  }
}

> java SelectNodesTest family.xml
Sarah
Bob
Joanne
Jim

> java SelectNodesTest family.xml //member/@memberid
m1
m2
m3
m4

Generating an XML Document from Data in Variables

Here is an example of XML document generation starting from information contained in simple variables, such as when a client fills in a Java form and wants to obtain an XML document.

If you have two variables in Java:

String firstname = "Gianfranco";
String lastname = "Pietraforte";

The two ways to get this information into an XML document are as follows:

1. Make an XML document in a string and parse it:

   String xml = "<person><first>"+firstname+"</first>"+
        "<last>"+lastname+"</last></person>";
   DOMParser d = new DOMParser();
   d.parse( new StringReader(xml));
   Document xmldoc = d.getDocument();
   
   

2. Use DOM APIs to construct the document and append it together:

   Document xmldoc = new XMLDocument();
   Element e1 = xmldoc.createElement("person");
   xmldoc.appendChild(e1);
   Element e2 = xmldoc.createElement("first");
   e1.appendChild(e2);
   Text t = xmldoc.createText(firstname);
   e2.appendChild(t);
   

Using the DOM API to Print Data in the Element Tags

For DOM, <name>macy</name> is actually an element named name with a child node (Text Node) of value macy. The sample code is:

String value = myElement.getFirstChild().getNodeValue();

Building XML Files from Hash Table Value Pairs

If you have a hash table key = value name = george zip = 20000:

<key>value</key><name>george</name><zip>20000</zip>

1. Get the enumeration of keys from your hash table.

2. Loop while enum.hasMoreElements().

3. For each key in the enumeration, use the createElement() on DOM document to create an element by the name of the key with a child text node with the value of the value of the hash table entry for that key.

DOM Exception WRONG_DOCUMENT_ERR on Node.appendChild()

If you have the following code snippet:

Document doc1 = new XMLDocument();
  Element element1 = doc1.creatElement("foo");
  Document doc2 = new XMLDocument();
  Element element2 = doc2.createElement("bar");
  element1.appendChild(element2);  

You will get a DOM exception of WRONG_DOCUMENT_ERR on calling the appendChild() routine, since the owner document of element1 is doc1 while that of element2 is doc2. AppendChild() only works within a single tree and the example uses two different ones. You need to use importNode() or adoptNode() instead

Getting DOMException when Setting Node Value

If you create an element node, its nodeValue is null and hence cannot be set. You get the following error:

oracle.xml.parser.XMLDOMException: Node cannot be modified while trying to set
 the value of a newly created node as below:
  String eName="Mynode";
  XMLNode aNode = new XMLNode(eName, Node.ELEMENT_NODE);
  aNode.setNodeValue(eValue);

Extracting Embedded XML from a CDATA Section

Here is an example to extract XML from the CDATA section of a DTD, which is:

<PAYLOAD>
<![CDATA[<?xml version = '1.0' encoding = 'ASCII' standalone = 'no'?>
<ADD_PO_003>
   <CNTROLAREA>
      <BSR>
         <VERB value="ADD">ADD</VERB>
         <NOUN value="PO">PO</NOUN>
         <REVISION value="003">003</REVISION>
      </BSR>
   </CNTROLAREA>
</ADD_PO_003>]]>
</PAYLOAD>

String s = YourDocumentObject.selectSingleNode("/OES_MESSAGE/PAYLOAD");

YourParser.parse( new StringReader(s));

Reading a Unicode XML File

When reading an XML document stored in an operating system file, do not use the FileReader class. Instead, use the XML Parser for Java to automatically detect the character encoding of the document. Given a binary input stream with no external encoding information, the parser automatically figures out the character encoding based on the byte order mark and encoding declaration of the XML document. Any well-formed document in any supported encoding can be successfully parsed using the following sample code:

import java.io.*; 
import oracle.xml.parser.v2.*; 
public class I18nSafeXMLFileReadingSample 
{ 
public static void main(String[] args) throws Exception 
{ 
// create an instance of the xml file 
File file = new File("myfile.xml"); 
// create a binary input stream 
FileInputStream fis = new FileInputStream(file); 
// buffering for efficiency 
BufferedInputStream in = new BufferedInputStream(fis); 
// get an instance of the parser 
DOMParser parser = new DOMParser(); 
// parse the xml file 
parser.parse(in); 
}

Writing an XML File in UTF-8

FileWriter class should not be used in writing XML files because it depends on the default character encoding of the runtime environment. The output file can suffer from a parsing error or data loss if the document contains characters that are not available in the default character encoding.

UTF-8 encoding is popular for XML documents, but UTF-8 is not usually the default file encoding of Java. Using a Java class that assumes the default file encoding can cause problems. The following example shows how to avoid these problems:

mport java.io.*;
import oracle.xml.parser.v2.*;

public class I18nSafeXMLFileWritingSample
{
  public static void main(String[] args) throws Exception
  {
    // create a test document
    XMLDocument doc = new XMLDocument();
    doc.setVersion("1.0");
    doc.appendChild(doc.createComment("This is a test empty document."));
    doc.appendChild(doc.createElement("root"));

    // create a file
    File file = new File("myfile.xml");

    // create a binary output stream to write to the file just created
    FileOutputStream fos = new FileOutputStream(file);

    // create a Writer that converts Java character stream to UTF-8 stream
    OutputStreamWriter osw = new OutputStreamWriter( fos,"UTF8");

    // buffering for efficiency
    Writer w = new BufferedWriter(osw);

    // create a PrintWriter to adapt to the printing method
    PrintWriter out = new PrintWriter(w);

    // print the document to the file through the connected objects
    doc.print(out);
  }
}

Writing Parsing XML Stored in NCLOB with UTF-8 Encoding

The following problem with parsing XML stored in an NCLOB column using UTF-8 encoding was reported.

An XML sample that is loaded into the database contains two UTF-8 multibyte characters: The text is supposed to be:

G(0xc2,0x82)otingen, Br(0xc3,0xbc)ck_W

A Java stored function was written that uses the default connection object to connect to the database, runs a select query, gets the OracleResultSet, calls the getCLOB() method and calls the getAsciiStream() method on the CLOB object. Then it executes the following code to get the XML into a DOM object:

DOMParser parser = new DOMParser();
parser.setPreserveWhitespace(true);
parser.parse(istr); 
// istr getAsciiStreamXMLDocument xmldoc = parser.getDocument();

The code throws an exception stating that the XML contains an invalid UTF-8 encoding. The character (0xc2, 0x82) is valid UTF-8. The character can be distorted when getAsciiStream() is called.

To solve this problem, use getUnicodeStream() and getBinaryStream() instead of getAsciiStream().

If this does not work, try to print out the characters to make sure that they are not distorted before they are sent to the parser in step: parser.parse(istr)

Parsing a Document Containing Accented Characters

This is the way to parse a document containing accented characters:

DOMParser parser=new DOMParser(); 
parser.setPreserveWhitespace(true); 
parser.setErrorStream(System.err); 
parser.setValidationMode(false); 
parser.showWarnings(true);
parser.parse ( new FileInputStream(new File("PruebaA3Ingles.xml")));

Storing Accented Characters in an XML Document

If you have stored accented characters, for example, an é, in your XML file and then attempt to parse the XML file with the XML Parser for Java, the parser may throw the following exception:

'Invalid UTF-8 encoding' 

You can read in accented characters in their hex or decimal format within the XML document, for example:

é 

but if you prefer not to do this, set the encoding based on the character set you were using when you created the XML file. Try setting the encoding to ISO-8859-1 (Western European ASCII). Use that encoding or something different, depending on the tool or operating system you are using.

If you explicitly set the encoding to UTF-8 (or do not specify it at all), the parser interprets your accented character (which has an ASCII value > 127) as the first byte of a UTF-8 multibyte sequence. If the subsequent bytes do not form a valid UTF-8 sequence, you get an error.

This error just means that your editor is not saving the file with UTF-8 encoding. For example, it might be saving it with ISO-8859-1 encoding. The encoding is a particular scheme used to write the Unicode character number representation to disk. Just adding this string to the top of the document does not cause your editor to write out the bytes representing the file to disk using UTF-8 encoding:

<?xml version="1.0" encoding="UTF-8"?>

Notepad uses UTF-8 on Windows systems.

You Cannot Dynamically Set the Encoding for an Input XML File

You need to include the proper encoding declaration in your document according to the specification. You cannot use setEncoding() to set the encoding for your input document. SetEncoding() is used with oracle.xml.parser.v2.XMLDocument to set the correct encoding for the printing.

Using System.out.println() and Special Characters

You cannot use System.out.println(). You need to use an output stream which is encoding aware (for example, OutputStreamWriter). You can construct an OutputStreamWriter and use the write(char[], int, int) method to print.

/* Example */
OutputStreamWriter out = new OutputStreamWriter
(System.out, "8859_1");
/* Java enc string for ISO8859-1*/

Including Binary Data in an XML Document

There is no way to directly include binary data within the document; however, there are two ways to work around this:

• Binary data can be referenced as an external unparsed entity that resides in a different file.

• Binary data can be uuencoded (meaning converted into ASCII data by UUENCODE program) and be included in a CDATA section. The limitation on the encoding technique is to ensure that it only produces legal characters for the CDATA section.

• base64 is a command line utility which encodes and decodes files in a format used by MIME-encoded documents.

Displaying an XML Document

If you are using IE5 as your browser you can display the XML document directly. Otherwise, you can use the Oracle XSLT Processor version 2 to create the HTML document using an XSL Stylesheet. The XDK JavaBeans also enable you to view your XML document.

Including an External XML File in Another XML File

IE 5.0 will parse an XML file and show the parsed output. Just load the file as you load an HTML page.

The following works, both browsing it in IE5 as well as parsing it with the XML Parser for Java:

File: a.xml
<?xml version="1.0" ?>
<!DOCTYPE a [<!ENTITY b SYSTEM "b.xml">]>
 <a>&b;</a>

File: b.xml
 <ok/>

When you browse and parse a.xml you get the following:

<a>
  <ok/>
</a>

You Do Not Need Oracle9i or Higher to Run XML Parser for Java

XML Parser for Java can be used with any of the supported version JavaVMs. The only difference with Oracle9i or higher, is that you can load it into the database and use Oracle9i JVM (formerly JServer) which is an internal JVM. For other database versions or servers, you simply run it in an external JVM and as necessary connect to a database through JDBC.

Inserting Characters <, >, ', ", and & into XML Documents

You must use the entity references:

• > for greater than (>)

• < for less than (<)

• ' for an apostrophe or a single quote (')

• " for straight double quotes (")

• & for ampersand (&)

Invalid Special Characters in Tags

If you have a tag in XML <COMPANYNAME> and use A&B, the parser gives an error with invalid character.

Special characters such as &, $, and #, and so on are not allowed to be used. If you are creating an XML document from scratch, you can use a workaround by using only valid NameChars. For example, <A_B>, <AB>, <A_AND_B> and so on. They are still readable.

If you are generating XML from external data sources such as database tables, then this is a problem which XML 1.0 does not address.

The datatype XMLType addresses this problem by offering a function which maps SQL names to XML names. The SQL to XML name mapping function will escape invalid XML NameChar in the format of _XHHHH_ where HHHH is a Unicode value of the invalid character. For example, table name V$SESSION will be mapped to XML name V_X0024_SESSION.

Finally, escaping invalid characters is a workaround to give people a way to serialize names so that they can reload them somewhere else.

Parsing XML from Data of Type String

Currently there is no method that can directly parse an XML document contained within a string. You need to convert the string into an InputStream or InputSource before parsing. An easy way is to create a ByteArrayInputStream using the bytes in the string. For example:

/* xmlDoc is a String of xml */
byte aByteArr [] = xmlDoc.getBytes();
ByteArrayInputStream bais = new ByteArrayInputStream (aByteArr, 0, aByteArr.length);
domParser.parse(bais);

Extracting Data from an XML Document into a String

Here is an example to do this:

XMLDocument Your Document;
/* Parse and Make Mods */
:
StringWriter sw = new StringWriter();
PrintWriter  pw = new PrintWriter(sw);
YourDocument.print(pw);
String YourDocInString = sw.toString();

Illegal Characters in XML Documents

If you limit it to 8-bit, then #x0-#x8; #xB, #xC, #xE, and #xF are not legal.

Using Entity References with the XML Parser for Java

If the XML Parser for Java does not expand entity references, such as &[whatever] and instead, all values are null, how can you fix this?

You probably have a simple error defining or using your entities, since Oracle has regression tests that handle entity references without error. A simple example is: ]> Alpha, then &status.

Merging XML Documents

This is done either using DOM or XSLT.

The XML Parser for Java Does Not Need a Utility to View the Parsed Output

The parsed external entity only needs to be a well-formed fragment. The following program (with xmlparser.jar from version 1) in your CLASSPATH shows parsing and printing the parsed document. It's parsing here from a string but the mechanism is no different for parsing from a file, given its URL.

import oracle.xml.parser.*;
import java.io.*;
import java.net.*;
import org.w3c.dom.*;
import org.xml.sax.*;
/*
** Simple Example of Parsing an XML File from a String
** and, if successful, printing the results.
**
** Usage: java ParseXMLFromString <hello><world/></hello>
*/
public class ParseXMLFromString {
  public static void main( String[] arg ) throws IOException, SAXException {
    String theStringToParse =
       "<?xml version='1.0'?>"+
       "<hello>"+
       "  <world/>"+
       "</hello>";
    XMLDocument theXMLDoc = parseString( theStringToParse );
    // Print the document out to standard out
    theXMLDoc.print(System.out);
  }
  public static XMLDocument parseString( String xmlString ) throws
   IOException, SAXException {
   XMLDocument theXMLDoc     = null;
    // Create an oracle.xml.parser.v2.DOMParser to parse the document.
    XMLParser theParser = new XMLParser();
    // Open an input stream on the string
    ByteArrayInputStream theStream =
         new ByteArrayInputStream( xmlString.getBytes() );
    // Set the parser to work in non-Validating mode
    theParser.setValidationMode(DTD_validation);
    try {
      // Parse the document from the InputStream
      theParser.parse( theStream );
      // Get the parsed XML Document from the parser
      theXMLDoc = theParser.getDocument();
    }
    catch (SAXParseException s) {
      System.out.println(xmlError(s));
      throw s;
    }
    return theXMLDoc;
  }
  private static String xmlError(SAXParseException s) {
     int lineNum = s.getLineNumber();
     int  colNum = s.getColumnNumber();
     String file = s.getSystemId();
     String  err = s.getMessage();
     return "XML parse error in file " + file +
            "\n" + "at line " + lineNum + ", character " + colNum +
            "\n" + err;
  }
}

Support for Hierarchical Mapping

About the relational mapping of parsed XML data: some users prefer hierarchical storage of parsed XML data. Will XMLType address this concern?

Many customers initially have this concern. It depends on what kind of XML data you are storing. If you are storing XML datagrams that are really just encoding of relational information (for example, a purchase order), then you will get much better performance and much better query flexibility (in SQL) by storing the data contained in the XML documents in relational tables, then reproduce on-demand an XML format when any particular data needs to be extracted.

If you are storing documents that are mixed-content, like legal proceedings, chapters of a book, reference manuals, and so on, then storing the documents in chunks and searching them using Oracle Text's XML search capabilities is the best bet.

The book, Building Oracle XML Applications, by Steve Muench, covers both of these storage and searching techniques with lots of examples.

Support for Ambiguous Content Mode

Are there plans to add an ambiguous content mode to the XDK Parser for Java?

The XML Parser for Java implements all the XML 1.0 standard, and the XML 1.0 standard requires XML documents to have unambiguous content models. Therefore, there is no way a compliant XML 1.0 parser can implement ambiguous content models.

Generating an XML Document Based on Two Tables

If you want to generate an XML document based on two tables with a master detail relationship. Suppose you have two tables:

• PARENT with columns: ID and PARENT_NAME (Key = ID)

• CHILD with columns: PARENT_ID, CHILD_ID, CHILD_NAME (Key = PARENT_ID + CHILD_ID)

There is a master detail relationship between PARENT and CHILD. How can you generate a document that looks like this?

<?xml version = '1.0'?> 
  <ROWSET> 
     <ROW num="1"> 
       <parent_name>Bill</parent_name> 
         <child_name>Child 1 of 2</child_name> 
         <child_name>Child 2 of 2</child_name> 
      </ROW> 
      <ROW num="2"> 
       <parent_name>Larry</parent_name> 
         <child_name>Only one child</child_name> 
      </ROW> 
  </ROWSET>

Use an object view to generate an XML document from a master-detail structure. In your case, use the following code:

create type child_type is object 
(child_name <data type child_name>) ; 
/ 
create type child_type_nst 
is table of child_type ; 
/ 

create view parent_child 
as 
select p.parent_name 
, cast 
  ( multiset 
    ( select c.child_name 
      from   child c 
      where  c.parent_id = p.id 
    ) as child_type_nst 
  ) child_type 
from parent p 
/ 

A SELECT * FROM parent_child, processed by an SQL to XML utility generates a valid XML document for your parent child relationship. The structure does not look like the one you have presented, though. It looks like this:

<?xml version = '1.0'?> 
<ROWSET> 
   <ROW num="1"> 
      <PARENT_NAME>Bill</PARENT_NAME> 
      <CHILD_TYPE> 
         <CHILD_TYPE_ITEM> 
            <CHILD_NAME>Child 1 of 2</CHILD_NAME> 
         </CHILD_TYPE_ITEM> 
         <CHILD_TYPE_ITEM> 
            <CHILD_NAME>Child 2 of 2</CHILD_NAME> 
         </CHILD_TYPE_ITEM> 
      </CHILD_TYPE> 
  </ROW> 
   <ROW num="2"> 
      <PARENT_NAME>Larry</PARENT_NAME> 
      <CHILD_TYPE> 
         <CHILD_TYPE_ITEM> 
            <CHILD_NAME>Only one child</CHILD_NAME> 
         </CHILD_TYPE_ITEM> 
      </CHILD_TYPE> 
  </ROW> 
</ROWSET>