6.7 Special Oracle Features

   

---

In this section we will discuss some of the special features provided by Oracle.

6.7.1 URI Support

Oracle9i introduces new URIType object types that represent URIs (Uniform Resource Identifiers). A URI generalizes the concept of URL. A URI references not only HTML and XML documents, it also possesses "pointer" semantics to point into a document. Hence, a URI consists of two parts:

• A URL referencing a document

• A fragment that identifies a fragment within that document

A typical example for a URI is http://www.xml.com/xml_doc#//Customer/Address/Zip'. The part in front of the number sign (#) identifies the place of the document, while the final part references a fragment in the document. This mechanism follows the W3C XPointer specification. Oracle provides four object types to support the URI concept:

• UriType is an abstract object type that supplies the basic mechanisms.

• The subtype HttpUriType implements the HTTP protocol for accessing (external) Web pages.

• DBUriType is another subtype that allows referencing data in the database, so to speak, by means of intra-database references.

• The purpose of class UriFactoryType is to create those UriType objects.

The UriType object types are ordinary Oracle attribute domains. An object of that type holds a URI to an external document or to database data. Moreover, further subtypes of UriType can be added to support and implement other protocols such as gopher.

The subtype DBUriType, in particular, can be understood as a pointer to one entry in the database, which might be a table, a single row, a value, maybe complexly structured. The basis for referencing data via DBUriType is the implicit XML representation of a database shown in Listing 6.38.

Listing 6.38 XML Representation for DBUriType

<?xml version="1.0"?>
<oradb SID="mydb">
  <PUBLIC>
    <ALL_TABLES>
     . . .
    </ALL_TABLES>
    <EMP>
      <ROW>
        <EMPNO>1001</EMPNO>
        <ENAME>John</ENAME>
         . . .
      </ROW>
      <ROW>
        <EMPNO>1002</EMPNO>
        <ENAME>Mary</ENAME>
         . . .
      </ROW>
    </EMP>
  </PUBLIC>
  <SCOTT>
    <CUSTOMER>
      <ROW>
        <CNO>10</CNO>
        <NAME>Lucky Luke</NAME>
        <ADDRESS>
           <ZIP>12345</ZIP>
           <CITY>Bull</CITY>
           <STREET>Cows Xing</STREET>
           <HOUSENO>8</HOUSENO>
        </ADDRESS>
         . . .
      </ROW>
  </SCOTT>
</oradb>

The organization of this virtual XML database document reflects the hierarchy of database concepts:

• <oradb> with the Oracle system identifier (SID) as attribute

• Database schema (e.g., <PUBLIC> and <SCOTT>)

• Table in the schema (e.g., <EMP>, <CUSTOMER>)

• Tuple in the table (<ROW>)

• Attribute value (<CNO>)

Complex attribute values are handled as in XSU. For instance, the "virtual" XML document presents an object-valued attribute Address being structured as <ADDRESS> <ZIP> 12345 </ZIP> <CITY> . . . </HOUSENO> </ZIP>.

The virtual XML document takes into account the access privileges that are valid at the time of access. Hence, only those tables that are accessible by the user become part of the document. NULL values are not displayed, and the whole element for the attribute value is absent. In the future, the special null attribute <xsi null="true"> will be used to this end.

A DBUri path refers to exactly one element in the "database document"?that is, an attribute value, a single tuple, or the whole table. The path is specified in a simplified XPath format.

• /SCOTT/CUSTOMER denotes the whole table.

• /SCOTT/CUSTOMER/ROW[ CNO="10"] determines a tuple by means of a predicate.

• /SCOTT/CUSTOMER/ROW[ CNO="10"] /NAME refers to an attribute value of a tuple.

• /SCOTT/CUSTOMER/ROW[ CNO="10"] /ADDRESS/ZIP points to a value of an object.

In any case, the predicate has to determine exactly one tuple. It does not need to include the key of the table. Logical operators and, or, and not(), the usual comparisons, and some arithmetic operators are allowed. Not all features of XPath and XPointer are supported. For example, the wildcard "*" and the operator "//" are missing. The only XPath-function being allowed is text(). This function eliminates embedding tags and references just the text itself. Hence, the DBUri /SCOTT/CUSTOMER/ROW[ CNO="10"] /NAME/text() qualifies the text "Lucky Luke" instead of the element <NAME> Lucky Luke </NAME>.

