Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents an XML document

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.FileReader;

import java.io.IOException;

import java.io.StringWriter;

import java.io.Writer;

import java.util.Date;

import org.xml.sax.AttributeList;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.XMLReader;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.XMLReaderFactory;

 * A class that represents an XML document. It can be created with a simple

 * XML text document to a database connection using SAX.

public class DocumentImpl {

  static final int WRITE = 2;

  static final int READ = 4;

  private String docid = null;

  private String docname = null;

  private String doctype = null;

//  private String doctitle = null;

  private String updatedate = null;

  private String userupdated = null;

  private ElementNode rootNode = null;

  /**

   * from the database.  If readNodes is false, then the node data is not

   * read at this time, but is deferred until it is needed (such as when a

   * call to toXml() is made).

   * @param conn the database connection from which to read the document

   * @param readNodes flag indicating whether the xmlnodes should be read

         throws McdbException

      this.conn = conn;

      this.docid = docid;

      // Look up the document information

      getDocumentInfo(docid);

        // The sort order of the records is determined by the NodeComparator

        // class, and needs to represent a depth-first traversal for the

        // toXml() method to work properly

        nodeRecordList = getNodeRecordList(rootnodeid);

      throw ex;

    } catch (Throwable t) {

      throw new McdbException("Error reading document from " +

                              "DocumentImpl.DocumentImpl: " + docid);

  /**

   * for reading the document

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   */

  public DocumentImpl(Connection conn, String docid) throws McdbException

  {

   * This method is called from DBSAXHandler because we need to know the

   * root element name for documents without a DOCTYPE before creating it.

   * @param conn the JDBC Connection to which all information is written

   * @param rootnodeid - sequence id of the root node in the document

   * @param docname - the name of DTD, i.e. the name immediately following

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (Oracle's and IBM parsers are not aware if it is not the

   *        root element name)

   * @param doctype - Public ID of the DTD, i.e. the name immediately

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   * @param action the action to be performed (INSERT OR UPDATE)

   * @param user the user that owns the document

   * @param pub flag for public "read" access on document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public DocumentImpl(Connection conn, long rootnodeid, String docname,

  {

    this.conn = conn;

    this.rootnodeid = rootnodeid;

    this.docname = docname;

    this.doctype = doctype;

    this.docid = docid;

   * Register a document that resides on the filesystem with the database.

   * (ie, just an entry in xml_documents, nothing in xml_nodes).

   * Creates a reference to a filesystem document (used for non-xml data files).

   *

   * @param conn the JDBC Connection to which all information is written

   * @param docname - the name of DTD, i.e. the name immediately following

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (Oracle's and IBM parsers are not aware if it is not the

   *        root element name)

   * @param doctype - Public ID of the DTD, i.e. the name immediately

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   * @param accnum the accession number to use for the INSERT OR UPDATE, which

   *               includes a revision number for this revision of the document

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public static void registerDocument(

                     String docname, String doctype, String accnum,

                     String user, int serverCode)

                     throws SQLException, AccessionNumberException, Exception

  {

    Connection dbconn = null;

    MetaCatUtil util = new MetaCatUtil();

      dbconn = util.openDBConnection();

      AccessionNumber ac = new AccessionNumber(dbconn, accnum, "insert");

      String docid = ac.getDocid();

      String rev = ac.getRev();

      SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

      Date localtime = new Date();

      String dateString = formatter.format(localtime);

      String sqlDateString = "to_date('" + dateString + "', 'YY-MM-DD HH24:MI:SS')";

      StringBuffer sql = new StringBuffer();

      sql.append("insert into xml_documents (docid, docname, doctype, ");

      sql.append("user_owner, user_updated, server_location, rev, date_created");

      sql.append(", date_updated, public_access) values ('");

      sql.append(docid).append("','");

      sql.append(docname).append("','");

      sql.append(doctype).append("','");

      sql.append(user).append("','");

      sql.append(user).append("','");

      sql.append(serverCode).append("','");

      sql.append(rev).append("',");

      sql.append(sqlDateString).append(",");

      sql.append(sqlDateString).append(",");

      sql.append("'0')");

      //System.out.println("sql: " + sql.toString());

      PreparedStatement pstmt = dbconn.prepareStatement(sql.toString());

      pstmt.execute();

      pstmt.close();

      dbconn.close();

    } finally {

      util.returnConnection(dbconn);

    }

  }

   * get the document name

   */

  public String getDocname() {

    return docname;

  }

  /**

   * get the document type (which is the PublicID)

   */

  public String getDoctype() {

    return doctype;

  }

  /**

   * get the system identifier

   */

  public String getSystemID() {

    return system_id;

  }

  /**

   * get the root node identifier

   */

  public long getRootNodeID() {

    return rootnodeid;

  }

  /**

   * get the creation date

   */

  public String getCreateDate() {

    return createdate;

  }

  /**

   * get the update date

   */

  public String getUpdateDate() {

    return updatedate;

  }

   * Get the document identifier (docid)

   */

  public String getDocID() {

    return docid;

  }

//  /**

//   *get the document title

//   */

//  public String getDocTitle() {

//    return doctitle;

//  }

  public String getUserowner() {

    return userowner;

  }

  public String getUserupdated() {

    return userupdated;

  }

  public int getServerlocation() {

    return serverlocation;

  }

  }

  public int getRev() {

    return rev;

  }

  public String toString()

  {

      this.toXml(docwriter);

    } catch (McdbException mcdbe) {

      return null;

    }

    return document;

  }

