/DBReader.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/DBReader.java @ 106

-            jones
+/**
  *        Name: DBReader.java
  *     Purpose: A Class that creates an XML text document
  *              from a query to a relational DB containing a DOM representation
-            jones
+ *   Copyright: 2000 Regents of the University of California and the
  *              National Center for Ecological Analysis and Synthesis
-            jones
+ *     Authors: Matt Jones
+ *
  *     Version: '$Id$'
  */
-            jones
+package edu.ucsb.nceas.metacat;
-            jones
+import java.io.*;
 import java.net.URL;
 import java.net.MalformedURLException;
 import java.sql.*;
 import java.util.Stack;
-            jones
+/**
  * A Class that creates an XML text document
  * from a query to a relational DB containing a DOM representation
  */
-            jones
+public class DBReader {
   static  String 	defaultDB = "jdbc:oracle:thin:@localhost:1521:test";
   private Connection	conn = null;
-            jones
+  /**
    * main routine used for testing.
+   *
    * Usage: java DBReader <nodeid> <user> <password> [dbstring]
+   *
    * @param nodeid the id number of the root of the subtree to display
    * @param user the username to use for the database connection
    * @param password the password to use for the database connection
    * @param dbstring the connection info to use for the database connection
    */
-            jones
+  static public void main(String[] args) {
      if (args.length < 3)
+     {
         System.err.println("Wrong number of arguments!!!");
         System.err.println("USAGE: java DBReader " +
                            "<nodeid> <user> <password> [dbstring]");
         return;
      } else {
         try {
-            jones
+          String nodeidstr = args[0];
           long nodeid = (new Long(nodeidstr).longValue());
-            jones
+          String user     = args[1];
           String password = args[2];
           String dbstring = null;
           if (args.length <= 3) {
             dbstring = defaultDB;
           } else {
             dbstring = args[3];
+          }
-            jones
+          // Open a connection to the database
           Connection dbconn = MetaCatUtil.openDBConnection(
                 "oracle.jdbc.driver.OracleDriver",
                 dbstring, user, password);
           DBReader rd = new DBReader( dbconn );
-            jones
+          String xml = rd.readXMLDocument(nodeid);
-            jones
+          System.out.println(xml);
         } catch (Exception e) {
           System.err.println("EXCEPTION HANDLING REQUIRED");
           System.err.println(e.getMessage());
           e.printStackTrace(System.err);
+        }
+     }
+  }
-            jones
+  /**
    * construct a DBReader instance.
+   *
    * Generally, one calls readXMLDocument() after constructing the instance
+   *
-            jones
+   * @param conn the database connection from which to read the document
-            jones
+   */
-            jones
+  public DBReader( Connection conn )
-            jones
+                  throws IOException,
                          SQLException,
                          ClassNotFoundException
+  {
-            jones
+    this.conn = conn;
             jones
-            jones
+  /**
-            jones
+   * Get the root node id for an XML document given a document id
+   *
    * @param docid the document node contains the root of the document
    * @returns long the nodeid of the root node for this document
    */
   public long getRootNode(long docid) {
     // Now look up the root node id
     long rootnodeid = 0;
     try {
       PreparedStatement pstmt =
         conn.prepareStatement("SELECT rootnodeid " +
                 "FROM xml_documents " +
                 "WHERE docid = ?");
       // Bind the values to the query
       pstmt.setLong(1, docid);
       pstmt.execute();
       try {
         ResultSet rs = pstmt.getResultSet();
         try {
           boolean tableHasRows = rs.next();
           if (tableHasRows) {
             try {
               rootnodeid = rs.getLong(1);
             } catch (SQLException e) {
               System.out.println("Error with getLong: " + e.getMessage());
+            }
+          }
         } catch (SQLException e) {
           System.out.println("Error with next: " + e.getMessage());
+        }
       } catch (SQLException e) {
         System.out.println("Error with getrset: " + e.getMessage());
+      }
       pstmt.close();
     } catch (SQLException e) {
       System.out.println("Error getting id: " + e.getMessage());
+    }
     return rootnodeid;
+  }
   /**
-            jones
+   * Create an XML document from the database starting with the element
    * having element_id nodeid
+   *
-            jones
+   * @param docid the document that we want retrieved
-            jones
+   */
-            jones
+  public String readXMLDocument(long docid) {
-            jones
+    StringBuffer doc = new StringBuffer();
-            jones
+    DoctypeInfo dti = getDoctypeInfo(docid);
     String docname = dti.getDocname();
     String doctype = dti.getDoctype();
     String sysid = dti.getSystemID();
             jones
-            jones
+    ReaderElement element = new ReaderElement(conn, getRootNode(docid));
-            jones
+    doc.append("<?xml version=\"1.0\"?>\n");
             jones
     if (docname != null) {
       if ((doctype != null) && (sysid != null)) {
         doc.append("<!DOCTYPE " + docname + " PUBLIC \"" + doctype +
                    "\" \"" + sysid + "\">\n");
       } else {
         doc.append("<!DOCTYPE " + docname + ">\n");
+      }
+    }
-            jones
+    doc.append(element.toString());
             jones
     return (doc.toString());
+  }
             jones
   /**
    * Look up the document type information from the database
+   *
    * @param docid the id of the document to look up
    */
   public DoctypeInfo getDoctypeInfo(long docid) {
     PreparedStatement pstmt;
     String doctype = null;
     String docname = null;
     String sysid   = null;
     DoctypeInfo dti = null;
     try {
       pstmt =
         conn.prepareStatement("SELECT docname,doctype " +
                                 "FROM xml_documents " +
                                "WHERE docid = ?");
       // Bind the values to the query
       pstmt.setLong(1, new Long(docid).longValue());
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean tableHasRows = rs.next();
       if (tableHasRows) {
         docname  = rs.getString(1);
         doctype  = rs.getString(2);
+      }
       pstmt.close();
       pstmt =
         conn.prepareStatement("SELECT system_id " +
                                 "FROM xml_catalog " +
                                "WHERE public_id = ?");
       // Bind the values to the query
       pstmt.setString(1, doctype);
       pstmt.execute();
       rs = pstmt.getResultSet();
       tableHasRows = rs.next();
       if (tableHasRows) {
         sysid  = rs.getString(1);
+      }
       pstmt.close();
     } catch (SQLException e) {
       System.out.println("Error getting id: " + e.getMessage());
+    }
     dti = new DoctypeInfo(docname, doctype, sysid);
     return dti;
+  }
   /**
    * A utility class that encapsulates document type information
    */
   public class DoctypeInfo {
     private String docname = null;
     private String doctype = null;
     private String system_id = null;
     /**
      * Constructor
      */
     public DoctypeInfo(String docname, String doctype, String system_id) {
       this.docname = docname;
       this.doctype = doctype;
       this.system_id = system_id;
+    }
     /**
      * get the document name
      */
     public String getDocname() {
       return docname;
+    }
     /**
      * get the document type
      */
     public String getDoctype() {
       return doctype;
+    }
     /**
      * get the system identifier
      */
     public String getSystemID() {
       return system_id;
+    }
+  }
             jones

Project

General

Profile

Metacat