DBUriType objects are accessible from a browser or a Web server. Certainly, a servlet must be called being able to transform a DBUri. A Java servlet oracle.xml.uri.OraDbUriServlet can execute the DBUri reference and return the value. However, the servlet can run only on the Oracle Servlet Engine (OSE). Anyway, anybody can implement such a servlet and plug it into a Web server. Using the Oracle servlet, the following URL returns the name of customer 10:

http://machine.oracle.com:8080/oradb/SCOTT/CUSTOMER/ROW[ CNo=10] /Name/text()

The servlet engine runs on the machine machine.oracle.com with a Web service at port 8080 listening to requests. The appended DBUri is then executed by the servlet. The result of this "query," the name of customer 10, is visualized in the browser. Note that a non-SQL programmer can now easily access data and documents stored in the database.

The MIME type of the generated document is chosen automatically. In the case the DBUri ends in a text() function, then "text/plain" is used, else an XML document is produced with the mime type "text/xml".

DBUriType objects are useful in several scenarios:

• Links to other related documents can be held in the database, as some kind of intra-database link.

• A "lazy fetching" of documents can be implemented: Only the first few characters of a document are stored in a table, the complete document is referenced by a URI in the database.

• XSL style sheets can be stored in the database and referenced during parsing with import/include.

The URIType object types encapsulate in principle a VARCHAR value that holds the URI string. URIType possesses the following methods:

• CLOB getClob(): Returns the value pointed to by the URI as a CLOB.

• VARCHAR getUrl(): Returns the URL that is stored in the URIType object.

• VARCHAR getExternalUrl(): Is similar to getUrl; however, it calls the escape mechanism (e.g., to convert white spaces into "%20").

The type UriFactory should be used to create UriType objects. Let us assume a table UrlTab(id INTEGER, uri URIType). A URI can be stored as shown in Listing 6.39.

Listing 6.39 URI Example