  /**

   * Get a text representation of the XML document as a string

   * This older algorithm uses a recursive tree of Objects to represent the

   * nodes of the tree.  Each object is passed the data for the document

   * and searches all of the document data to find its children nodes and

   * recursively build.  Thus, because each node reads the whole document,

   * this algorithm is extremely slow for larger documents, and the time

   * to completion is O(N^N) wrt the number of nodes.  See toXml() for a

   * better algorithm.

   */

    if (nodeRecordList == null) {

      nodeRecordList = getNodeRecordList(rootnodeid);

    }

    rootNode = new ElementNode(nodeRecordList, rootnodeid);

    doc.append("<?xml version=\"1.0\"?>\n");

    if (docname != null) {

      if ((doctype != null) && (system_id != null)) {

        doc.append("<!DOCTYPE " + docname + " PUBLIC \"" + doctype +

                   "\" \"" + system_id + "\">\n");

      } else {

        doc.append("<!DOCTYPE " + docname + ">\n");

      }

    }

    doc.append(rootNode.toString());

    return (doc.toString());

  }

  /**

   *

   * @param pw the Writer to which we print the document

   */

    PrintWriter out = null;

    if (pw instanceof PrintWriter) {

      out = (PrintWriter)pw;

    } else {

      out = new PrintWriter(pw);

    }

    MetaCatUtil util = new MetaCatUtil();

    if (nodeRecordList == null) {

      nodeRecordList = getNodeRecordList(rootnodeid);

    }

    boolean atRootElement = true;

    boolean previousNodeWasElement = false;

    // Step through all of the node records we were given

    Iterator it = nodeRecordList.iterator();

    while (it.hasNext()) {

      NodeRecord currentNode = (NodeRecord)it.next();

      //util.debugMessage("[Got Node ID: " + currentNode.nodeid +

                          //" (" + currentNode.parentnodeid +

                          //", " + currentNode.nodeindex +

                          //", " + currentNode.nodetype +

                          //", " + currentNode.nodename +

                          //", " + currentNode.nodedata + ")]");

      // Print the end tag for the previous node if needed

      //

      // This is determined by inspecting the parent nodeid for the

      // currentNode.  If it is the same as the nodeid of the last element

      // that was pushed onto the stack, then we are still in that previous

      // parent element, and we do nothing.  However, if it differs, then we

      // have returned to a level above the previous parent, so we go into

      // a loop and pop off nodes and print out their end tags until we get

      // the node on the stack to match the currentNode parentnodeid

      //

      // So, this of course means that we rely on the list of elements

      // having been sorted in a depth first traversal of the nodes, which

      // is handled by the NodeComparator class used by the TreeSet

      if (!atRootElement) {

        NodeRecord currentElement = (NodeRecord)openElements.peek();

        if ( currentNode.parentnodeid != currentElement.nodeid ) {

          while ( currentNode.parentnodeid != currentElement.nodeid ) {

            currentElement = (NodeRecord)openElements.pop();

            util.debugMessage("\n POPPED: " + currentElement.nodename);

              out.print(">");

              previousNodeWasElement = false;

            }

              out.print("</" + currentElement.nodeprefix + ":" +

                        currentElement.nodename + ">" );

            } else {

              out.print("</" + currentElement.nodename + ">" );

            }

          }

        }

      }

      // Handle the DOCUMENT node

      if (currentNode.nodetype.equals("DOCUMENT")) {

        out.println("<?xml version=\"1.0\"?>");

        if (docname != null) {

          if ((doctype != null) && (system_id != null)) {

            out.println("<!DOCTYPE " + docname + " PUBLIC \"" + doctype +

                       "\" \"" + system_id + "\">");

          } else {

            out.println("<!DOCTYPE " + docname + ">");

          }

        }

      // Handle the ELEMENT nodes

      } else if (currentNode.nodetype.equals("ELEMENT")) {

        if (atRootElement) {

          atRootElement = false;

        } else {

          if (previousNodeWasElement) {

            out.print(">");

          }

        }

        openElements.push(currentNode);

        util.debugMessage("\n PUSHED: " + currentNode.nodename);

        previousNodeWasElement = true;

          out.print("<" + currentNode.nodeprefix + ":" + currentNode.nodename);

        } else {

          out.print("<" + currentNode.nodename);

        }

      // Handle the ATTRIBUTE nodes

      } else if (currentNode.nodetype.equals("ATTRIBUTE")) {

          out.print(" " + currentNode.nodeprefix + ":" + currentNode.nodename +

                    "=\"" + currentNode.nodedata + "\"");

        } else {

          out.print(" " + currentNode.nodename + "=\"" +

                    currentNode.nodedata + "\"");

        }

      // Handle the NAMESPACE nodes

      } else if (currentNode.nodetype.equals("NAMESPACE")) {

        out.print(" xmlns:" + currentNode.nodename + "=\""

                 + currentNode.nodedata + "\"");

      // Handle the TEXT nodes

        if (previousNodeWasElement) {

          out.print(">");

        }

        out.print(currentNode.nodedata);

        previousNodeWasElement = false;

      // Handle the COMMENT nodes

      } else if (currentNode.nodetype.equals("COMMENT")) {

        if (previousNodeWasElement) {

          out.print(">");

        }

        out.print("<!--" + currentNode.nodedata + "-->");

        previousNodeWasElement = false;

      // Handle the PI nodes

      } else if (currentNode.nodetype.equals("PI")) {

        if (previousNodeWasElement) {

          out.print(">");

        }

        out.print("<?" + currentNode.nodename + " " +

                        currentNode.nodedata + "?>");

        previousNodeWasElement = false;

      // Handle any other node type (do nothing)

      } else {

        // Any other types of nodes are not handled.

        // Probably should throw an exception here to indicate this

      }

      out.flush();

    }

    // Print the final end tag for the root element

    {

      NodeRecord currentElement = (NodeRecord)openElements.pop();

      util.debugMessage("\n POPPED: " + currentElement.nodename);

        out.print("</" + currentElement.nodeprefix + ":" +

                  currentElement.nodename + ">" );

      } else {

        out.print("</" + currentElement.nodename + ">" );

      }

  }

  private boolean isRevisionOnly(DocumentIdentifier docid) throws Exception

  {

    //System.out.println("inRevisionOnly");

    PreparedStatement pstmt;

    String rev = docid.getRev();

    String newid = docid.getIdentifier();

    pstmt = conn.prepareStatement("select rev from xml_documents " +

                                  "where docid like '" + newid + "'");

    pstmt.execute();

    ResultSet rs = pstmt.getResultSet();

    boolean tablehasrows = rs.next();

    if(rev.equals("newest") || rev.equals("all"))

    {

      return false;

    }

    if(tablehasrows)

    {

      int r = rs.getInt(1);

      { //the current revision in in xml_documents

        //System.out.println("returning false");

        return false;

      }

      else if(new Integer(rev).intValue() < r)

      { //the current revision is in xml_revisions.

        //System.out.println("returning true");

        return true;

      }

      else if(new Integer(rev).intValue() > r)

      { //error, rev cannot be greater than r

        throw new Exception("requested revision cannot be greater than " +

                            "the latest revision number.");

      }

    }

    throw new Exception("the requested docid '" + docid.toString() +

                        "' does not exist");

  }

  {

    getDocumentInfo(new DocumentIdentifier(docid));

  }

   *

   * @param docid the id of the document to look up

   */

    PreparedStatement pstmt;

    try

    {

      if(isRevisionOnly(docid))

      { //pull the document from xml_revisions instead of from xml_documents;

        table = "xml_revisions";

      }

    }

    catch(Exception e)

    {

                          e.getMessage());

    //deal with the key words here.

    if(docid.getRev().equals("all"))

    {

    }

