Get result from PL/SQL function through XDBUri (10g)

Question

Hi!
I have to call a PL/SQL function that takes two parameters and return one parameter. (I will do this from Oracle Service Bus).
It is possible to get relational data as xml through an XDBUri type over http by using the XML DB functionality. But is it possible to get the result of a PL/SQL function as XML as well?
I have tried to wrap the PL/SQL procedure inside a view, but cant get the variable to be bound into the sql.
I have tried with stuff like this:
create or replace view test (a, b)
as
select function(a, b) from dual
But since I dont have a table returning the values i cant get it work.
If I can make this view, I can call it through the XDMUri type.
Sombody that can help me to manage this?
/Helge
Edited by: user3169245 on 03.apr.2009 12:06

Answer 1

Here's a code snippet that may help
package com.oracle.st.xmldb.pm.xfiles;
import com.oracle.st.xmldb.pm.multipart.InputStreamProcessor;
import com.oracle.st.xmldb.pm.multipart.MultipartInputStream;
import java.io.IOException;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import oracle.jdbc.OracleConnection;
import oracle.jdbc.OracleDriver;
import oracle.jdbc.OracleCallableStatement;
import com.oracle.st.xmldb.pm.multipart.MultipartProcessor;
import com.oracle.st.xmldb.pm.multipart.MultipartProcessorImpl;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Enumeration;
import oracle.jdbc.OraclePreparedStatement;
import oracle.jdbc.OracleResultSet;
import oracle.jdbc.OracleTypes;
import oracle.sql.BLOB;
import oracle.sql.CLOB;
import oracle.xdb.XMLType;
import oracle.xml.parser.v2.XMLDocument;
import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
public class XFilesServlet extends HttpServlet implements InputStreamProcessor {
    public static String TARGET_PATH      = "target";
    public static String STYLESHEET_PATH      = "stylesheet"; 
    private static String CREATE_RESOURCE_SQL =
    "begin " +
    "  XFILES_SOAP_SERVICES.UPLOADRESOURCE" +
    "  ( " +
    "    P_RESOURCE_PATH => :1, " +
    "    P_CONTENT => :2, " +
    "    P_CONTENT_TYPE => :3," +
    "    P_DESCRIPTION => :4," +
    "    P_LANGUAGE => :5," +
    "    P_CHARACTER_SET => :6," +
    "    P_DUPLICATE_POLICY => :7" +
    "  );" +
    "end;";
    private static String GET_FOLDER_HTML_PAGE_SQL =
    "select xdburitype('/XFILES/lite/Folder.html').getClob() from dual";
    private static String WRITE_LOG_RECORD_SQL =
    "begin xfiles_logging.enqueue_log_record(:1); end;";
    private OracleConnection dbConnection;
    private OracleCallableStatement createResource;
    private OracleCallableStatement writeLogRecord;
    private DatabaseMetaData dbMetadata;
    private static final int FILE_UPLOAD = 1;
    private static final int PUBLISH_RSS = 2;
    private static final int DB_REST_SERVICE = 3;
    private static final int FORCE_AUTHENTICATION = 4;
    private static final int SET_PASSWORD = 5;
    private static final int DISPLAY_XML = 6;
    private static final int ENABLE_RSS = 7;
    public static final int XDB_ACCESS_DENIED = 31050;
    private static String SERVLET_ROOT = "/sys/servlets/XFILES";
    private static final String FILE_UPLOAD_PATH = "fileUpload";
    private static final String PUBLISH_RSS_PATH = "publishRSS";
    private static final String SET_PASSWORD_PATH = "setPassword";
    private static final String DB_REST_SERVICE_PATH = "dbRestService";
    private static final String FORCE_AUTHENTICATION_PATH = "doAuthentication";
    private static final String DISPLAY_XML_PATH = "displayXML";
    private static final String ENABLE_RSS_PATH = "enableRSS";
    public static String POST_UPLOAD_URL = "postUploadRedirect";
    public static String DULPLICATE_POLICY = "duplicatePolicy";
    public static String SOURCE_FILE_PATH = "sourceFilePath";
    public static String RESOURCE_FILENAME = "targetFileName";
    public static String RESOURCE_DESCRIPTION = "description";
    public static String UPLOAD_LANGUAGE = "UploadLanguage";
    public static String UPLOAD_CHARACTERSET = "UploadCharset";
    public static String PASSWORD = "password";
    public static String XML_DOCUMENT = "content";
    public static String XML_CHUNK = "chunk";
    public static String RESOURCE_ID = "resid";
    public static String DATABASE_SCHEMA = "DatabaseSchema";
    public static String PACKAGE  = "Package";
    public static String METHOD = "Method";
    public static String SQL_CALL = "SqlOperation";
    protected XMLDocument logRecord;
    protected Element parameterList;
    protected Element timings;
    protected int currentOperation;
    public String xmlContent;
    public static String XML_TIMESTAMP_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS000";
    public static String LOG_TIMESTAMP_FORMAT = "HH:mm:ss.SSS000";
    protected SimpleDateFormat xmlDateFormatter  = new SimpleDateFormat(XML_TIMESTAMP_FORMAT); 
    private String postUploadURL;
    private String targetFolder;
    private String onDuplicateAction;
    private String sourceFile;
    private BLOB   resourceContent;
    private String contentType;
    private String resourceName;
    private String resourceComment;
    private String uploadLanguage;
    private String uploadCharacterSet;
    public XFilesServlet() {
    private void logParameter(Document doc)
       this.parameterList.appendChild(logRecord.importNode(doc.getDocumentElement().cloneNode(true),true));
    private void logParameter(String parameterName, String[] values)
      Element e = this.logRecord.createElement(parameterName);
      this.parameterList.appendChild(e);
      if (values != null)
        Attr a = this.logRecord.createAttribute("Length");
        e.setAttributeNode(a);
        a.setValue(Integer.toString(values.length));
        for (int i = 0; i < values.length; i++)
          Element v = this.logRecord.createElement("parameterValue");
          e.appendChild(v);
          Text t = this.logRecord.createTextNode(values);
v.appendChild(t);
a = this.logRecord.createAttribute("Index");
v.setAttributeNode(a);
a.setValue(Integer.toString(i));
public void logParameter(String parameterName,String value)
Element e = this.logRecord.createElement(parameterName);
this.parameterList.appendChild(e);
if (value != null)
Text t = this.logRecord.createTextNode(value);
e.appendChild(t);
private void logParameterCDATA(String parameterName,String value)
Element e = this.logRecord.createElement(parameterName);
this.parameterList.appendChild(e);
if (value != null)
CDATASection c = this.logRecord.createCDATASection(value);
e.appendChild(c);
private void logException(Exception e) {
Element stackTrace = this.logRecord.createElement("StackTrace");
this.logRecord.getDocumentElement().appendChild(stackTrace);
this.appendException(stackTrace,e);
private void appendException(Element stackTrace, Throwable error)
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
error.printStackTrace(pw);
pw.flush();
pw.close();
Text t = this.logRecord.createCDATASection(sw.toString());
stackTrace.appendChild(t);
if (error.getCause() != null)
Element causedBy = this.logRecord.createElement("CausedBy");
stackTrace.appendChild(causedBy);
appendException(causedBy,error.getCause());
else {
if (error instanceof ServletException) {
ServletException se = (ServletException) error;
if (se.getRootCause() != null) {
Element causedBy = this.logRecord.createElement("CausedBy");
stackTrace.appendChild(causedBy);
appendException(causedBy,se.getRootCause());
private void logTimestamp(String eventName)
Timestamp ts = new Timestamp(System.currentTimeMillis());
Element element = logRecord.createElement(eventName);
this.timings.appendChild(element);
Text text = logRecord.createTextNode(this.xmlDateFormatter.format(ts));
element.appendChild(text);
protected void initiateLogging(HttpServletRequest request)
throws IOException
this.logRecord = new XMLDocument();
Element root = this.logRecord.createElement("XFilesLogRecord");
this.logRecord.appendChild(root);
Element e = this.logRecord.createElement("HttpRequest");
root.appendChild(e);
Element e1 = this.logRecord.createElement("ServletName");
Text t = this.logRecord.createTextNode(this.getClass().getName());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("HttpMethod");
t = this.logRecord.createTextNode(request.getMethod());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("RequestURI");
t = this.logRecord.createTextNode(request.getRequestURI());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("PathTranslated");
t = this.logRecord.createTextNode(request.getPathTranslated());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("RequestURL");
t = this.logRecord.createTextNode(new String(request.getRequestURL()));
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("Protocol");
t = this.logRecord.createTextNode(request.getProtocol());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("ServerName");
t = this.logRecord.createTextNode(request.getServerName());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("ContentType");
t = this.logRecord.createTextNode(request.getContentType());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("LocalAddr");
t = this.logRecord.createTextNode(request.getLocalAddr());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("LocalName");
t = this.logRecord.createTextNode(request.getLocalName());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("LocalPort");
t = this.logRecord.createTextNode(Integer.toString(request.getLocalPort()));
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("Port");
t = this.logRecord.createTextNode(Integer.toString(request.getServerPort()));
e1.appendChild(t);
e.appendChild(e1);
this.timings = this.logRecord.createElement("Timestamps");
root.appendChild(this.timings);
logTimestamp("Init");
e = this.logRecord.createElement("Remote");
root.appendChild(e);
e1 = this.logRecord.createElement("RemoteHost");
t = this.logRecord.createTextNode(request.getRemoteHost());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("RemoteAddress");
t = this.logRecord.createTextNode(request.getRemoteAddr());
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("RemotePort");
t = this.logRecord.createTextNode(Integer.toString(request.getRemotePort()));
e1.appendChild(t);
e.appendChild(e1);
e1 = this.logRecord.createElement("RemoteUser");
t = this.logRecord.createTextNode(request.getRemoteUser());
e1.appendChild(t);
e.appendChild(e1);
e = this.logRecord.createElement("RequestHeaders");
root.appendChild(e);
Enumeration headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements())
String headerName = (String) headerNames.nextElement();
e1 = this.logRecord.createElement(headerName);
t = this.logRecord.createTextNode(request.getHeader(headerName));
e1.appendChild(t);
e.appendChild(e1);
this.parameterList = this.logRecord.createElement("ServletParameters");
root.appendChild(parameterList);
public void writeLogRecord(XMLDocument logRecord) throws SQLException , IOException {
XMLType xml = new XMLType(this.dbConnection, logRecord);
this.writeLogRecord.setObject(1, xml);
this.writeLogRecord.execute();
this.dbConnection.commit();
protected String readParameter(HttpServletRequest request,String parameterName,String defaultValue)
String value = request.getParameter(parameterName);
if (value != null)
if (value.length() == 0) {
value = null;
if (value == null) {
value = defaultValue;
logParameter(parameterName,value);
return value;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException
try {
try {  
initiateLogging(request);
initializeDatabaseConnection();
String requestURI = request.getRequestURI();
this.currentOperation = getOperation(requestURI);
switch (this.currentOperation) {
case DB_REST_SERVICE:
restResponse(request,response);
break;
default:
response.sendError(HttpServletResponse.SC_NOT_FOUND);
logTimestamp("Complete");
writeLogRecord(this.logRecord);
this.dbConnection.commit();
catch (Exception e) {
try {
this.dbConnection.rollback();
logTimestamp("Exception");
logException(e);
writeLogRecord(this.logRecord);
catch (Exception wle) {
System.out.println("XFilesServlet : Fatal error while logging Error : ");
e.printStackTrace(System.out);
System.out.flush();
wle.printStackTrace(System.out);
System.out.flush();
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
finally {
try {
this.createResource.close();
this.writeLogRecord.close();
catch (SQLException e) {
System.out.println("XFilesServlet : Fatal error while closing statements : ");
e.printStackTrace(System.out);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} catch (IOException ioe) {
System.out.println("XFilesServlet : Fatal error while Sending Error Status : ");
ioe.printStackTrace(System.out);
System.out.flush();
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
doGet(req, res);
private void initializeDatabaseConnection() throws SQLException {
DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
OracleDriver ora = new OracleDriver();
this.dbConnection = (OracleConnection) ora.defaultConnection();
this.createResource = (OracleCallableStatement) this.dbConnection.prepareCall(this.CREATE_RESOURCE_SQL);
this.writeLogRecord = (OracleCallableStatement) this.dbConnection.prepareCall(this.WRITE_LOG_RECORD_SQL);
this.dbMetadata = this.dbConnection.getMetaData();
private int getOperation(String requestURI) {
String servletTarget = requestURI.substring(this.SERVLET_ROOT.length()+1);
if (servletTarget.indexOf('/') > -1) {
servletTarget = servletTarget.substring(0,servletTarget.indexOf("/"));
if (servletTarget.equals(this.FILE_UPLOAD_PATH)) return FILE_UPLOAD;
if (servletTarget.equals(this.FORCE_AUTHENTICATION_PATH)) return this.FORCE_AUTHENTICATION;
if (servletTarget.equals(this.PUBLISH_RSS_PATH)) return this.PUBLISH_RSS;
if (servletTarget.equals(this.DB_REST_SERVICE_PATH)) return this.DB_REST_SERVICE;
if (servletTarget.equals(this.SET_PASSWORD_PATH)) return this.SET_PASSWORD;
if (servletTarget.equals(this.DISPLAY_XML_PATH)) return this.DISPLAY_XML;
if (servletTarget.equals(this.ENABLE_RSS_PATH)) return this.ENABLE_RSS;
return 0;
public void processParameter(String name, String value)
throws SQLException {
logParameter(name,value);
if (name.equals(this.TARGET_PATH)) {
this.targetFolder = value;
if (name.equals(this.POST_UPLOAD_URL)) {
this.postUploadURL = value;
if (name.equals(this.UPLOAD_LANGUAGE)) {
this.uploadLanguage = value;
if (name.equals(this.UPLOAD_CHARACTERSET)) {
this.uploadCharacterSet = value;
if (name.equals(this.DULPLICATE_POLICY)) {
this.onDuplicateAction = value;
if (name.equals(this.SOURCE_FILE_PATH)) {
this.sourceFile = value;
if (name.equals(MultipartProcessor.MULTIPART_CONTENT_TYPE)) {
this.contentType = value;
if (name.equals(this.RESOURCE_FILENAME)) {
this.resourceName = value;
if (name.equals(this.RESOURCE_DESCRIPTION)) {
this.resourceComment = value;
createNewResource();
private void restResponse(HttpServletRequest request, HttpServletResponse response)
throws IOException, SQLException, ServletException {
String requestURI = request.getRequestURI();
String restTarget = requestURI.substring(this.SERVLET_ROOT.length() + this.DB_REST_SERVICE_PATH.length()+1);
if (restTarget.contains("//")) {
// Cannot have // in URL
response.sendError(HttpServletResponse.SC_BAD_REQUEST);
return;
if (restTarget.length() < 4) {
// URL is too short to be valid - Minumum is /A/B
response.sendError(HttpServletResponse.SC_BAD_REQUEST);
return;
if (!restTarget.startsWith("/")) {
// Invalid URL
response.sendError(HttpServletResponse.SC_BAD_REQUEST);
return;
if (!restTarget.substring(1).contains("/")) {
// URL must contain /Schema/Method, may Contain /Schema/Package/Method
response.sendError(HttpServletResponse.SC_BAD_REQUEST);
return;
String schemaName = restTarget.substring(1,restTarget.substring(1).indexOf("/")+1);
restTarget = restTarget.substring(schemaName.length()+1);
logParameter(this.DATABASE_SCHEMA,schemaName);
String packageName = null;
if (restTarget.substring(1).contains("/")) {
// URL contains /Schema/Package/Method
packageName = restTarget.substring(1,restTarget.substring(1).indexOf("/")+1);
restTarget = restTarget.substring(packageName.length()+1);
logParameter(this.PACKAGE,packageName);
if (restTarget.substring(1).contains("/")) {
// URL must be /Schema/Method or /Schema/Package/Method, anything else is junk
response.sendError(HttpServletResponse.SC_BAD_REQUEST);
return;
String methodName = restTarget.substring(1);
logParameter(this.METHOD,methodName);
int responseCode = verifyTarget(request,schemaName,packageName,methodName);
if (responseCode != HttpServletResponse.SC_OK) {
System.out.println("Status Code = " + responseCode);
response.sendError(responseCode);
return;
String target = "\"" + schemaName + "\".";
if (packageName != null) {
target = target + "\"" + packageName + "\".";
target = target + "\"" + methodName + "\"";
int index;
Enumeration parmNames;
String sqlStatementText =
"begin" + "\n" +
" :1 := " + target + "(" + "\n";
index = 1;
parmNames = request.getParameterNames();
while (parmNames.hasMoreElements()) {
index++;
sqlStatementText = sqlStatementText + "\"" + parmNames.nextElement() + "\" => :" + index + " ";
if (parmNames.hasMoreElements()) {
sqlStatementText = sqlStatementText + ",\n";
sqlStatementText = sqlStatementText + ");\nend;";
logParameterCDATA(this.SQL_CALL,sqlStatementText);
OracleCallableStatement statement = (OracleCallableStatement) this.dbConnection.prepareCall(sqlStatementText);
index = 1;
parmNames = request.getParameterNames();
while (parmNames.hasMoreElements()) {
index++;
String parameterName = (String) parmNames.nextElement();
String parameterValue = (String) request.getParameter(parameterName);
logParameter(parameterName,parameterValue);
statement.setString(index,parameterValue);
XMLType xml = null;
try {
statement.registerOutParameter(1,OracleTypes.OPAQUE,"SYS.XMLTYPE");
statement.execute();
xml = (XMLType) statement.getObject(1);
statement.close();
catch (SQLException sqle) {
statement.close();
if (xml != null) xml.close();
if (sqle.getErrorCode() == this.XDB_ACCESS_DENIED) {
logTimestamp("RequestAuthorization");
response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
return;
ServletException se = new ServletException("Unexpected SQL Error",sqle);
throw se;
response.setContentLength(0);
response.setContentType("text/xml");
xml.writeToOutputStream(response.getOutputStream());
xml.close();
response.getOutputStream().flush();
response.getOutputStream().write( new byte[] {'\r','\n'} );
// response.getOutputStream().flush();
response.getOutputStream().close();
response.setStatus(HttpServletResponse.SC_OK);
private int verifyTarget(HttpServletRequest request, String schemaName, String packageName, String methodName)
throws SQLException {
int response = HttpServletResponse.SC_NOT_FOUND;
boolean parameterValid = false;
ResultSet procedure = null;
procedure = this.dbMetadata.getProcedures(packageName,schemaName,methodName);
while (procedure.next()) {
response = HttpServletResponse.SC_OK;
response = verifyMandatoryParameters(request,schemaName,packageName,methodName);
if (response == HttpServletResponse.SC_OK) {
response = verifyOptionalParameters(request,schemaName,packageName,methodName);
return response;
private int verifyMandatoryParameters(HttpServletRequest request, String schemaName, String packageName, String methodName) throws SQLException {
// Check Mandatory Parameters are present.
ResultSet columns = null;
columns = this.dbMetadata.getProcedureColumns(packageName,schemaName,methodName,"%");
while (columns.next()) {
short nullable = columns.getShort(12);
String columnName = columns.getString(4);
if (nullable == DatabaseMetaData.procedureNoNulls) {
if (request.getParameter(columnName) == null) {
columns.close();
return HttpServletResponse.SC_BAD_REQUEST;
return HttpServletResponse.SC_OK;
private int verifyOptionalParameters(HttpServletRequest request, String schemaName, String packageName, String methodName) throws SQLException {
// Check Optional Parameters are valid
Enumeration parms = request.getParameterNames();
ResultSet column = null;
while (parms.hasMoreElements()) {
String columnName = (String) parms.nextElement();
column = this.dbMetadata.getProcedureColumns(packageName,schemaName,methodName,columnName);
if (!column.next()) {
column.close();
return HttpServletResponse.SC_BAD_REQUEST;
column.close();
return HttpServletResponse.SC_OK;