Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles the SAX XML events as they

 *             are generated from XML documents

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Jivka Bojilova

 *

 *   '$Author: bojilova $'

 *     '$Date: 2000-08-03 16:17:03 -0700 (Thu, 03 Aug 2000) $'

 * '$Revision: 313 $'

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.util.Stack;

import java.util.EmptyStackException;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.DefaultHandler;

/** 

 * A database aware Class implementing callback bethods for the SAX parser to

 * call when processing the XML stream and generating events

 */

public class DBSAXHandler extends DefaultHandler 

                          implements LexicalHandler, DeclHandler {

   private boolean	atFirstElement;

   private boolean	processingDTD;

   private String 	docname = null;

   private String 	doctype;

   private String 	systemid;

   private boolean 	stackCreated = false;

   private Stack 	nodeStack;

   private Connection	conn = null;

   private DBSAXDocument currentDocument;

   private DBSAXNode    rootNode;

   private String       action = null;

   private String       docid = null;

   private static final int MAXDATACHARS = 4000;

   /** Construct an instance of the handler class 

    *

    * @param conn the JDBC connection to which information is written

    */

   public DBSAXHandler(Connection conn) {

     this.conn = conn;

     this.atFirstElement = true;

     this.processingDTD = false;

     // Create the stack for keeping track of node context

     // if it doesn't already exist

     if (!stackCreated) {

       nodeStack = new Stack();

       stackCreated = true;

     }

   }

   /** Construct an instance of the handler class 

    *

    * @param conn the JDBC connection to which information is written

    */

   public DBSAXHandler(Connection conn, String action, String docid) {

     this(conn);

     this.action = action;

     this.docid = docid;

   }

   /** SAX Handler that receives notification of beginning of the document */

   public void startDocument() throws SAXException {

     MetaCatUtil.debugMessage("start Document");

     // Create the document node representation as root

     rootNode = new DBSAXNode(conn, docname);

     MetaCatUtil.debugMessage("PRINTING DOCNAME FROM ROOTNODE: " + 

                               rootNode.getTagName());

     // Add the node to the stack, so that any text data can be 

     // added as it is encountered

     nodeStack.push(rootNode);

   }

   /** SAX Handler that receives notification of end of the document */

   public void endDocument() throws SAXException {

     currentDocument.setTitleFromChildElement();

     MetaCatUtil.debugMessage("end Document");

     if ((docid != null) && (!docid.equals(currentDocument.getDocID()))) {

       throw (new SAXException("New document ID generated:",

           new AccessionNumberGeneratedException(currentDocument.getDocID())));

     } else {

       throw (new SAXException("New document ID generated:",

           new AccessionNumberGeneratedException(currentDocument.getDocID())));

     }

   }

   /** SAX Handler that is called at the start of each XML element */

   public void startElement(String uri, String localName,

                            String qName, Attributes atts) 

               throws SAXException {

     MetaCatUtil.debugMessage("Start ELEMENT " + localName);

     DBSAXNode parentNode = null;

     DBSAXNode currentNode = null;

     // Get a reference to the parent node for the id

     try {

       parentNode = (DBSAXNode)nodeStack.peek();

     } catch (EmptyStackException e) {

     }

     // Document representation that points to the root document node

     if (atFirstElement) {

       atFirstElement = false;

       // If no DOCTYPE declaration: docname = root element name 

       if (docname == null) {

         docname = localName;

         doctype = docname;

         MetaCatUtil.debugMessage("DOCNAME-a: " + docname);

         MetaCatUtil.debugMessage("DOCTYPE-a: " + doctype);

       } else if (doctype == null) {

         doctype = docname;

         //doctype = DBEntityResolver.doctype;

         MetaCatUtil.debugMessage("DOCTYPE-b: " + doctype);

       }

       rootNode.writeNodename(docname);

       rootNode.writeRootNodeID(rootNode.getNodeID());

       try {

         currentDocument = new DBSAXDocument(conn, rootNode.getNodeID(), 

                                           docname, doctype, docid, action);

         } catch (AccessionNumberException ane) {

           throw (new SAXException("Error with " + action, ane));

         }

       rootNode.writeDocID(currentDocument.getDocID());

     }      

     // Create the current node representation

     currentNode = new DBSAXNode(conn, localName, parentNode, currentDocument);

     // Add all of the attributes

     for (int i=0; i<atts.getLength(); i++) {

       currentNode.setAttribute(atts.getLocalName(i), atts.getValue(i));

     }      

     // Add the node to the stack, so that any text data can be 

     // added as it is encountered

     nodeStack.push(currentNode);

  }

   /** SAX Handler that is called for each XML text node */

   public void characters(char[] cbuf, int start, int len) {

     MetaCatUtil.debugMessage("CHARACTERS");

     DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

     String data = null;

     int leftover = len;

     int offset = start;

     boolean moredata = true;

     // This loop deals with the case where there are more characters 

     // than can fit in a single database text field (limit is 

     // MAXDATACHARS).  If the text to be inserted exceeds MAXDATACHARS,

     // write a series of nodes that are MAXDATACHARS long, and then the

     // final node contains the remainder

     while (moredata) {

       if (leftover > MAXDATACHARS) {

         data = new String(cbuf, offset, MAXDATACHARS);

         leftover -= MAXDATACHARS;

         offset += MAXDATACHARS;

       } else {

         data = new String(cbuf, offset, leftover);

         moredata = false;

       }

       // Write the content of the node to the database

       currentNode.writeChildNodeToDB("TEXT", null, data);

     }

   }

   /** 

    * SAX Handler that is called for each XML text node that is Ignorable

    * white space

    */

   public void ignorableWhitespace(char[] cbuf, int start, int len) {

     MetaCatUtil.debugMessage("IGNORABLEWHITESPACE");

   }

   /** 

    * SAX Handler called once for each processing instruction found: 

    * node that PI may occur before or after the root element.

    */

   public void processingInstruction(String target, String data) 

          throws SAXException {

     MetaCatUtil.debugMessage("PI");

     DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

     currentNode.writeChildNodeToDB("PI", target, data);

   }

   /** SAX Handler that is called at the end of each XML element */

   public void endElement(String uri, String localName,

                          String qName) throws SAXException {

     MetaCatUtil.debugMessage("End ELEMENT " + localName);

     // Get the node from the stack

     DBSAXNode currentNode = (DBSAXNode)nodeStack.pop();

   }

   //

   // the next section implements the LexicalHandler interface

   //

   /** SAX Handler that receives notification of DOCTYPE. Sets the DTD */

   public void startDTD(String name, String publicId, String systemId) 

               throws SAXException {

     docname = name;

     doctype = publicId;

     systemid = systemId;

     MetaCatUtil.debugMessage("Start DTD");

     MetaCatUtil.debugMessage("DOCNAME: " + docname);

     MetaCatUtil.debugMessage("DOCTYPE: " + doctype);

     MetaCatUtil.debugMessage("  SYSID: " + systemid);

   }

   /** 

    * SAX Handler that receives notification of end of DTD 

    */

   public void endDTD() throws SAXException {

     MetaCatUtil.debugMessage("end DTD");

   }

   /** 

    * SAX Handler that receives notification of comments in the DTD

    */

   public void comment(char[] ch, int start, int length) throws SAXException {

     MetaCatUtil.debugMessage("COMMENT");

     DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();

     currentNode.writeChildNodeToDB("COMMENT", null, new String(ch));

   }

   /** 

    * SAX Handler that receives notification of the start of CDATA sections

    */

   public void startCDATA() throws SAXException {

     MetaCatUtil.debugMessage("start CDATA");

   }

   /** 

    * SAX Handler that receives notification of the end of CDATA sections

    */

   public void endCDATA() throws SAXException {

     MetaCatUtil.debugMessage("end CDATA");

   }

   /** 

    * SAX Handler that receives notification of the start of entities

    */

   public void startEntity(String name) throws SAXException {

     MetaCatUtil.debugMessage("start ENTITY: " + name);

     if (name.equals("[dtd]")) {

       processingDTD = true;

     }

   }

   /** 

    * SAX Handler that receives notification of the end of entities

    */

   public void endEntity(String name) throws SAXException {

     MetaCatUtil.debugMessage("end ENTITY: " + name);

     if (name.equals("[dtd]")) {

       processingDTD = false;

     }

   }

   /** 

    * SAX Handler that receives notification of element declarations

    */

   public void elementDecl(String name, String model)

                        throws org.xml.sax.SAXException {

     MetaCatUtil.debugMessage("ELEMENTDECL: " + name + " " + model);

   }

   /** 

    * SAX Handler that receives notification of attribute declarations

    */

   public void attributeDecl(String eName, String aName,

                        String type, String valueDefault, String value)

                        throws org.xml.sax.SAXException {

     MetaCatUtil.debugMessage("ATTRIBUTEDECL: " + eName + " " 

                        + aName + " " + type + " " + valueDefault + " "

                        + value);

   }

   /** 

    * SAX Handler that receives notification of internal entity declarations

    */

   public void internalEntityDecl(String name, String value)

                        throws org.xml.sax.SAXException {

     MetaCatUtil.debugMessage("INTERNENTITYDECL: " + name + " " + value);

   }

   /** 

    * SAX Handler that receives notification of external entity declarations

    */

   public void externalEntityDecl(String name, String publicId,

                        String systemId)

                        throws org.xml.sax.SAXException {

     MetaCatUtil.debugMessage("EXTERNENTITYDECL: " + name + " " + publicId 

                              + " " + systemId);

   }

   //

   // the next section implements the ErrorHandler interface

   //

   /** 

    * SAX Handler that receives notification of fatal parsing errors

    */

   public void fatalError(SAXParseException exception) throws SAXException {

     MetaCatUtil.debugMessage("FATALERROR");

     throw (new SAXException("Fatal processing error.", exception));

   }

   /** 

    * SAX Handler that receives notification of recoverable parsing errors

    */

   public void error(SAXParseException exception) throws SAXException {

     MetaCatUtil.debugMessage("ERROR");

   }

   /** 

    * SAX Handler that receives notification of warnings

    */

   public void warning(SAXParseException exception) throws SAXException {

     MetaCatUtil.debugMessage("FATALERROR");

   }

   // 

   // Helper, getter and setter methods

   //

   /**

    * get the document name

    */

   public String getDocname() {

     return docname;

   }

   /**

    * get the document processing state

    */

   public boolean processingDTD() {

     return processingDTD;

   }

}

