|
|
Control JDBC AutoCommit on Each Connection By adding the new
<connection name="demo"> <username>scott</username> <password>tiger</password> <dburl>jdbc:oracle:thin:@localhost:1521:ORCL</dburl> <driver>oracle.jdbc.driver.OracleDriver</driver> <autocommit>true</autocommit> </connection> If
Explicitly Commit After DML Using <xsql:dml> By specifying the new Change or Suppress Parameter Value Character Set Conversion By default, the XSQL Page Process does charater set conversion
on the value of HTTP parameters to compensate for the default character set
used by most servlet engines. The default base character set used for
conversion is the Java character set <XSQLConfig>
:
<processor>
:
<character-set-conversion>
<default-charset>8859_1</default-charset>
</character-set-conversion>
To disable character set conversion for HTTP parameters, use
the
<XSQLConfig>
:
<processor>
:
<character-set-conversion>
<none/>
</character-set-conversion>
This is useful if you are working with parameter values which are correctly representable using your servlet's default character set, and eliminates a small amount of overhead associated with performing this character set conversion. New -version Flag to XSQL Command Line Utility Passing the
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Note
:
If any of the parameter names listed in the bind-params
attribute have not been supplied a specific value, their value will be bound as
a SQL |
The following built-in action handlers support bind variables
using the same
Because using true bind variables can improve the performance of your XSQL Pages' database interactions by allowing the database to reuse previously parsed cursors, it is recommended that you use true bind variables anywhere where SQL permits them. Be aware that true bind variables do not make XSQL lexical parameters obsolete in the least! Anywhere true bind variables are not allowed ? in the FROM clause, ORDER BY clause, or to substitute fragments of the query syntax ? the existing XSQL parameters are just what the doctor ordered.
Set Default Date Format for
You can now supply the
Produce Custom Output From Your XSQL "Data Page" with Custom Serializers
You can now provide a user-defined serializer class to
programmatically control how the final XSQL datapage's XML document should be
serialized to a text or binary stream. A user-defined serializer must implement
the
Bookmark
void serialize(org.w3c.dom.Document doc,
XSQLPageRequest env) throws Throwable;
In this release, DOM-based serializers are supported. A future release may support SAX2-based serializers as well. A custom serializer class is expected to perform the following tasks in the correct order:
Set the content type of the serialized stream before writing any content to the output PrintWriter (or OutputStream).
You set the type by calling
env.setContentType("text/html");
or a MIME type with an explicit output encoding character set like this:
env.setContentType("text/html;charset=Shift_JIS");
Call
For example, the following custom serializer (included in the
XSQL distribution in
package oracle.xml.xsql.serializers;
import org.w3c.dom.Document;
import java.io.PrintWriter;
import oracle.xml.xsql.*;
public class XSQLSampleSerializer
implements XSQLDocumentSerializer {
public void serialize(Document doc, XSQLPageRequest env) throws Throwable {
String encoding = env.getPageEncoding(); // Use same encoding as XSQL page
// template. Set to specific
// encoding if necessary
String mimeType = "text/html";// Set this to the appropriate content type
// (1) Set content type using the setContentType on the XSQLPageRequest
if (encoding != null && !encoding.equals("")) {
env.setContentType(mimeType+";charset="+encoding);
}
else {
env.setContentType(mimeType);
}
// (2) Get the output writer from the XSQLPageRequest
PrintWriter e = env.getWriter();
// (3) Serialize the document to the writer
e.println("<html>Document element is <b>"+
doc.getDocumentElement().getNodeName()+
"</b></html>");
}
}
There are two ways to use a custome serializer, depending on
whether you need to first perform an XSLT transformation before serializing or
not. To perform an XSLT transformation before using a custom serializer, simply
add the
<?xml version="1.0?> <?xml-stylesheet type="text/xsl" href="mystyle.xsl" serializer="java:my.pkg.MySerializer"?>
If you only need the custom serializer, simply leave out the
<?xml version="1.0?> <?xml-stylesheet serializer="java:my.pkg.MySerializer"?>
You can also assign a short nickname to your custom serializers
in the
<XSQLConfig>
<!-- etc. -->
<serializerdefs>
<serializer>
<name>Sample</name>
<class>oracle.xml.xsql.serializers.XSQLSampleSerializer</class>
</serializer>
<serializer>
<name>FOP</name>
<class>oracle.xml.xsql.serializers.XSQLFOPSerializer</class>
</serializer>
</serializerdefs>
</XSQLConfig>
then you can use the nicknames "Sample" and/or "FOP" as shown in the following examples:
<?xml-stylesheet type="text/xsl" href="emp-to-xslfo.xsl" serializer="FOP"?>
or
<?xml-stylesheet serializer="Sample"?>
Serialize XSQL Data Pages in Binary Formats
The
Produce PDF Output from XSQL Pages via Integration with Apache FOP for XSL-FO
Using the new support for custom serializers, the
<!-- EmpTableFO.xsl -->
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xsl:version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<!-- defines the layout master -->
<fo:layout-master-set>
<fo:simple-page-master master-name="first"
page-height="29.7cm"
page-width="21cm"
margin-top="1cm"
margin-bottom="2cm"
margin-left="2.5cm"
margin-right="2.5cm">
<fo:region-body margin-top="3cm"/>
</fo:simple-page-master>
</fo:layout-master-set>
<!-- starts actual layout -->
<fo:page-sequence master-name="first">
<fo:flow flow-name="xsl-region-body">
<fo:block font-size="24pt" font-family="Garamond" line-height="24pt" space-after.optimum="3pt" font-weight="bold" start-indent="15pt">
Total of All Salaries is $<xsl:value-of select="sum(/ROWSET/ROW/SAL)"/>
</fo:block>
<!-- Here starts the table -->
<fo:block border-width="2pt">
<fo:table>
<fo:table-column column-width="4cm"/>
<fo:table-column column-width="4cm"/>
<fo:table-body font-size="10pt" font-family="sans-serif">
<xsl:for-each select="ROWSET/ROW">
<fo:table-row line-height="12pt">
<fo:table-cell>
<fo:block><xsl:value-of select="ENAME"/></fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block><xsl:value-of select="SAL"/></fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:for-each>
</fo:table-body>
</fo:table>
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
you can format the results of a query against the EMP table
using the supplied FOP serializer (pre-defined in
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="emptablefo.xsl" serializer="FOP"?>
<xsql:query connection="demo" xmlns:xsql="urn:oracle-xsql">
SELECT ENAME, SAL FROM EMP
ORDER BY SAL asc
</xsql:query>
|
|
Note
:
The example FOP Serializer provided with this release was tested against the 0.14.0 release of Apache FOP, and requires the following additional JAR files to be in your server-side CLASSPATH to function correctly:
The FOP release is available from the xml.apache.org website and the SAX2 release is available from http://www.megginson.com/SAX/Java/index.html. Since this is not a production-level release of FOP, the integration of XSQL/FOP should be considered experimental in this release until the FOP interface stabilizes in later releases. |
Optionally Use XSQL Pages with XML Parser 2.1.0.0 Beta
XSQL Pages 1.0.2 is a production release and ships
pre-configured with the latest production release of the
Oracle XML Parser for Java, release 2.0.2.9, on which XSQL depends. You can use
XSQL 1.0.2 with the Beta release of the Oracle XML Parser for Java, release
2.1.0.0, by including its
|
|
Note
:
The Oracle XML Parser for Java, release 2.1.0.0, is a Beta release. |
Optionally Use XML SQL Utility 2.1.0.0 Beta
XSQL Pages 1.0.2 is a production release and ships
pre-configured with the latest production release of the
Oracle XML SQL Utility for Java, release 1.2.1, on which XSQL depends. You can
use XSQL 1.0.2 with the Beta release of the Oracle XML SQL Utility, release
2.1.0, by including its
|
|
Note
:
The Oracle XML SQL Utility, release 2.1.0, is a Beta release. |
Insert, Update, Delete Via XML Using Non-Oracle JDBC Drivers
If you are using XSQL Pages with the 2.1.0 Beta release of the XML SQL Utility in the CLASSPATH, the restriction in previous releases has been lifted so that the following XSQL actions that update the database based on posted XML documents:
can be used with any JDBC driver, not just the Oracle JDBC driver. Since other databases do not support object views, the types of XML that can be supported against these databases is limited to their flat, one-table-or-view capabilities.
Produce Inline XML Schema for Queried Data
If you are using XSQL Pages with the 2.1.0 Beta release of the
XML SQL Utility in the CLASSPATH, you can provide the new
Request Parameters Missing in Command Line and XSQLRequest correctly
When using the XSQL Command Line processor or the XSQLRequest
API, pages processed that contained the
XSQL Command Line Pages Always Use UTF-8 Encoding
Regardless of the setting of the
|
|
Note
:
To produce UTF-16 output, you must be using XSQL with a Java JDK version 1.3, which introduces UTF-16 support. |
REMOTE_ADDR CGI Variable Not Available via <xsql:include-owa>
Now the
Release 1.0.1.0 was the first maintenance release of the Oracle XSQL Pages technology. It added several improvements requested by XSQL Pages users, as well as several bug fixes.
Dynamic Stylesheet Assignment
It is now possible to include one or more XSQL parameter
references in the value of the
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="{@sheetname}.xsl"?>
<!-- Example of dynamically setting the XSLT stylesheet name -->
<page>
<!-- Set value of page-private "sheetname" param to value fetched from DB -->
<xsql:set-page-param name="sheetname">
SELECT stylesheet_name
FROM my_user_pref_table
WHERE userid = '{@uid}' /* Assume 'uid' cookie value is user name */
</xsql:set-page-param>
<xsql:query>
SELECT * FROM YOURTABLE WHERE ... /* Query here */
</xsql:query>
</page>
Declaratively Update Rows in Tables or Views using XML
Previously, users relied on
The differences are:
The
The rows processed are updated, rather than inserted.
To limit the list of columns whose values should be updated,
provide the optional
Declaratively Delete Rows in Tables or Views using XML
Previously, users relied on
The differences are:
The
The rows processed are deleted, rather than inserted or updated.
Limit List of columns to insert using <xsql:insert-request>
Previously, an
Add Request-Scoped Objects to the XSQLPageRequest context
Using the new methods
ServletContext now available on XSQLServletPageRequest
The
connection="connname" can optionally be xsql:connection
For additional clarity, your XSQL pages can now indicate their
optional database connection to be used using the namespace-qualified attribute
The following reported bugs were fixed in this release:
Pages included using xsql:include-xsql not always cached correctly
In certain situations nested XSQL pages included using the
Unhelpful errors if XSQLConfig.xml file is not well formed
Previously, the XSQL Page Processor (Servlet, Command Line, and
via XSQLRequest) would fail unceremoniously if its configuration file
Parameters in including page not visible in nested page with reparse=yes
When XSQL pages were included using
Error in Demos using XML Parser V2 version 2.0.2.9
All errors in the XSQL demos, caused by more stringent error checking in the XSLT engine introduced in the 2.0.2.9 release, have been fixed.
Insert transform stylesheets ignore stylesheet parameters
Any XSLT stylesheet parameters set using
Run out of open cursors using CURSOR() expressions
Actually a bug in the underlying XML SQL Utility (XSU). Fixed by upgrading the latest production version of XSU, release 1.2.1, now included in the XSQL distribution.
<xsql:action> missing from online help.
Information on
Infinite loop passing param={@param}
Passing the value "
Stylesheet parameters lost if one parameter contained an apostrophe
Passing a stylesheet parameter whose value contains an apostrophe would result in having all stylesheet parameters ignored. Now a stylesheet parameter's value can contains a single-quote or a double-quote, but not both, and if a value contains both only that one parameter's value will be ignored.
Connections not freed to the connection pool under certain circumstances
Previously if you were:
Using XSQLRequest to call processToXML() on an XSQL Page which did not have an associated XSLT stylesheet, or
Using <xsql:include-xsql> to include another XSQL page that uses a different database connection from the current page and the included page did not have an associated XSLT stylesheet
the connection for the
As with any software running on a server, care must be taken to avoid risks of exposing sensitive information to malicious users. This section describes best practice security techniques for using the Oracle XSQL Servlet.
Install Your XSQLConfig.xml File in a Safe Directory
The
Failure to follow this recommendation could mean that a user of your site could accidentally (or intentionally) browse the contents of your configuration file.
Disable Default Client Stylesheet Overrideability When Your Pages Go Production
By default, the XSQL Page Processor allows the user to supply a
stylesheet in the request by passing a value for the special
Be Alert of the Use of Subsitution Parameters
With power comes responsibility. Any product, like Oracle Reports and XSQL Pages among others, that supports the use of lexical substitution variables in a SQL query can give a developer enough rope to hang himself. Any time you deploy an XSQL page that allows important parts of a SQL statement (or at the extreme, the entire SQL statement) to be substituted by a lexical parameter, you should make sure that you have taken appropriate precautions against misuse.
For example, one of the demonstrations that comes with XSQL Pages
is the "adhoc query demo". It illustrates how the entire SQL statement of an
Techniques that can be used to make sure your pages are not abused include:
Making sure the database user account associated with the page has only the privileges for reading the tables/views you want your users to see.
Using true bind variables instead of lexical bind variables when substituting single values in a SELECT statement. If you need to make syntactic parts of your SQL statement parameterized, then lexical parameters are the only game in town. Otherwise, true bind variabled are recommended so that any attempt to pass an invalid value will generate an error instead of producing an unexpected result.
The XSQL Pages distribution includes a working version of the
single-user web server that is part of the Web-to-Go mobile application
platform along with the
This release includes an on-line Help System (built using XSQL Pages, of course) giving helpful information about the syntax and options for each XSQL Action Element. In additional helpful examples are provided illustrating each action. To access the help system, after successfully installing the XSQL Servlet, browse the URL:
http://yourmachine/xsql/index.html
|
A number of new built-in XSQL Action Elements have been added in this release. The following table documents the new arrivals...
| Action Element | Description |
|
|
Set the value of a top-level XSLT stylesheet parameter. |
|
|
Set a page-level (local) parameter that can be referred to in subsequent SQL statements in the page. |
|
|
Set an HTTP-Session level parameter. |
|
|
Set an HTTP Cookie. |
|
|
Execute an arbitrary SQL statement and include its result set in canonical XML format. |
|
|
Includes the canonical XML representation of the result set of a cursor returned by a PL/SQL stored function. |
|
|
Include a parameter and its value as an element in your XSQL page. |
|
|
Include all request parameters as XML elements in your XSQL page. |
|
|
Include arbitrary XML resources at any point in your page by relative or absolute URL. |
|
|
Include the results of executing a stored procedure that makes use of the Oracle Web Agent (OWA) packages inside the database to generate XML. |
|
|
Include the results of one XSQL page at any point inside another. |
|
|
Insert the XML document (or HTML form) posted in the request into a database table or view. |
|
|
Update an existing row in the database based on the posted XML document supplied in the request. |
|
|
Delete an existing row in the database based on the posted XML document supplied in the request. |
|
|
Inserts the XML document contained in the value of a single parameter. |
|
|
Execute a SQL DML statement or PL/SQL anonymous block. |
|
|
Invoke a user-defined action handler, implemented in Java, for executing custom logic and including custom XML information into your XSQL page. |
XSQL provides a single way to refer to values that can be specified as:
HTTP Request Parameters
HTTP Cookies
HTTP Session Variables
Local XSQL Page Parameters
When you reference an parameter like
<xsql:query>
select name from users where userid = {@myParam}
</xsql:query>
or in the attribute value of an XSQL Action Element, like:
<xsql:query max-rows="{@myParam}">
:
</xsql:query>
the XSQL Page Processor determines the value of the parameter by using the following logic.
If the request is being processed by the XSQL
Servlet, then check in the following order if
An XSQL local page parameter
An HTTP Cookie
An HTTP Session Variable
An HTTP Request Parameter
If the request is being processed by a non-Servlet request method
using
An XSQL local page parameter
An XSQL Request parameter
Provided on the command-line or passed into the
In either case, if none of the attempts produces a matching
parameter value, the XSQL Page Processor looks for a "fallback" (a.k.a
"default") value for
This release contains the following known issues:
HTTP parameters with multibyte names (e.g. a parameter whose
name is in Kanji) are properly handled when they are inserted into your XSQL
page using
Using the
When using the Apache JServ servlet engine, the use of
relative stylesheet and XSQL page references may not produce the results you
expect if you have an elaborate virtual path mapping. Since the Apache JServ
engine does not properly implement the Servlet API method
The XSQL Servlet is designed to run on any Java VM, using any JDBC driver, against any database. In practice, we are able to test it against only the most popular configurations of these. In this section we document the supported configurations that have been tested in the Oracle labs.
The XSQL Pages and XSQL Servlet have been tested using:
JDK 1.1.8
JDK 1.2.2
JDK 1.3
These are the only three JDK versions that we know work correctly.
|
|
Note
:
Numerous users have reported problems using XSQL Pages and the XSQL Servlet with JDK 1.1.7 which suffers problems in its character set conversion routines for UTF-8 that make it unusable for processing XSQL Pages. |
This XSQL Servlet has been tested with the following servlet engines:
Oracle Internet Application Server 8i
Allaire JRun 2.3.3 and 3.0.0
Apache 1.3.9 with JServ 1.0 and 1.1
Apache 1.3.9 with Tomcat 3.1 or 3.2 Servlet Engine
Apache Tomcat 3.1 or 3.2 Web Server + Servlet Engine
Caucho Resin 1.1
Java Web Server 2.0
Weblogic 5.1 Web Server
NewAtlanta ServletExec 2.2 and 3.0 for IIS/PWS 4.0
Oracle8i Lite Web-to-Go Server
Oracle8i 8.1.7 Oracle Servlet Engine
Sun JavaServer Web Development Kit (JSWDK) 1.0.1 Web Server
JavaServer Pages can use
Apache 1.3.9 with Tomcat 3.1 or 3.2 Servlet Engine
Apache Tomcat 3.1 or 3.2 Web Server + Tomcat 3.1 or 3.2 Servlet Engine
Caucho Resin 1.1 (Built-in JSP 1.0 Support)
NewAtlanta ServletExec 2.2 and 3.0 for IIS/PWS 4.0 (Built-in JSP 1.0 Support)
Oracle8i Lite Web-to-Go Server with Oracle JSP 1.0
Oracle8i 8.1.7 Oracle Servlet Engine
Any Servlet Engine with Servlet API 2.1+ and Oracle JSP 1.0
In general, it should work with any servlet engine supporting the Servlet 2.1 Specification or higher, and the Oracle JSP 1.0 reference implementation or functional equivalent from another vendor.
The Oracle XSQL Page processor has been designed to exploit the maximum set of features against the Oracle JDBC drivers, but gracefully degrade to work against any database with a reasonable JDBC driver. While numerous users have reported successfully using XSQL Pages with many other JDBC drivers, the ones that we have tested in-house are:
Oracle8i 8.1.5 Driver for JDBC 1.x
Oracle8i 8.1.6 Driver for JDBC 1.x
Oracle8i 8.1.7 Driver for JDBC 1.x
Oracle8i Lite 4.0 Driver for JDBC 1.x
Oracle8i 8.1.6 Driver for JDBC 2.0
Oracle8i 8.1.7 Driver for JDBC 2.0
|
|
Note
:
If you are using the Oracle 8i 8.1.6 Driver for JDBC 2.0 (in classes12.zip) you must download and use the corresponding Oracle XML SQL Utility for JDBC 2.0 (in XSU12.zip) from Oracle Technology Network. |
|
|
Note
:
The XSQL Servlet distribution comes with the files necessary to use the Oracle 8.1.7 JDBC driver in "Thin" Java mode for single-byte languages. If you want to use:
Please download the entire Oracle 8.1.7 JDBC distribution from Technet. |
Oracle XSQL Pages 9.0.1.0.0 depends on:
Oracle XML Parser V2, version 2.0.2.9 or higher
Oracle XML SQL Utilities for Java, version 2.0.1 or higher
A Web Server that supports Java Servlets
A JDBC driver, like Oracle JDBC or Oracle8i Lite JDBC
For your convenience, all of these dependent libraries are included with the XSQL Servlet distribution when you download it.
In addition to the Oracle XSQL Servlet archive itself in
Oracle XML Parser V2, version 2.0.2.10 in
Oracle XML SQL Utility, version 2.0.1 in
Oracle 8i 8.1.7 JDBC "Thin" Driver
(Production) in
SAX2
Interfaces and Helper Classes in
Beta releases of the following Oracle XDK components with which XSQL Servlet is also compatible can be downloaded separately from OTN:
Oracle XML Parser V2, version 2.1.0.0 (Beta)
Oracle XML SQL Utility, version 2.1.0 (Beta)
|
|
Note
:
If you download either or both of these beta releases, the
installation instructions below make the assumption that you have copied their
respective |
You can download the XSQL Servlet distribution by:
Clicking on the 'Software' icon at the top of the page:
|
Logging in with your OTN username and password (registration is free if you do not already have an account).
Selecting whether you want the NT or Unix download (both contain the same files)
Acknowledging the licensing agreement and download survey
Clicking on
To extract the contents of the XSQL Servlet distribution, do the following:
Choose a directory under which you would like the
Change directory to
tar xvfz xsqlservlet_v9_0_1_0_0.tar.gz
on Unix, or on Windows:
pkzip25 -extract -directories xsqlservlet_v9_0_1_0_0.zip
using the pkzip25 command-line tool or the WinZip visual archive extraction tool.
The XSQL Servlet comes bundled with the Oracle Web-to-go server that is pre-configured to use XSQL Pages. The Web-to-go web server is a single-user server, supporting the Servlet 2.1 API, used for mobile application deployment and for development. This is a great way to try XSQL Pages out on your Windows machine before delving into the details of configuring another Servlet Engine to run XSQL Pages.
|
|
Note
:
The Web-to-go Web server is part of Oracle's development and deployment platform for mobile applications.For more information on Web-to-go, please visit http://www.oracle.com/mobile |
Windows users can get started quickly with XSQL Pages by:
Running the
Browsing the URL
If you get an error starting this script, edit the
REM ---------------------------------------------- REM Set the 'JAVA' variable equal to the full path REM of your Java executable. REM ---------------------------------------------- set JAVA=J:\java1.2\jre\bin\java.exe set XSQL_HOME=C:\xsql REM ---------------------------------------------- REM Set the 'XSQL_HOME' variable equal to the full REM path of where you install the XSQL Servlet REM distribution. REM ----------------------------------------------
If you install XSQL into a directory other than
[FILESYSTEM] TYPE=OS ROOT_DIR=C:\
to:
[FILESYSTEM] TYPE=OS ROOT_DIR=D:\
Then, repeat the two steps above.
If you get an error connecting to the database when you try the
demos, you'll need to go on to the next section, then try the steps above again
after setting up your database connection information correctly in the
The demos are set up to use the
<?xml version="1.0" ?>
<XSQLConfig>
:
<connectiondefs>
<connection name="demo">
<username>scott</username>
<password>tiger</password>
<dburl>jdbc:oracle:thin:@localhost:1521:ORCL</dburl>
<driver>oracle.jdbc.driver.OracleDriver</driver>
</connection>
<connection name="lite">
<username>system</username>
<password>manager</password>
<dburl>jdbc:Polite:POlite</dburl>
<driver>oracle.lite.poljdbc.POLJDBCDriver</driver>
</connection>
</connectiondefs>
:
</XSQLConfig>
Unix users and any user wanting to install the XSQL Servlet on other web servers should continue with the instructions below depending on the web server you're trying to use. In every case, there are 3 basic steps:
Include the list of XSQL Java archives:
or the JAR file for the JDBC driver you will be using instead
as well as the directory where
|
|
Note
:
In a production system, make sure your
|
|
|
Note
:
For convenience, the
|
Map the
Map a virtual directory
Oracle IAS release 1.0 and beyond comes pre-configured to run
XSQL Servlet. By default it's Apache JServ servlet engine contains all of the
|
|
Note
:
In a production system, make sure your
|
Setup the Server CLASSPATH Correctly for the XSQL Servlet
This is done by starting the JRun Administrator, clicking on the General tab, and clicking on the Java subtab as shown below.
|
Append the list of JAR files and directory that need to be
in the server CLASSPATH for the XSQL Servlet to the existing value in the Java
Classpath field. Assuming you installed into
To use the Oracle JDBC 1.x Driver, the list looks like:
C:\xsql\lib\sax2.jar;
C:\xsql\lib\xsu111.jar;
C:\xsql\lib\xmlparserv2.jar;
C:\xsql\lib\classes111.zip;
C:\xsql\lib\oraclexsql.jar;
directory_where_XSQLConfig.xml_resides
To use Apache FOP for PDF Generation, you need to add:
C:\xsql\lib\xsqlserializers.jar; FOPHOME/fop_bin_0_14_0.jar; FOPHOME/lib/w3c.jar
To use the Oracle JDBC 2.0 Driver, the list looks like:
C:\xsql\lib\sax2.jar;
C:\xsql\lib\xsu12.jar;
C:\xsql\lib\xmlparserv2.jar;
C:\xsql\lib\classes12.zip;
C:\xsql\lib\oraclexsql.jar;
directory_where_XSQLConfig.xml_resides
To use Apache FOP for PDF Generation, you need to add:
C:\xsql\lib\xsqlserializers.jar; FOPHOME/fop_bin_0_14_0.jar; FOPHOME/lib/w3c.jar
Map the
To do this, select the Services tab in the JRun Administrator and select the appropriate "JRun Servlet Engine for XXX" entry for the Servlet Engine that corresponds to the web server that you are using. In the example below, we'll show configuring the Servlet Engine for the (built-in) JRun Web Server (JWS).
|
Then click the Service Config button...
On the Service Config screen, select the Mappings tab.
|
Click the Add button and make an entry for the
Map an
In this step, we want to map the virtual path
If you are using JRun together with another web server like Apache, IIS, or others, the virtual directory mapping needs to be done using the web server configuration file/utility. If you are using the JRun Web Server, then you can configure this virtual path mapping from the JRun Adminstrator. To do this, select the "jws" service and click on Service Config.
|
Click on the Path Settings tab on the Service Config dialog, and click the Add button as show below.
|
Make an entry for a virtual path of
Restart the JRun server and browse the URL:
http://localhost:8000/xsql/index.html
Setup the Server CLASSPATH Correctly for the XSQL Servlet
This is done by editing the JServ configuration file named
To use the Oracle JDBC 1.x Driver, the entries look like:
# Oracle XML SQL Utility (XSU) wrapper.classpath=C:\xsql\lib\sax2.jar wrapper.classpath=C:\xsql\lib\xsu111.jar # Oracle XSQL Servlet wrapper.classpath=C:\xsql\lib\oraclexsql.jar # Oracle JDBC (8.1.6) -- JDBC 1.x driver wrapper.classpath=C:\xsql\lib\classes111.zip # Oracle XML Parser V2 (with XSLT Engine) wrapper.classpath=C:\xsql\lib\xmlparserv2.jar # XSQLConfig.xml File location wrapper.classpath=directory_where_XSQLConfig.xml_resides # FOR Apache FOP Generation, Add # wrapper.classpath=C:\xsql\lib\xsqlserializers.jar # wrapper.classpath=FOPHOME/fop_bin_0_14_0.jar # wrapper.classpath=FOPHOME/lib/w3c.jar
To use the Oracle JDBC 2.0 Driver, the list looks like:
# Oracle XML SQL Utility (XSU) wrapper.classpath=C:\xsql\lib\sax2.jar wrapper.classpath=C:\xsql\lib\xsu12.jar # Oracle XSQL Servlet wrapper.classpath=C:\xsql\lib\oraclexsql.jar # Oracle JDBC (8.1.6) -- JDBC 2.0 driver wrapper.classpath=C:\xsql\lib\classes12.zip # Oracle XML Parser V2 (with XSLT Engine) wrapper.classpath=C:\xsql\lib\xmlparserv2.jar # XSQLConfig.xml File location wrapper.classpath=directory_where_XSQLConfig.xml_resides # FOR Apache FOP Generation, Add # wrapper.classpath=C:\xsql\lib\xsqlserializers.jar # wrapper.classpath=FOPHOME/fop_bin_0_14_0.jar # wrapper.classpath=FOPHOME/lib/w3c.jar
Map the
To do this, you need to edit the JServ configuration file
named
# Executes a servlet passing filename with proper extension in PATH_TRANSLATED # property of servlet request. # Syntax: ApJServAction [extension] [servlet-uri] # Defaults: NONE ApJServAction .xsql /servlets/oracle.xml.xsql.XSQLServlet
Map an
In this step, we want to map the virtual path
Alias /xsql/ "C:/xsql/"
Restart the Apache server and browse the URL:
http://localhost/xsql/index.html
Setup the Server CLASSPATH Correctly for the XSQL Servlet
This is done by editing the Tomcat startup script named
To use the Oracle JDBC 1.x Driver, the entries look like:
rem Set up the CLASSPATH that we need set cp=%CLASSPATH% set CLASSPATH=. set CLASSPATH=%TOMCAT_HOME%\classes set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\webserver.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\jasper.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\xml.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\servlet.jar set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\lib\tools.jar REM Added for Oracle XSQL Servlet REM ----------------------------- set CLASSPATH=%CLASSPATH%;C:\xsql\lib\sax2.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xsu111.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\oraclexsql.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xmlparserv2.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\classes111.zip set CLASSPATH=%CLASSPATH%;directory_where_XSQLConfig.xml_resides REM FOR Apache FOP Generation, Add REM set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xsqlserializers.jar REM set CLASSPATH=%CLASSPATH%;FOPHOME/fop_bin_0_14_0.jar REM set CLASSPATH=%CLASSPATH%;FOPHOME/lib/w3c.jar
To use the Oracle JDBC 2.0 Driver, the list looks like:
rem Set up the CLASSPATH that we need set cp=%CLASSPATH% set CLASSPATH=. set CLASSPATH=%TOMCAT_HOME%\classes set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\webserver.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\jasper.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\xml.jar set CLASSPATH=%CLASSPATH%;%TOMCAT_HOME%\lib\servlet.jar set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\lib\tools.jar REM Added for Oracle XSQL Servlet REM ----------------------------- set CLASSPATH=%CLASSPATH%;C:\xsql\lib\sax2.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xsu12.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\oraclexsql.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xmlparserv2.jar set CLASSPATH=%CLASSPATH%;C:\xsql\lib\classes12.zip set CLASSPATH=%CLASSPATH%;directory_where_XSQLConfig.xml_resides REM FOR Apache FOP Generation, Add REM set CLASSPATH=%CLASSPATH%;C:\xsql\lib\xsqlserializers.jar REM set CLASSPATH=%CLASSPATH%;FOPHOME/fop_bin_0_14_0.jar REM set CLASSPATH=%CLASSPATH%;FOPHOME/lib/w3c.jar
Map the
Tomcat supports creating any number of configuration "contexts" to better organize the web applications your site needs to support. Each context is mapped to a virtual directory path, and has its own separate servlet configuration information. XSQL Servlet comes with a pre-configured context file to make XSQL Servlet setup easier.
By default, Tomcat 3.1 and 3.2 come pre-configured with the
following contexts (defined by
The root context
We could install XSQL Servlet into one of these, but for simplicity we'll create a new context just for the XSQL Servlet that maps to the directory where you installed the XSQL Servlet distribution.
Edit the
<Context path="/technology/test" docBase="webapps/test" debug="0" reloadable="true" /> <!-- | Define a Servlet context for the XSQL Servlet | | The XSQL Servlet ships with a .\WEB-INF directory | with its web.xml file pre-configured for C:\xsql | installation. +--> <Context path="/technology/xsql" docBase="C:\xsql"/>
Note that the
|
|
Note
:
To add the XSQL Servlet to an existing context, add the
servlet and servlet-mapping entries that you find in
|
Map an
This is already achieved by creating the
Restart the Tomcat server and browse the URL:
http://localhost:8080/xsql/index.html
Setup the Server CLASSPATH Correctly for the XSQL Servlet
This is done by browsing the url http://localhost/servlet/admin after starting the IIS Server, and clicking the VM Settings link under "Advanced" in the sidebar.
|
Add the four archives and one directory as shown above, by adding them one at a time and clicking the Submit button after each new entry.
Map the
Click on Configure under the
"Servlets" heading in the sidebar to browse the form where you register
servlets. Enter a Servlet Name of
|
Then, click on Aliases under "Servlets" in the sidebar.
Add an entry as shown below mapping
|
Map an
Use the IIS Admin console to create an
|
Restart the IIS server and browse the URL:
http://localhost/xsql/index.html
Oracle 8i release 3 (version 8.1.7) ships
with the Oracle Servlet Engine, a Servlet 2.2-compliant servlet engine that
runs on the database Java VM. You can install the XSQL Servlet on the OSE
servlet engine and dispatch requests to it using an Apache web server (via
The following instructions assume you are starting with a brand new Oracle8i release 3 installation and have not yet defined any web service, endpoint, or web domain. If you already have a web domain created into which you want to publish the XSQL Servlet, you can ....
Insure that the XML SQL Utility is loaded into the database
with appropriate public synonyms so the XSQL schema can resolve its classes. By
default, the 8.1.7 release ships with a version of the
Edit
Find the line:
call sys.dbms_java.loadjava('-v -r -grant PUBLIC rdbms/jlib/xsu12.jar');
Change it to read:
call sys.dbms_java.loadjava('-v -r -grant PUBLIC -synonym rdbms/jlib/xsu12.jar');
Rerun this edited
Create a database user named
Load the contents of
loadjava -user XSQL/XSQL -verbose -resolve oraclexsql.jar
|
|
Note
:
Resolution errors relating to "FOP" and to "XMLNodeUtil" are harmless and can be ignored. |
Create a new web service with a single endpoint and make the XSQL user the owner
Launch the session shell utility, connecting as
sess_sh -user SYS/password -service sess_iiop://your817server:2481:ORCL
Destroy any existing service named
destroyservice -all XSQLWebService
Create a service named
createwebservice -root /XSQLWebService XSQLWebService
Change the owner of
chown XSQL /XSQLWebService
Recursively give read, write, execute privs to every
object in the
chmod -R +rwx XSQL /XSQLWebService
Add an endpoint for the service to accept HTTP requests on any convenient port (e.g. 8182):
addendpoint -port 8182 XSQLWebService XSQLWebService8182
Exit the session shell utility (logged in as SYS).
exit
As XSQL, use the session shell utility to create a web domain and publish the XSQL Servlet into it:
Launch the session shell utility, connecting as
sess_sh -user XSQL/XSQL -service sess_iiop://your817server:2481:ORCL
Create a web domain, mapping its virtual root directory to a convenient physical file system directory:
createwebdomain -docroot F:\oracle\htdocs /XSQLWebService
Publish the XSQL Servlet into the default context of this new domain. The options below should be entered all on a single line when typed in:
publishservlet -virtualpath *.xsql
-stateless
/XSQLWebService/contexts/default
xsql
XSQL:oracle.xml.xsql.XSQLServlet
To setup an MTS-based HTTP listener running inside the
database, add the following line to your database's
mts_dispatchers = "(ADDRESS=(PROTOCOL=tcp)(HOST=localhost)(PORT=8182))(PRE=http://XSQLWebService)"
Stop and restart your database
Edit the default
Use the KPRB driver connection string in the
<connection name="demo">
<username>scott</username>
<password>tiger</password>
<dburl>jdbc:oracle:kprb:@</dburl> <!-- CHANGE THIS LINE -->
<driver>oracle.jdbc.driver.OracleDriver</driver>
</connection>
Disable connection pooling by editing the
<connection-pool>
<initial>1</initial>
<increment>0</increment>
<timeout-seconds>60</timeout-seconds>
<dump-allowed>no</dump-allowed>
</connection-pool>
Load the
loadjava -user XSQL/XSQL -verbose XSQLConfig.xml
Copy any XSQL pages that you want to run into the physical directory that you mapped as the virtual root of the XSQLWebService above, then request them by URL from the web server running inside the database like:
http://your817server:8182/foo.xsql
or
http://your817server:8182/any/subdirectory/foo.xsql
To setup the data for the demos do the following:
Change directory to the
In this directory, run SQLPLUS. Connect to your database as
GRANT EXECUTE ON CTX_DDL TO SCOTT;
Connect to your database as
GRANT QUERY REWRITE TO SCOTT;
This allows SCOTT to create a functional index that one of the demos uses to perform case-insensitive queries on descriptions of airports.
Connect to your database as
Run the script
Change directory to the
|
|
Note
:
To properly experience the Scalable Vector Graphics demonstration, you need to install an SVG plugin into your browser like the Adobe SVG Plugin. |
To use Oracle XSQL Pages just include a
The XSQL Page Processor expects to find an attribute named
The simplest usage of the
<?xml version="1.0"?> <xsql:query xmlns:xsql="urn:oracle-xsql" connection="demo"> SELECT 'Hello World' AS "GREETING" FROM DUAL </xsql:query>which produces the resulting dynamically created XML document:
<?xml version = '1.0'?>
<ROWSET>
<ROW id="1">
<GREETING>Hello World</GREETING>
</ROW>
</ROWSET>
An |
|
Note
:
To have the dynamic XML-results of your
|
For example, you could build up a "data page" out of two queries like this:
<?xml version="1.0"?>
<sales-by-year xmlns:xsql="urn:oracle-xsql" connection="salesdb">
<period id="H1" year="CY99">
<xsql:query>
SELECT salesperson, SUM(sales) AS Total
FROM sales
WHERE sale_date between '01-JAN-99' and '30-JUN-99'
GROUP BY salesperson
</xsql:query>
</period>
<period id="H2" year="CY99">
<xsql:query>
SELECT salesperson, SUM(sales) AS Total
FROM sales
WHERE sale_date between '01-JUL-99' and '31-DEC-99'
GROUP BY salesperson
</xsql:query>
</period>
</sales-by-year>
which would produce results like:
<?xml version="1.0"?>
<sales-by-year connection="salesdb">
<period id="H1" year="CY99">
<ROWSET>
<ROW id="1">
<SALESPERSON>Steve</SALESPERSON>
<TOTAL>23465500</TOTAL>
</ROW>
<ROW id="2">
<SALESPERSON>Mark</SALESPERSON>
<TOTAL>39983400</TOTAL>
</ROW>
</ROWSET>
</period>
<period id="H2" year="CY99">
<ROWSET>
<ROW id="1">
<SALESPERSON>Steve</SALESPERSON>
<TOTAL>67788400</TOTAL>
</ROW>
<ROW id="2">
<SALESPERSON>Mark</SALESPERSON>
<TOTAL>55786990</TOTAL>
</ROW>
</ROWSET>
</period>
</sales-by-year>
While the two examples above show the default behavior for
SQL-to-XML query results, you can customize many of the aspects of the XML
query results produced for each
The following attribute-based options correspond one-to-one to
features offered by the underlying
The XSQL Page Processor supports the following (case-sensitive) attributes
on the
|
|
|
| Attribute Name | Description |
| |
Element name to use for the query results. Set equal to
the empty string to suppress printing a document element. (Default is
|
| |
Element name to use for each row in the query results. Set
equal to the empty string to supress printing a row element. (Default is
|
| |
Maximum number of rows to fetch from the query. Useful for
fetching the "top-N" or, in combination with |
| |
Number of rows to skip over before returning the query results. (Default is not skip any rows) |
| |
Attribute name for the id attribute for each row in the
query result. (Default is |
| |
Column name to use to supply the value of the id attribute for each row in the query result. (Default is to use the row count as the id attribute value) |
| |
If set to |
| |
If set to |
|
|
Ordered, space-separated list of XSQL parameter names to be bound to corresponding bind variables in the SQL statement. |
The SQL statement provided in the content of the
<?xml version="1.0"?>
<xsql:query xmlns:xsql="urn:oracle-xsql" connection="xmldemo"
airport = "SFO"
rowset-element = "Ok"
max-rows = "1"
row-element = "Airport" >
SELECT tla "Code", description "Description"
FROM AIRPORT
WHERE tla = UPPER('{@airport}')
</xsql:query>
to allow the HTTP request to supply the value of the
http://yourserver/xsql/demo/airport.xsql?airport=SQLThe example above would return the following XML document (Note the use of custom
<?xml version = '1.0'?>
<Ok>
<Airport id="1">
<programlisting>SQL</programlisting>
<Description>San Carlos, California, Usa</Description>
</Airport>
</Ok>
Nested inside a
This allows you to augment the example above to do:
<?xml version="1.0"?>
<xsql:query xmlns:xsql="urn:oracle-xsql"
connection = "xmldemo"
airport = "SFO"
rowset-element = "Ok"
max-rows = "1"
row-element = "Airport" >
SELECT tla "Code", description "Description"
FROM AIRPORT
WHERE tla = UPPER('{@airport}')
<xsql:no-rows-query
max-rows = "10"
rowset-element = "Error"
row-element = "Airport" >
SELECT tla "Code", description "Description"
FROM AIRPORT
WHERE UPPER(description) LIKE UPPER('%{@airport}%')
ORDER BY tla
</xsql:no-rows-query>
</xsql:query>
This example will initially attempt an exact match on an airport
using its three-letter code, and if that produces no matching rows, the error
query will attempt to do a LIKE match on the description. While the exact match
query specifies it wants to return a maximum of one row, the error query
returns up to the first 10 "fuzzy" matches on the candidate airport name passed
in in the
Here we explore how to use the powerful concept of an XSL Transformation to "morph" the XML document containing our SQL query results into HTML, XML of another format, or simply text.
The W3C-standard XSL Transformation Language (XSLT) gives us the power to describe arbitrary transformations of XML into XML, HTML, or Text. An XSLT transformation describes how a source document should be transformed into a target document. It works in concert with the W3C-standard XML Path Language (XPath) that offers a URL-like syntax for referring to any information in the source document that is required in the target document, as well as providing a basic set of string, number, and boolean functions to operate on that information as part of the transformation.
In its simplest form, an XSLT transformation is just template that:
Provides a literal example of the target document's structure, and
Includes special XSLT tags like
Given the XML output of an
<?xml version="1.0"?>
<query connection="demo" id="7839">
SELECT *
FROM EMP
WHERE EMPNO = {@id}
</query>
you can use an XSL Transformation like:
<html xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<head>
<title>Employee Info</title>
</head>
<body>
<table border="1" cellspacing="0">
<tr>
<th>Employee Name</th>
<th>Salary</th>
</tr>
<xsl:for-each select="ROWSET/ROW">
<tr>
<td><xsl:value-of select="ENAME"/></td>
<td><xsl:value-of select="SAL"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
to produce HTML output like:
|
or an XSL Transformation like:
<hr:people-group xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:hr="/human-resources">
<hr:group-members><xsl:value-of select="count(ROWSET/ROW)"/></hr:group-members>
<hr:people>
<xsl:for-each select="ROWSET/ROW">
<hr:person>
<hr:name><xsl:value-of select="ENAME"/></hr:name>
<hr:wages><xsl:value-of select="SAL"/></hr:wages>
</hr:person>
</xsl:for-each>
</hr:people>
</hr:people-group>
to produce XML output complying with a fictitious Human Resources schema, requiring the XML to be in a particular format like:
|
In both the HTML and XML examples the template for the target
document can literally represent the transformation, provided that you declare
the
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
on the document element of the target page before making use of
the special
In both transformation examples above, notice that the value of
the
Your intuition about filesystem "paths" and web URL "paths"
should serve you well when using XPath expressions. If you think of the
elements in the source document like directory names, then you'll quickly find
an expression like
|
Just like directories in a filesystem an XPath that starts with a slash is an absolute path from the "root" of the source document while an XPath that does not start with a slash is relative to the current context. This explains why an expression like:
can be used nested inside of an:
element to refer relatively to the
Now let's learn how to put an XSL Transformation into action in our programs.
As we learned above, rather than returning the raw "datapage" document produced by processing your XSQL Page, you can use an XSL Transformation to transform those results into XML, HTML, or text by adding one line to the top of your XSQL page:
<?xml-stylesheet type="text/xsl" href="transformname.xsl"?>
This is the W3C Standard mechanism of Associating Style Sheets with XML Documents.
The result of adding a line like this to the top of our page from above:
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="emphtml.xsl"?>
<query connection="demo" id="7839">
SELECT *
FROM EMP
WHERE EMPNO = {@id}
</query>
causes the "raw" datapage to be transformed by the
http://yourmachine/xmlinout/emp.xsql?id=7499
produces the HTML page:
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Employee Info</title>
</head>
<body>
<table border="1" cellspacing="0">
<tr>
<th>Employee Name</th>
<th>Salary</th>
</tr>
<tr>
<td>ALLEN</td>
<td>1600</td>
</tr>
</table>
</body>
</html>
So by writing an XSQL page with some queries and associatng an XSL Transform to it, you can publish any data in your database into any desired XML, HTML, or Textual format that you need over the web without writing code. See the demos that accompany the XSQL Servlet release for lots of examples of combining SQL, XML, and XSLT.
As we've seen, if you include an
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="emp.xsl"?>
<xsql:query xmlns:xsql="urn:oracle-xsql"
connection = "demo"
rowset-element = "employee-list"
row-element = "employee"
tag-case = "lower" >
SELECT *
FROM EMP
ORDER BY SAL DESC
</xsql:query>
would use the
Multiple
For example, the following processing instructions at the top of
an
<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" media="lynx" href="doyouxml-lynx.xsl" ?> <?xml-stylesheet type="text/xsl" media="msie" href="doyouxml-ie.xsl" ?> <?xml-stylesheet type="text/xsl" href="doyouxml.xsl" ?> <datapage xmlns:xsql="urn:oracle-xsql" connection="demo"> : :
will use
One additional pseudo-attributes can be supplied on the
|
|
|
| Attribute Name | Description |
| |
Must be present and be set to the value
|
|
|
Must be present. It indicates the relative or absolute URL to the stylesheet to be used. |
| |
This value is optional. If set, this attribute's value is used to perform a case-insensitive match on the User-Agent string of the requesting browser so that an appropriate stylesheet can be used depending on the requesting software/device. |
|
|
If set to " |
so a modified example using these extra attributes would look like:
<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" media="lynx" href="doyouxml-lynx.xsl" ?> <?xml-stylesheet type="text/xsl" media="msie 5.0" client="yes" href="doyouxml-ie5.xsl" ?> <?xml-stylesheet type="text/xsl" href="doyouxml.xsl" ?> <datapage connection="xmldemo">
which will have the following behavior:
If the browser is Lynx, use
If the browser is Internet Explorer 5.0, use
Otherwise, use
If the XSQL page has not explicitly forbidden it, you may also
supply the XSL stylesheet URL as part of the HTTP request by specifying an
extra URL parameter named
http://yourserver/yourdatapage.xsql?param1=value&xml-stylesheet=yourstyle.xsl
will cause the XSQL Page Processor to add the
If you want to force the
http://yourserver/yourdatapage.xsql?param1=value&xml-stylesheet=none
This can be useful during development.
You can supply the additional
|
|
Note
:
Any XSQL page can prevent externally-supplied stylesheets from
being considered by the XSQL Page Processor by including the XML
attribute |
|
|
Note
:
The XSQL Page Processor performs the same stylesheet processing
mechanics regardless of whether your |
The XSQL Pages we've seen so far all show examples of using the
Structured columns can be one of three types:
Strongly Typed, User-Defined Object
Strongly Typed, User-Defined Collection
Untyped Collection based on a SQL statement
Since the underlying Oracle XML SQL Utility for Java natively supports all of these combinations for producing richly structure XML from SQL statements that make use of these features, your Oracle XSQL Pages gain this capability for "free". We'll look at two simple examples...
If you have used the object/relational capabilities of
Oracle8i to create a user-defined object type called
CREATE TYPE POINT AS OBJECT (X NUMBER, Y NUMBER);
and have used your new
CREATE TABLE LOCATION ( NAME VARCHAR2(80), ORIGIN POINT );
and have inserted a row into this
INSERT INTO LOCATION VALUES ( 'Someplace', POINT(11,17) ); COMMIT;
Then, an XSQL page like
<xsql:query connection="demo" xmlns:xsql="urn:oracle-xsql">
SELECT name, origin
FROM location loc
WHERE loc.origin.x = {@x-coord}
</xsql:query>
...when requested using a URL like:
http://yourmachine.com/xsql/demo/point.xsql?x-coord=11
produces the output:
<ROWSET>
<ROW num="1">
<NAME>Someplace</NAME>
<ORIGIN>
<X>11</X>
<Y>17</Y>
</ORIGIN>
</ROW>
</ROWSET>
This demonstrates how the nested
|
|
Note
:
See the supplied
|
If you have not created object types that contain a
pre-defined structure, you can still introduce nested
structure into your SQL queries using the
Taking the familar
<xsql:query connection="demo" xmlns:xsql="urn:oracle-xsql">
SELECT dname,
CURSOR( SELECT ename,sal
FROM emp
WHERE emp.deptno = dept.deptno) as employees /* Column Alias */
FROM dept
WHERE deptno = {@department}
</xsql:query>
Requesting this
http://yourserver.com/xsql/demo/empdept.xsql?department=10
produces the resulting XML "datapage":
<ROWSET>
<ROW num="1">
<DNAME>ACCOUNTING</DNAME>
<EMPLOYEES>
<EMPLOYEES_ROW num="1">
<ENAME>CLARK</ENAME>
<SAL>2450</SAL>
</EMPLOYEES_ROW>
<EMPLOYEES_ROW num="2">
<ENAME>KING</ENAME>
<SAL>5000</SAL>
</EMPLOYEES_ROW>
<EMPLOYEES_ROW num="3">
<ENAME>MILLER</ENAME>
<SAL>1300</SAL>
</EMPLOYEES_ROW>
</EMPLOYEES>
</ROW>
</ROWSET>
Note that the second column in the
Since the
One or more
One or more
The SQL statement that may appear within the
Any SQL statement can be included in an
you can quickly see how powerful, structured information can be created on the fly to get almost any structure you are looking for. This allows the processing speed of the database to be exploited for sorting and grouping instead of having to rely on slower techniques that would attempt these operations on flat data from within the XSLT stylesheet.
Of course, by using these query techniques in the
Oracle provides all the ingredients necessary to accomplish this task. The approach you take depends on whether you need to accomplish the insert from within your own Java program, or whether you want a simple, declarative way of inserting the target document.
The Oracle XML SQL Utility for Java contains the
The
The fact that
An arbitrary XML document
A database table
You can create an XSL Transformation that transforms the
source document
Let's say that the source document is an XML news feed like what you'll see if you browse the following URL from www.moreover.com ...
http://www.moreover.com/cgi-local/page?index_xml+xml
A shortened version of such a resulting XML document looks like this:
<?xml version="1.0"?>
<!DOCTYPE moreovernews SYSTEM "http://www.moreover.com/xml/moreovernews.dtd">
<moreovernews>
<article id="4227581">
<url>http://d.moreover.com/click/here.pl?x4227575</url>
<headline_text>Austin: webMethods gets deal with Dell</headline_text>
<source>dbusiness.com</source>
<media_type>text</media_type>
<cluster>XML and metadata news</cluster>
<tagline>Austin</tagline>
<document_url>http://washington.dbusiness.com/</document_url>
<harvest_time>Oct 30 1999 7:08AM</harvest_time>
<access_registration> </access_registration>
<access_status> </access_status>
</article>
<article id="4212701">
<url>http://d.moreover.com/click/here.pl?x4212698</url>
<headline_text>Microsoft continues XML push with resource kit</headline_text>
<source>InfoWorld</source>
<media_type>text</media_type>
<cluster>XML and metadata news</cluster>
<tagline></tagline>
<document_url>http://www.infoworld.com/</document_url>
<harvest_time>Oct 29 1999 7:27AM</harvest_time>
<access_registration> </access_registration>
<access_status> </access_status>
</article>
<article id="4202251">
<url>http://d.moreover.com/click/here.pl?x4202247</url>
<headline_text>IBM Brings XML To MQSeries</headline_text>
<source>Internet Week</source>
<media_type>text</media_type>
<cluster>XML and metadata news</cluster>
<tagline></tagline>
<document_url>http://www.internetwk.com/</document_url>
<harvest_time>Oct 28 1999 4:28PM</harvest_time>
<access_registration> </access_registration>
<access_status> </access_status>
</article>
<article id="4082434">
<url>http://d.moreover.com/click/here.pl?x4082432</url>
<headline_text>XML leader OnDisplay's travel clients praised</headline_text>
<source>Web Travel News</source>
<media_type>text</media_type>
<cluster>XML and metadata news</cluster>
<tagline></tagline>
<document_url>http://www.webtravelnews.com/</document_url>
<harvest_time>Oct 20 1999 7:34AM</harvest_time>
<access_registration> </access_registration>
<access_status> </access_status>
</article>
</moreovernews>
Next, let's say that you have a table called
CREATE TABLE newsstory( id NUMBER PRIMARY KEY, title VARCHAR2(200), url VARCHAR2(200), source VARCHAR2(200) );
And further, let's suppose that you want to insert information from the XML news feed from Moreover.com into this table.
So, we need to produce an XSL transformation that transforms the
information in the XML news feed from Moreover.com into the canonical format
that
We start by using an XSQL page to quickly produce one row of
canonical query results from the
<?xml version="1.0"?> <query connection="demo" max-rows="1"> SELECT * FROM NEWSTORY </query>
We can either request this page through the webserver, or more conveninently for this job, use the XSQL Command Line Utility to quickly put the XSQL Page's output into a file:
xsql newstory.xsql newsstory.xml
This command processes the
<?xml version = '1.0'?>
<ROWSET>
<ROW num="1">
<ID>1911</ID>
<TITLE>Some Title</TITLE>
<URL>http://somemachine/somepage.html</URL>
<SOURCE>SomeSource</SOURCE>
</ROW>
</ROWSET>
We can take this one row of canonical output from a
"
Add an
Remove the
Remove any elements corresponding to columns whose values will be assigned by database triggers, like the ID column will be in this example,
Surround the
Replace the literal text between the
The result of applying the changes outlined in the three steps above to the sample output of the:
query produces the following XSL Transformation:
<?xml version = '1.0'?>
<ROWSET xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:for-each select="moreovernews/article">
<ROW>
<TITLE><xsl:value-of select="headline_text"/></TITLE>
<URL><xsl:value-of select="url"/></URL>
<SOURCE>Moreover.com</SOURCE>
</ROW>
</xsl:for-each>
</ROWSET>
Which illustrates that we have:
Added the
<ROWSET xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Added the
<xsl:for-each select="moreovernews/article">
so that for each
Removed the
Changed the:
<TITLE>Some Title</TITLE> <URL>http://somemachine/somepage.html</URL>
tags to:
<TITLE><xsl:value-of select="headline_text"/></TITLE> <URL><xsl:value-of select="url"/></URL>
to plug-in the value of the current
Hard-coded the value of the
If we rename the now-edited
java oracle.xml.parser.v2.oraxsl moreover.xml moreover-to-newsstory.xsl out.xml
|
|
Note
:
Since the <!DOCTYPE moreovernews
SYSTEM "http://www.moreover.com/xml/moreovernews.dtd">
declaration with an java -DproxySet=true
-DproxyHost=proxyServerName
-DproxyPort=80 oracle.xml.parser.v2.oraxsl ...
|
If we use Internet Explorer to browse the resulting
|
If we pass this resulting target document to the
The last step before showing how to tie it all together using Java or XSQL Pages is to create the database trigger to automatically assign the value of the ID column on insert. Assuming we have a sequence named newsstory_id_seq lying around, the code looks like:
CREATE TRIGGER newsstory_autoid
BEFORE INSERT ON newsstory FOR EACH ROW
BEGIN
SELECT newsstory_id_seq.nextval
INTO :new.id
FROM dual;
END;
The general steps for inserting XML into the database are:
Choose the table or view you want to use for inserting the XML information,
Create an XSL Transformation that transforms the inbound document into the canonical format for this table or view,
We saw a "cookbook" approach above for how to do this easily
based on a
Transform the inbound document into the canonical format for the table or view into which you want to insert it, and
Let
Oracle XSQL Pages support a simple
<xsql:insert-request
table="tableorviewname"
transform="transformname.xsl"/>
to the top of your XSQL page to perform the four steps above
automatically. So, for example, the following XSQL Page would accept
information posted through HTTP in the Moreover.com moreovernews format, and
insert it into the
<?xml version="1.0?>
<xsql:insert-request xmlns:xsql="urn:oracle-xsql"
connection="demo"
table="newsstory"
transform="moreover-to-newsstory.xsl"/>
Running this program retrieves the newsstories and inserts them
into our
Due to the nature of this news feed, news stories stay in the
feed for a few days. If we want to avoid inserting the same story over and over
again, we can easily do that by making sure we don't insert a story unless its
Title and URL are a unique combination in our
Let's implement this behavior using a database
Since
CREATE VIEW newsstoryview AS SELECT * FROM newsstory
Then we can create the
CREATE OR REPLACE TRIGGER insteadOfIns_newsstoryview
INSTEAD OF INSERT ON newsstoryview FOR EACH ROW
DECLARE
notThere BOOLEAN := TRUE;
tmp VARCHAR2(1);
CURSOR chk IS SELECT 'x'
FROM newsstory
WHERE title = :new.title
AND url = :new.url;
BEGIN
OPEN chk;
FETCH chk INTO tmp;
notThere := chk%NOTFOUND;
CLOSE chk;
IF notThere THEN
INSERT INTO newsstory(title,url,source)
VALUES (:new.title,:new.url,:new.source);
END IF;
END;
Here we are assuming that "uniqueness" of a story is defined by
the combination of its
CREATE UNIQUE INDEX newsstory_unique_title_url on newsstory(title,url);
We've written the body of the trigger in PL/SQL to demonstrate that you can mix and match PL/SQL and Java in this solution, but in Oracle8i we could have also written the INSTEAD OF trigger to call a Java Stored Procedures as well to perform the uniqueness check.
Finally, the only thing left to do is to change the
xsql:insert-request action element above to use the
<?xml version="1.0?>
<xsql:insert-request xmlns:xsql="urn:oracle-xsql"
connection="demo"
table="newsstoryview"
transform="moreover-to-newsstory.xsl"/>
Now, only unique newstories from the Moreover XML news feed will be inserted.
|
|
Note
:
Using the same |
The
<?xml version="1.0"?>
<page connection="demo" xmlns:xsql="urn:oracle-xsql">
<xsql:insert-request table="newsstoryview" transform="moreover-to-newsstory.xsl"/>
<lateststories>
<xsql:query tag-case="lower" max-rows="5" rowset-element="" row-element="story" >
select *
from newsstory
order by id desc
</xsql:query>
</lateststories>
</page>
The XSQL page above inserts any posted XML document containing
|
When XML is posted to a web server through HTTP, it's ContentType
is
<request>
<parameters>
<firstparamname>firstparamvalue</firstparamname>
:
<lastparamname>lastparamvalue</lastparamname>
</parameters>
<session>
<firstparamname>firstsessionparamvalue</firstparamname>
:
<lastparamname>lastsessionparamvalue</lastparamname>
</session>
<cookies>
<firstcookie>firstcookievalue</firstcookiename>
:
<lastcookie>firstcookievalue</lastcookiename>
</cookies>
</request>
and then allows an
|
|
Note
:
If multiple parameters are posted with the same name, then they will automatically be "row-ified" to make subsequent processing easier. This means, for example, that a request which posts or includes the following parameters:
Will create a "row-ified" set of parameters like: <request>
<parameters>
<row>
<id>101</id>
<name>Steve</name>
</row>
<row>
<id>102</id>
<name>Sita</name>
</row>
<operation>update</operation>
</parameters>
:
</request>
|
Using an
<xsql:insert-request
table="newsstoryview"
transform="request-to-newsstoryview.xsl"/
and by referencing the name of the
<?xml version = '1.0'?>
<ROWSET xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xsl:version="1.0">
<xsl:for-each select="request/parameters">
<ROW>
<TITLE><xsl:value-of select="title_field"/></TITLE>
<URL><xsl:value-of select="url_field"/></URL>
<SOURCE>User-Submitted</SOURCE>
</ROW>
</xsl:for-each>
</ROWSET>
If the above XSQL page were saved as
<html>
<body>
Insert a new news story...
<form action="insertnewsform.xsql" method="post">
<b>Title</b><input type="text" name="title_field" size="30"><br>
<b>URL</b><input type="text" name="url_field" size="30"><br>
<br>
<input type="submit">
</form>
<body>
</html>
If we let a user fill-out and post the form as-is, they will get
raw XML as a response from the
Using the mechanism we learned in the previous section for
associating XSL Stylesheets with XSQL Pages, we can include an
<html xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<head>
<title>Latest Stories</title>
</head>
<body>
<h2>Thanks for your Story!</h2>
Here's a list of the latest stories we've received...
<table border="0" cellspacing="0">
<xsl:for-each select="page/lateststories/story">
<tr>
<td><a href="{url}"><xsl:value-of select="title"/></a></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
This means the
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="lateststories.xsl"?>
<page connection="demo" xmlns:xsql="urn:oracle-xsql">
<xsql:insert-request table="newsstoryview" transform="request-to-newsstory.xsl"/>
<lateststories>
<xsql:query tag-case="lower" max-rows="5" rowset-element="" row-element="story" >
select *
from newsstory
order by id desc
</xsql:query>
</lateststories>
</page>
Now when the user browses the
|
...then rather than seeing the raw XML datagram returned by the
|
as an HTML page instead of as raw XML.
So in addition to being possible for developers by using Java programs that leverage the Oracle XML SQL Utility directly, we've seen that it's easy to insert XML-based information into Oracle database tables or views without programming using XSQL Pages and XSLT Transformations.
|
|
Note
:
Here we've used simple examples with simple tables, however
The |
You can process any XSQL page at the command line by using the
java oracle.xml.xsql.XSQLCommandLine xsqlURI [outputFile] [param1=value1 ... paramN=valueN]
The
xsql xsqlURI [outputFile] [param1=value1 ... paramN=valueN]
So, for example, to test the demo file
xsql airport.xsql airport=sfo xml-stylesheet=noneto output the results of processing the
xsql airport.xsql output.html airport=sfoto output the results to the
To post an XML Document to an XSQL Page being processed by the
XSQLCommandLine utility, provide a URL or filename as the value of the
xsql insertnewsstory.xsql
posted-xml=http://p.moreover.com/cgi-local/page?index_xml+xml
This will use the XSQL Page named
The following is a list of all built-in Action Elements that you can use in your XSQL Pages. ..
| Action Element | Description |
|
|
Execute an arbitrary SQL statement and include its result set in canonical XML format. |
|
|
Execute a SQL DML statement or PL/SQL anonymous block. |
|
|
Set the value of a top-level XSLT stylesheet parameter. Value of the parameter can be set by supplying the optional "value" attribute, or by including a SQL statement as the element content. |
|
|
Insert the (optionally transformed) XML document that has been posted in the request into a database table or view. If HTML Form has been posted, then posted XML document is materialized from HTTP request parameters, cookies, and session variables. |
|
|
Include arbitrary XML resources at any point in your page by relative or absolute URL. |
|
|
Include key information like HTTP Parameters, Session Variable values and Cookies into your XSQL Page for addressing them in your stylesheet. |
|
|
Include the results of one XSQL Page at any point inside another. |
|
|
Include the results of executing a stored procedure that makes use of the Oracle Web Agent (OWA) packages inside the database to generate XML. |
|
|
Invoke a user-defined action handler, implemented in Java, for executing custom logic and including custom XML information into your XSQL Page. |
|
|
Includes the canonical XML representation of the result set of a cursor returned by a PL/SQL stored function. |
|
|
Set a page-level (local) parameter that can be referred to in subsequent SQL statements in the page. The value can be set using a static value, the value of another parameter, or the results of a SQL statement. |
|
|
Include a parameter and its value as an element in your XSQL page. |
|
|
Set an HTTP-Session level parameter. The value can be set using a static value, the value of another parameter, or the results of a SQL statement. |
|
|
Set an HTTP Cookie. The value can be set using a static value, the value of another parameter, or the results of a SQL statement. |
|
|
Inserts the value of a single parameter containing XML. Can optionally supply a transform to get it in canonical format. |
See the on-line help system for full details on each element. Additional notes on individual action elements follow below:
If you will be using the
If you run the XSQL Servlet from inside a corporate firewall,
then you will need to uncomment the
The results of the XML resource included by an
The format of the XML document fragment that is included when
you use
<request>
<parameters>
<param1>value1</param1>
<param2>value2</param2>
:
</parameters>
<session>
<name1>val1</name1>
<name2>val2</name2>
:
</session>
<cookies>
<cookiename1>value1</cookiename1>
:
</cookies>
</parameters>
For the HTTP case through the XSQL Servlet, and
<request>
<parameters>
<param1>value1</param1>
<param2>value2</param2>
:
</parameters>
</parameters>
for other types of requests like through the XSQL Command Line Utility, or through
the programmatic
The
<request>
<parameters>
<param1>value1</param1>
:
</paramN>valueN</paramN>
</parameters>
:
</request>
To determine the canonical format of the XML document needed
for automatic insert into a table or view using
query from the table/view in question and use it's output as the template for the canonical format.
Errors raised by the processing of any XSQL Action Elements are now reported as XML elements in a uniform way so XSL Stylesheets can easily detect the presence of errors and optionally format them for presentation if desired.
The action element in error will be replaced in the page by:
Depending on the error the
An example fragment of an XSLT stylesheet that would leverage this information to display error information on the screen would look like:
<xsl:if test="/technology//xsql-error">
<table style="background:yellow">
<xsl:for-each select="/technology//xsql-error">
<tr>
<td><b>Action</b></td>
<td><xsl:value-of select="@action"/></td>
</tr>
<tr valign="top">
<td><b>Message</b></td>
<td><xsl:value-of select="message"/></td>
</tr>
</xsl:for-each>
</table>
</xsl:if>
If your stylesheet uses an
JSP pages can use
Attributes of the
Client-overriding of stylesheets for an XSQL Page can be
disallowed with the new
The XSQL Page Processor loads the first
The
import oracle.xml.xsql.XSQLRequest;
import java.util.Hashtable;
import java.io.PrintWriter;
import java.net.URL;
public class XSQLRequestSample {
public static void main( String[] args) throws Exception {
// Construct the URL of the XSQL Page
URL pageUrl = new URL("file:///C:/foo/bar.xsql");
// Construct a new XSQL Page request
XSQLRequest req = new XSQLRequest(pageUrl);
// Setup a Hashtable of named parameters to pass to the request
Hashtable params = new Hashtable(3);
params.put("param1","value1");
params.put("param2","value2");
/* If needed, treat an existing, in-memory XMLDocument as if
** it were posted to the XSQL Page as part of the request
Example:
--------
req.setPostedDocument(myXMLDocument);
**
*/
// Process the page, passing the parameters and writing the output
// to standard out.
req.process(params,new PrintWriter(System.out)
,new PrintWriter(System.err));
}
}
You can also call
If you set the
<XSQLConfig>
:
<processor>
:
<connection-pool>
:
<dump-allowed>yes</dump-allowed>
</connection-pool>
:
</processor>
:
</XSQLConfig>
...then you can request diagnostic information about the XSQL Servlet's connection pooling and named connection definitions from a browser.
To request an XSQL Servlet connection pool diagnostic dump, add
the extra URL parameter
http://yoursever/your.xsql?dumppool=y
If you set the
<XSQLConfig>
:
<processor>
:
<timing-info>
<page>yes</page>
<action>no</action>
</timing-info>
:
</processor>
:
</XSQLConfig>
...then the requested level of timing information (in
milliseconds) will be included in the XSQL Page by the page processor.
Page-level timing information is included as an XML attribute named
The XSQL Page Processor processes an XSQL Page by:
Looking for "Action Elements" from the
Invoking an appropriate action element handler class to process the element.
Oracle XSQL Pages come with a number of built-in action handlers for the following basic XSQL action elements:
|
Built-in XSQL Action Elements and Action Handler Classes
|
|
| XSQL Action Element | Handler Class in
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Action Handlers are initialized by getting passed the
To create a custom Action Handler, you need to provide a class that
implements the
For convenience, you can save time by extending the base
implementation class named
|
|
Note
:
If you extend
// Call the superclass to intialize protected variables super(env,e); |
Illustrates an example of an action handler that replaces the
action element with the current value of the database
getPageRequest().getJDBCConnection()
you can gain access to the current JDBC connection being used
for this request. Note that the connection may be
Illustrates a handler that adds an element to the XSQL page
with the value of the indicated parameter. Shows a custom
The following example shows a custom action handler
import oracle.xml.xsql.*;
import oracle.xml.xsql.actions.XSQLIncludeXSQLHandler;
import org.w3c.dom.*;
import java.sql.SQLException;
public class MyIncludeXSQLHandler extends XSQLActionHandlerImpl {
XSQLActionHandler nestedHandler = null;
public void init(XSQLPageRequest req, Element action) {
super.init(req, action);
// Create an instance of an XSQLIncludeXSQLHandler
// and init() the handler by passing the current request/action
// This assumes the XSQLIncludeXSQLHandler will pick up its
// href="xxx.xsql" attribute from the current action element.
nestedHandler = new XSQLIncludeXSQLHandler();
nestedHandler.init(req,action);
}
public void handleAction(Node result) throws SQLException {
DocumentFragment df = result.getOwnerDocument().createDocumentFragment();
nestedHandler.handleAction(df);
// Custom Java code here can work on the returned document fragment
// before appending the final, modified document to the result node.
// For example, add an attribute to the first child
Element e = (Element)df.getFirstChild();
if (e != null) {
e.setAttribute("ExtraAttribute","SomeValue");
}
result.appendChild(df);
}
}
Lastly, note that if you create custom action handlers that need to
work differently based on whether the page is being requested through the XSQL Servlet,
or the XSQL Command Line Utility, or programmatically through the XSQLRequest class, then in your
Action Handler implementation you can call
XSQLServletPageRequest xspr = (XSQLServletPageRequest)getPageRequest();
if (xspr.getRequestType().equals("Servlet")) {
HttpServletRequest req = xspr.getHttpServletRequest();
HttpServletResponse resp = xspr.getHttpServletResponse();
// do something fun here with req and resp, however
// writing to the response directly from a handler will
// produce unexpected results. Allow the XSQL Servlet
// to write to the servlet's response output stream
// at the write moment later when all action elements
// have been processed.
}
To include an Action Element in your XSQL Page that invokes a
custom Action Handler that is implemented by the
<xsql:action handler="yourpackage.YourCustomHandler"/>
or
<xsql:action handler="yourpackage.YourCustomHandler" param="xxx"/>
or
<xsql:action handler="yourpackage.YourCustomHandler" param="xxx"> Any text or <element>content</element> </xsql:action>
For additional convenience, you can define entries in the
<actiondefs>
<action>
<elementname>param</elementname>
<handlerclass>oracle.xml.xsql.actions.ExampleGetParameterHandler</handlerclass>
</action>
<action>
<elementname>current-date</elementname>
<handlerclass>oracle.xml.xsql.actions.ExampleCurrentDBDateHandler</handlerclass>
</action>
</actiondefs>
These entries in the config file allow a page to use:
<xsql:param name="myparam"/>
instead of the more verbose:
<xsql:action handler="oracle.xml.xsql.actions.ExampleGetParameterHandler"
name="myparam"/>
and similarly
<xsql:current-date/>
instead of the more verbose:
<xsql:action handler="oracle.xml.xsql.actions.ExampleDBDateHandler"/>
The following demo files are part of this release. Instructions for installing the demos are included in the Installation section of these release notes.
|
Description of Demonstrations
|
|
| Demonstration Name
( |
Comments |
| Hello World
( |
Simplest possible XSQL page. |
| Do You XML Site
( |
XSQL page which shows how a simple, data-driven web site can be built using an XSQL page which makes clever use of SQL, XSQL-substitution variables in the queries, and XSLT for formatting the site. Demonstrates using substitution parameters in both the body
of SQL query statements within
|
| Employee Page ( |
XSQL page showing XML data from the EMP table, using XSQL
page parameters to control what employees are returned and what column(s) to
use for the database sort. Uses an associated XSLT Stylesheet for format the
results as an HTML Form containing the emp.xsql page as the form
|
| Insurance Claim Page ( |
Demonstrates a number of sample queries over the
richly-structured, Insurance Claim object view. The
|
| Invalid Classes Page ( |
XSQL Page which uses |
| Airport Code Validation ( |
XSQL page which returns a "datagram" of information about
airports based on their three-letter code. Demonstrates using the
The When you type in a three-leter airport code into this web page, some JavaScript under the covers fetches the XML datagram from the XSQL Servlet over the web corresponding to information for the airport code you typed in. If the return indicates that there was no exact match, the builds up a dynamic "picklist" of possible matches based on the information returned in the XML "datagram" from the XSQL Servlet. |
| Airport Code Display ( |
Demonstrates using the same XSQL page as the previous example but supplying an XSLT Stylesheet name in the request. This causes the airport information to be formatted as an HTML form instead of being returned as raw XML. |
| Emp/Dept Object View Demo
( |
Demonstrates using an object view to group
master/detail information from two existing "flat" tables like EMP and DEPT.
The The |
| Adhoc Query Visualization
( |
Demonstrates passing the entire SQL query and XSLT Stylesheet to use as parameters to the server. |
| XML Document Demo ( |
Demonstrates inserting XML documents into
relational tables. The Try inserting the text of the document in
The The demo uses the client-side XML features of Internet Explorer 5.0 to check the document for well-formedness before allowing it to be posted to the server. |
| XML Insert Request Demo
( |
Demonstrates posting XML from a client to an
XSQL Page that handles inserting the posted XML information into a database
table using the
In this case, the program doing the posting of the XML is a
client-side web page using Internet Explorer 5.0 and the Try copying and pasting the example
The |
| SVG Demo ( |
The |
Once you've understood what the XSQL Page Processor running inside the XSQL Servlet does, you'll realize that Oracle XSQL Pages is really just a very thin layer of convenience functionality allowing you to leverage the tremendous flexibility and power of SQL, XML, and XSLT to really do the "heavy lifting".
|
|
Note
:
Some of the material included in this document is excerpted from Building Oracle XML Applications by permission of O'Reilly and Associates. |
|
|
|
|
|
|