INSERT INTO UrlTab
VALUES
(1,SYS.UriFactory.getUri('http://www.oracle.com/CUSTOMER/ROW
[ CNo=10] /Name'))

The method getUri(VARCHAR) takes a string and creates a URIType object in the following manner:

• If the prefix is "http://", then the object will be of type HttpUriType.

• If the prefix is "/oradb/" or unknown, then an object of type DBUriType is created.

In principle, new protocols can be added as further subtypes of UriType. Any subtype must be registered in UriFactory by means of a method registerHandler. Afterwards the protocol is recognized by getUri in the same way.

Oracle's SQL possesses a standalone function SYS_DBURIGen that simplifies creating a DBUriType object. URIs are defined in a descriptive manner in Listing 6.40 instead of specifying an XPath, which is useful to generate a DBUri dynamically for given target columns.

Listing 6.40 SYS_DBURIGen Example

SELECT SYS_DBURIGen(CNo, Name)
FROM Customer
WHERE CNo=10

This query produces a URI "/SCOTT/CUSTOMER/ROW[ CNO="10"] /NAME", which references the name of the customer with CNo=10. The first parameter CNo characterizes the key of the object to be referenced, while the second parameter determines the target?that is, the Name value. The key may consist of several attributes, which are all listed in the parameter list. All the parameters except the last one are considered the key. The last parameter always specifies the database object to be referenced.

The generated URI points to an element?that is, including tags like <ROW> . . . </ROW>. If the URI refers to the text, then 'text()' can be applied as the last parameter.

The following generates a URI /SCOTT/CUSTOMER/ROW[ CNO='10'] /NAME/ text():

SELECT SYS_DBURIGen(CNo, Name, 'text()') FROM Customer WHERE CNo=10

The scenario in Listing 6.41 presents an application for URIs. Given a table ClobTab(id INTEGER, doc CLOB), we are able to define a view Shorttext(id, header, link), which presents the first 20 characters of doc in a column named header and maintains a link to the real CLOB document.

Listing 6.41 CLOB view Example

CREATE VIEW Shorttext
AS SELECT id, shorten(doc) AS header,
          SYS_DBURIGen(id,doc,'text()') AS link
FROM ClobTab

The view uses a user-defined function shorten that extracts the first 20 characters.

6.7.2 Parsers

Oracle9i provides several components, utilities, and interfaces to provide the advantages of XML technology in building Web-based database applications. Most of them are summarized in the XDK (XML Development Kit). XDKs are available for Java, C/C++, and PL/SQL, containing building blocks for reading, manipulating, transforming, and viewing XML documents. The XDK for Java is composed of the following components:

• An XML parser parses and creates XML documents using industry standard DOM and SAX interfaces. The SAX and DOM interfaces conform to the W3C recommendations version 2.0.

• The parser includes an integrated XSL Transformation (XSLT) processor for transforming XML data using style sheets. Using the XSLT processor, XML documents can be transformed from XML to any text-based format, such as XML, WML, or HTML.

• Moreover, the parser is able to validate a document against a DTD or an XML schema.

XDK supports XML1.0, DOM1.0, 2.0, SAX1.0, 2.0, and XSLT1.0. As Java is one possible language for implementing stored procedures in Oracle, the XDK allows plugging applications with XML processing into the database server.

6.7.3 Class Generator

An XML Class Generator creates source files from an XML DTD or XML Schema definition. Given a DTD or XML Schema, a class generator produces a set of Java or C++ classes. These classes enable one to construct XML documents in a program incrementally by calling constructors and methods. This is useful, for instance, when a Java program has to create an XML document that confirms a customer's order.

Here we want to explain only the general principle for the Java class generation in case of DTDs. For each element of a DTD, a corresponding Java class is generated. The class possesses constructors to initialize the XML element. Methods represent the DTD rules; for each element E on the right side is a corresponding addNode method to add parts. In addition to these basic mechanisms for constructing documents, further methods such as print(OutputStream) and validateContent() validate the constructed document. Listing 6.42 shows how to build an XML document.

Listing 6.42 Building an XML Document Example

CNo id = new CNo("1");
Firstname f = new Firstname ("Lucky");
Lastname l = new Lastname ("Luke");
Name name = new Name;
name.addNode(f);
name.addNode(l); // Name element is ready now
Zip z = new Zip("12345");
City c = new City("Bull");
Street str = new Street ("Cows Xing");
Houseno hno = new Houseno("8");
Address addr = new Address();
addr.addNode(z);
addr.addNode(c);
addr.addNode(str);
addr.addNode(hno); // Address element is ready now
Phone ph1 = new Phone ("012/3456");
Phone ph2 = new Phone ("023/4567");
Price pr = new Price("1.11");
pr.setCURRENCY(CURRENCY_Dollar); // attribute of Price
Position p = new Position ("1");
p.addNode(pr);
 . . .
Order ord = new Order("4711");
 . . .
Customer c = new Customer();
c.addNode(id);
c.addNode(name);
c.addNode(addr);
c.addNode(ph1);
c.addNode(ph2);
c.addNode(ord);

c.validateContent();   // validate the document
c.print(System.out);   // print the document

Using the generated Java classes, XML documents can be constructed gradually in a Java program. At first, the leaves of the document tree are created by using constructors of CNo, Firstname, Lastname, and so on. Higher elements like Name or Address are then built. The addNode method adds either a component to an element or a repetitive element such as Phone. The validateContent method finally checks the validity of the constructed document, which is useful as the methods themselves do not guarantee valid documents. For instance, exchanging addNode(f) with addNode(1), an invalid document would emerge.

A command-line utility for the class generator offers the same functionality.

6.7.4 Special Java Beans

Most of Oracle's XML functionality is accompanied with Java Beans that encapsulate the concepts presented earlier in this chapter. These Oracle XML TransViewer beans are provided as part of XDK for Java Beans. They facilitate the addition of graphical or visual interfaces to an XML application. The first three beans are nonvisual:

• The DOM Builder bean builds a DOM tree from an XML document. It encapsulates the XML parser for Java's DOMParser class with a bean interface and extends the functionality with asynchronous parsing.

• The XSL Transformer bean accepts an XML file, applies the transformation specified by an input XSL style sheet, and creates the resulting output file. When integrated with other beans, XSL Transformer enables an application to view the results of transformations immediately.

• The DBAccess bean is dedicated to the storage of XML documents. This bean maintains CLOB tables that hold several XML documents. The tables manage filenames and related XML contents. DBAccess can be used by other TransViewer beans as a kind of intermediate XML storage (e.g., keeping XSL style sheets under development and transformation results).

The following beans are visual:

• The Treeviewer bean displays XML documents graphically as a tree. The branches and leaves of this tree can be manipulated with a mouse.

• The XML SourceView bean allows visualization of XML documents, and the editing. of XML and XSL files is displayed such that syntax is highlighted with color. Thanks to the Java Bean approach, the XML SourceView bean can easily be integrated with DOM Builder bean. Hence, it allows for pre- and post-parsing visualization.

• DBViewer is a Java Bean that can be used to display the results of database queries as XML documents in a scrollable swing panel. XSL style sheets can easily be applied to modify the shape of result.

• XML Transform Panel is a bean that applies XSL transformations on XML documents and shows the result. It allows the editing of XML and XSL files.

---

Top Title TOC Preface P.1 What Is XML? P.2 XML Concepts P.3 XML-Related Technologies P.4 XML Data Management P.5 How This Book Is Organized P.6 Who Should Read This Book P.7 Resources Acknowledgments Chapter 8 Chapter 12 Chapter 13 Chapter 14 Chapter 19 Part I: What Is XML? Chapter 1. Information Modeling with XML 1.1 Introduction 1.2 XML as an Information Domain 1.3 How XML Expresses Information 1.4 Patterns in XML 1.5 Common XML Information-Modeling Pitfalls 1.6 A Very Simple Way to Design XML 1.7 Conclusion Part II: Native XML Databases Chapter 2. Tamino-Software AG's Native XML Server 2.1 Introduction 2.2 Tamino Architecture and APIs 2.3 XML Storage 2.4 Querying XML 2.5 Tools 2.6 Full Database Functionality 2.7 Conclusion Chapter 3. eXist Native XML Database 3.1 Introduction 3.2 Features 3.3 System Architecture Overview 3.4 Getting Started 3.5 Query Language Extensions 3.6 Application Development 3.7 Technical Background 3.8 Conclusion Chapter 4. Embedded XML Databases 4.1 Introduction 4.2 A Primer on Embedded Databases 4.3 Embedded XML Databases 4.4 Building Applications for Embedded XML Databases 4.5 Conclusion Part III: XML and Relational Databases Chapter 5. IBM XML-Enabled Data Management Product Architecture & Technology 5.1 Introduction 5.2 Product and Technology Offering Summaries 5.3 Current Architecture and Technology 5.4 Future Architecture and Technology 5.5 Conclusion Notices Chapter 6. Supporting XML in Oracle9i 6.1 Introduction 6.2 Storing XML as CLOB 6.3 XMLType 6.4 Using XSU for Fine-Grained Storage 6.5 Building XML Documents from Relational Data 6.6 Web Access to the Database 6.7 Special Oracle Features 6.8 Conclusion Chapter 7. XML Support in Microsoft SQL Server 2000 7.1 Introduction 7.2 XML and Relational Data 7.3 XML Access to SQL Server 7.4 Serializing SQL Query Results into XML 7.5 Providing Relational Views over XML 7.6 SQLXML Templates 7.7 Providing XML Views over Relational Data 7.8 Conclusion Chapter 8. A Generic Architecture for Storing XML Documents in a Relational Database 8.1 Introduction 8.2 System Architecture 8.3 The Data Model 8.4 Creating the Database 8.5 Connecting to the Repository 8.6 Uploading XML Documents 8.7 Querying the Repository 8.8 Further Enhancements 8.9 Conclusion Chapter 9. An Object-Relational Approach to Building a High-Performance XML Repository 9.1 Introduction 9.2 Overview of XML Use-Case Scenario 9.3 High-Level System Architecture 9.4 Detailed Design Descriptions 9.5 Conclusion Part IV: Applications of XML Chapter 10. Knowledge Management in Bioinformatics 10.1 Introduction 10.2 A Brief Molecular Biology Background 10.3 Life Sciences Are Turning to XML to Model Their Information 10.4 A Genetic Information Model 10.5 NeoCore XMS* 10.6 Integration of BLAST into NeoCore XMS Conclusion Chapter 11. Case Studies of XML Used with IBM DB2 Universal Database 11.1 Introduction 11.2 Case Study 1: "Our Most Valued Customers Come First" 11.3 Case Study 2: "Improve Cash Flow" 11.4 Conclusion Notices Chapter 12. The Design and Implementation of an Engineering Data Management System Using XML and J2EE 12.1 Introduction 12.2 Background and Requirements 12.3 Overview 12.4 Design Choices 12.5 Future Directions 12.6 Conclusion Chapter 13. Geographical Data Interchange Using XML-Enabled Technology within the GIDB System 13.1 Introduction 13.2 GIDB METOC Data Integration 13.3 GIDB Web Map Service Implementation 13.4 GIDB GML Import and Export 13.5 Conclusion Chapter 14. Space Wide Web by Adapters in Distributed Systems Configuration from Reusable Components 14.1 Introduction 14.2 Advanced Concept Description: The Research Problem 14.3 Integration of Components with Architecture 14.4 Example 14.5 Future Generation NASA Institute for Advanced Concepts, Space Wide Web Research, and Boundaries 14.6 Advanced Concept Development 14.7 Conclusion Chapter 15. XML as a Unifying Framework for Inductive Databases 15.1 Introduction 15.2 Past Work 15.3 The Proposed Data Model: XDM 15.4 Benefits of XDM 15.5 Toward Flexible and Open Systems 15.6 Related Work 15.7 Conclusion Chapter 16. Designing and Managing an XML Warehouse 16.1 Introduction 16.2 Architecture 16.3 Data Warehouse Specification 16.4 Managing the Metadata 16.5 Storage and Management of the Data Warehouse 16.6 DAWAX: A Graphic Tool for the Specification and Management of a Data Warehouse 16.7 Related Work 16.8 Conclusion Part V: Performance and Benchmarks Chapter 17. XML Management System Benchmarks 17.1 Introduction 17.2 Benchmark Specification 17.3 Benchmark Data Set 17.4 Existing Benchmarks for XML 17.5 Conclusion Chapter 18. The Michigan Benchmark: A Micro-Benchmark for XML Query Performance Diagnostics 18.1 Introduction 18.2 Related Work 18.3 Benchmark Data Set 18.4 Benchmark Queries 18.5 Using the Benchmark 18.6 Conclusion Chapter 19. A Comparison of Database Approaches for Storing XML Documents 19.1 Introduction 19.2 Data Models for XML Documents 19.3 Databases for Storing XML Documents 19.4 Benchmarking Specification 19.5 Test Results 19.6 Related Work 19.7 Summary Chapter 20. Performance Analysis between an XML-Enabled Database and a Native XML Database 20.1 Introduction 20.2 Related Work 20.3 Methodology 20.4 Database Design 20.5 Discussion 20.6 Experiment Result 20.7 Conclusion Chapter 21. Conclusion References Contributors Editors Chapter 1: Information Modeling with XML Chapter 2: Tamino-Software AG's Native XML Server Chapter 3: eXist Native XML Database Chapter 4: Embedded XML Databases Chapter 5: IBM XML-Enabled Data Management Product Architecture and Technology Chapter 6: Supporting XML in Oracle9i Chapter 7: XML Support in Microsoft SQL Server 2000 Chapter 8: A Generic Architecture for Storing XML Documents in a Relational Database Chapter 9: An Object-Relational Approach to Building a High-Performance XML Repository Chapter 10: Knowledge Management in Bioinformatics Chapter 11: Case Studies of XML Used with IBM DB2 Universal Database Chapter 12: The Design and Implementation of an Engineering Data Management System Using XML and J2EE Chapter 13: Geographical Data Interchange Using XML-Enabled Technology within the GIDB System Chapter 14: Space Wide Web by Adapters in Distributed Systems Configuration from Reusable Components Chapter 15: XML as a Unifying Framework for Inductive Databases Chapter 16: Designing and Managing an XML Warehouse Chapter 17: XML Management System Benchmarks Chapter 18: The Michigan Benchmark: A Micro-Benchmark for XML Query Performance Diagnostics Chapter 19: A Comparison of Database Approaches for Storing XML Documents Chapter 20: Performance Analysis between an XML-Enabled Database and a Native XML Database Remember the name: eTutorials.org Copyright eTutorials.org 2008-2023. All rights reserved.