/**

 * '$Log$

 * 'Revision 1.31  2000/06/29 23:27:08  jones

 * 'Fixed bug in DBEntityResolver so that it now properly delegates to

 * 'the system id found inthe database.

 * 'Changed DBValidate to use DBEntityResolver, rather than the OASIS

 * 'catalog, and to return validation results in XML format.

 * '

 * 'Revision 1.30  2000/06/28 03:14:35  jones

 * 'Fixed bug where TEXT nodes couldn't be longer than 4000 characters, which

 * 'is the maximum length of a VARCHAR2 field in Oracle.  Now, if text

 * 'exceeds the field length, I break the text up into a series of TEXT

 * 'nodes each of the max field length, and the remainder in the last

 * 'TEXT node. The only problem with this is that our current search

 * 'algorithms only will find phrases within a single TEXT nodes, so if

 * 'the search term spans the node boundary, the search algorithm will not

 * 'return a hit. I expect this is extremely rare, basically inconsequential.

 * '

 * 'Revision 1.29  2000/06/27 04:31:07  jones

 * 'Fixed bugs associated with the new UPDATE and DELETE functions of

 * 'DBWriter.  There were problematic interactions between some static

 * 'variables used in DBEntityResolver and the way in which the

 * 'Servlet objects are re-used across multiple client invocations.

 * '

 * 'Generally cleaned up error reporting.  Now all errors and success

 * 'results are reported as XML documents from MetaCatServlet.  Need

 * 'to make the command line tools do the same.

 * '

 * 'Revision 1.28  2000/06/26 10:35:05  jones

 * 'Merged in substantial changes to DBWriter and associated classes and to

 * 'the MetaCatServlet in order to accomodate the new UPDATE and DELETE

 * 'functions.  The command line tools and the parameters for the

 * 'servlet have changed substantially.

 * '

 * 'Revision 1.27.2.6  2000/06/26 02:02:20  jones

 * 'Continued fixing problems with exception handling that deals

 * 'with INSERT and UPDATE actions and the docid passed to DBWriter

 * '

 * 'Revision 1.27.2.5  2000/06/26 00:51:06  jones

 * 'If docid passed to DBWriter.write() is not unique, classes now generate

 * 'an AccessionNumberException containing the new docid generated as a

 * 'replacement.  The docid is then extracted from the exception and

 * 'returned to the calling application for user feedback or client processing.

 * '

 * 'Revision 1.27.2.4  2000/06/25 23:38:16  jones

 * 'Added RCSfile keyword

 * '

 * 'Revision 1.27.2.3  2000/06/25 23:34:17  jones

 * 'Changed documentation formatting, added log entries at bottom of source files

 * ''

 */