//      sql.append("SELECT docname, doctype, rootnodeid, doctitle, ");

      sql.append("SELECT docname, doctype, rootnodeid, ");

      sql.append("server_location, public_access, rev");

      sql.append(" FROM ").append(table);

      sql.append("' and rev like '").append(docid.getRev()).append("'");

      //System.out.println(sql.toString());

      //pstmt.setString(2, docid.getRev());

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      if (tableHasRows) {

        this.doctype        = rs.getString(2);

        this.rootnodeid     = rs.getLong(3);

//        this.doctitle       = rs.getString(4);

        this.updatedate     = rs.getString(5);

        this.userowner      = rs.getString(6);

        this.userupdated    = rs.getString(7);

        this.serverlocation = rs.getInt(8);

        this.rev            = rs.getInt(10);

        pstmt =

          conn.prepareStatement("SELECT system_id " +

                                  "FROM xml_catalog " +

        pstmt.setString(1, doctype);

        pstmt.execute();

        rs = pstmt.getResultSet();

        tableHasRows = rs.next();

        if (tableHasRows) {

          this.system_id  = rs.getString(1);

        }

    } catch (SQLException e) {

                          e.getMessage());

                              "DocumentImpl.getDocumentInfo: ", e);

    if (this.docname == null) {

      throw new McdbDocNotFoundException("Document not found: " + docid);

    }

  }

  /**

   * Look up the node data from the database

   *

    PreparedStatement pstmt;

    TreeSet nodeRecordList = new TreeSet(new NodeComparator());

    long nodeid = 0;

    long parentnodeid = 0;

    long nodeindex = 0;

    String nodetype = null;

    String nodename = null;

    try {

      pstmt =

      conn.prepareStatement("SELECT nodeid,parentnodeid,nodeindex, " +

           "replace(" +

           "replace(nodedata,'&','&') " +

           ",'<','&lt;') " +

           ",'>','>') " +

      // Bind the values to the query

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      while (tableHasRows) {

        nodeid = rs.getLong(1);

        parentnodeid = rs.getLong(2);

        nodeindex = rs.getLong(3);

        nodetype = rs.getString(4);

        nodename = rs.getString(5);

        nodedata = rs.getString(7);

        // add the data to the node record list hashtable

                                       nodetype, nodename, nodeprefix, nodedata);

        // Advance to the next node

        tableHasRows = rs.next();

      }

      pstmt.close();

    } catch (SQLException e) {