Metacat

/**

 *    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

 *     '$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

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

 * call when processing the XML stream and generating events

 */

   protected String 	doctype;

   protected String 	systemid;

   protected Vector   nodeIndex;

   protected DBConnection	  connection = null;

   protected DocumentImpl currentDocument;

   protected DBSAXNode    rootNode;

   protected String   action = null;

   protected String   docid = null;

   protected String   revision = null;

   protected String   user = null;

   protected String[] groups = null;

   protected String   pub = null;

   protected Thread   xmlIndex;

   protected Hashtable namespaces = new Hashtable();

   // a buffer to keep all text nodes for same element

   // it is for element was splited

   protected StringBuffer textBuffer = new StringBuffer();

   protected Stack textBufferStack = new Stack();

   // writeTextForDBSAXNode will increase endNodeId.

   protected long  endNodeId = -1;    // The end node id for a substree

//   private static final int MAXTITLELEN = 1000;

   TripleCollection tripleList = new TripleCollection();

   Triple currentTriple        = new Triple();

   boolean startParseTriple    = false;

   boolean hasTriple           = false;

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

    */

     this.connection = conn;

     // if it doesn't already exist

     if (!stackCreated) {

       nodeStack = new Stack();

     }

  /** Construct an instance of the handler class

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

    * @param docid to be inserted or updated into JDBC connection

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

    *        resides.

    *

     this.action = action;

     this.docid = docid;

     this.serverCode = serverCode;

    * In this constructor, user can specify the version need to upadate

    *

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

    * @param action - "INSERT" or "UPDATE"

    * @param docid to be inserted or updated into JDBC connection

    * @param revision, the user specified the revision need to be update

    * @param user the user connected to MetaCat servlet and owns the document

    * @param groups the groups to which user belongs

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

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

    *        resides.

    *

    */

   {

     this(conn);

     this.action = action;

     this.docid = docid;

     this.revision = revision;

     this.user = user;

     this.groups = groups;

     this.pub = pub;

     this.serverCode = serverCode;

     this.xmlIndex = new Thread(this);

     nodeStack.push(rootNode);

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

     // It calls the run method of the thread.

     //if it is data package insert triple into relationtion table;

     if ( doctype != null &&

         MetaCatUtil.getOptionList(MetaCatUtil.getOption("packagedoctype")).

         contains(doctype) && hasTriple)

      {

        try

        {

          //initial handler and write into relationdb

          RelationHandler handler =

                        new RelationHandler(docid,doctype, connection, tripleList);

        }

        catch (Exception e)

        {

          MetaCatUtil.debugMessage

                                                           e.getMessage(), 30);

      }

       xmlIndex.start();

     } catch (NullPointerException e) {

       xmlIndex = null;

                    e.getMessage());

     }

   {

    namespaces.put(prefix, uri);

   }

   public void startElement(String uri, String localName,

     // for element <acl....> both qname and local name is "eml"

     // uri is namesapce

     MetaCatUtil.debugMessage("Start ELEMENT(qName) " + qName, 50);

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

     MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);

     DBSAXNode currentNode = null;

     try {

       parentNode = (DBSAXNode)nodeStack.peek();

     } catch (EmptyStackException e) {

     // If hit a text node, we need write this text for current's parent node

     // This will happend if the element is mixted

     if (hitTextNode && parentNode != null)

     {

       // write the textbuffer into db for parent node.

        hitTextNode =false;

        // reset textbuffer

        textBuffer = null;

        textBuffer = new StringBuffer();

     }

     {

       // doctype = root element name or name space

       if (docname == null)

       {

         // othewise root element

         if (uri != null && !(uri.trim()).equals(""))

         {

           doctype = uri;

         }

         else

         {

           doctype = docname;

         }

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

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

       }

       else if (doctype == null)

       {

         // because docname is not null and it is declared in dtd

         // so could not be in schema, no namespace

       rootNode.writeNodename(docname);

       try {

         // insert document action fialed.

         int serialNumber = -1;

           {

            // Get dbconnection

            dbConn=DBConnectionPool.getDBConnection

                                          ("DBSAXHandler.startElement");

            serialNumber=dbConn.getCheckOutSerialNumber();

            ResultSet rs = stmt.executeQuery(

            if ( hasRow ) {

              catalogid = rs.getString(1);

            }

            stmt.close();

           }//try

           finally

           {

             // Return dbconnection

             DBConnectionPool.returnDBConnection(dbConn, serialNumber);

           }//finally

         //the revision

                               docname, doctype, docid, revision, action, user,

                                 currentDocument.getDoctype());

     String prefix;

     String nsuri;

     Enumeration prefixes = namespaces.keys();

     while ( prefixes.hasMoreElements() ) {

       prefix = (String)prefixes.nextElement();

       nsuri = (String)namespaces.get(prefix);

       currentNode.setNamespace(prefix, nsuri, docid);

     }

     namespaces = null;

     namespaces = new Hashtable();

     {

       String attributeName = atts.getQName(i);

       String attributeValue = atts.getValue(i);

                currentNode.setAttribute(attributeName, attributeValue, docid);

       // To handle name space and schema location if the attribute name is

       // xsi:schemaLocation. If the name space is in not in catalog table

       // it will be regeistered.

       if (attributeName != null &&

           attributeName.indexOf(MetaCatServlet.SCHEMALOCATIONKEYWORD) != -1)

       {

         SchemaLocationResolver resolver =

                                  new SchemaLocationResolver(attributeValue);

         resolver.resolveNameSpace();

       }

     nodeStack.push(currentNode);

     nodeIndex.addElement(currentNode);

     if ( doctype != null &&

         MetaCatUtil.getOptionList(MetaCatUtil.getOption("packagedoctype")).contains(doctype)

         && localName.equals("triple"))

      {

        startParseTriple = true;

        hasTriple = true;

        currentTriple = new Triple();

      }

    DBSAXNode currNode = null;

    DBSAXNode prevNode = null;

    int serialNumber = -1;

    int counter = 0;

    {

      // stop 5 second

      Thread.sleep(5000);

      serialNumber=dbConn.getCheckOutSerialNumber();

      dbConn.setAutoCommit(false);

      checkDocumentTable();

      // Going through the elements of the document and writing its Index

      Enumeration nodes = nodeIndex.elements();

      while ( nodes.hasMoreElements() ) {

        currNode = (DBSAXNode)nodes.nextElement();

        currNode.updateNodeIndex(dbConn, docid, doctype);

      }

      dbConn.commit();

      try {

        dbConn.rollback();

        //dbconn.close();

      } catch (SQLException sqle) {}

      MetaCatUtil.debugMessage("Error in DBSAXHandler.run " +

                                e.getMessage(), 30);

    }

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* method to make sure insert is finished before create index table

   * If new version of record is in xml_documents every thing will be fine

   */

  private void checkDocumentTable() throws Exception

  {

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

       // Opening separate db connection for writing XML Index

      dbConn=DBConnectionPool.getDBConnection("DBSAXHandler.checkDocumentTable");

      serialNumber=dbConn.getCheckOutSerialNumber();

      //of the document that we are trying to index is already

      //in the xml_documents table.  if this is not the case, the foreign

      //key relationship between xml_documents and xml_index is temporarily

      //broken causing multiple problems.

      boolean inxmldoc = false;

      {

                                   " where docid ='" + docid + "' and " +

                                   " rev ='" + revision + "'";

        // Increase usage count

        dbConn.increaseUsageCount(1);

        ResultSet doccheckRS = xmlDocCheck.getResultSet();

        boolean tableHasRows = doccheckRS.next();

           inxmldoc = true;

         xmlDocCheck.close();

         // make sure the while loop will be ended in reseaonable time

         long stopTime = System.currentTimeMillis();

         if ((stopTime - startTime) > INDEXDELAY)

         {

           throw new Exception("Couldn't find the docid for index build in" +

       }//while

    }

    catch (Exception e)

    {

      try

      {

        //dbconn.close();

      catch (SQLException sqle)

      {}

                                e.getMessage(), 30);

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

  {

     // into different nodes

     textBuffer.append(new String(cbuf, start,len));

     // set hittextnode true

     hitTextNode = true;

     // so we can save memory

     if (textBuffer.length() > MAXDATACHARS)

     {

       MetaCatUtil.debugMessage("Write text into DB in charaters" +

                   " when text buffer size is greater than maxmum number", 50);

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

       endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, currentNode);

       textBuffer = null;

       textBuffer = new StringBuffer();

     }

   /**

    * Ignorable white space

               throws SAXException {

     // When validation is turned "on", white spaces are reported here

     // When validation is turned "off" white spaces are not reported here,

     // but through characters() callback

     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

     // 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

    * SAX Handler called once for each processing instruction found:

    */

                          String qName) throws SAXException {

     // write buffered text nodes into db (so no splited)

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

     // If before the end element, the parser hit text nodes and store them

     // into the buffer, write the buffer to data base. The reason we put

     // write database here is for xerces some time split text node

     if (hitTextNode)

     {

       MetaCatUtil.debugMessage("Write text into DB in End Element", 50);

       //if it is triple parsing process

       if (startParseTriple)

       {

          String content = textBuffer.toString().trim();

          if(localName.equals("subject"))

          { //get the subject content

            currentTriple.setSubject(content);

          }

          else if(localName.equals("relationship"))

          { //get the relationship content

            currentTriple.setRelationship(content);

          }

          else if(localName.equals("object"))

          { //get the object content

            currentTriple.setObject(content);

          }

       }

     //set hitText false

     hitTextNode = false;

     // reset textbuff

     textBuffer = null;

     textBuffer = new StringBuffer();

     if (startParseTriple && localName.equals("triple"))

      {

        // add trip to triple collection

        tripleList.addTriple(currentTriple);

        //rest variable

        currentTriple = null;

        startParseTriple = false;

      }

   // the next section implements the LexicalHandler interface

   //

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

     docname = name;

     doctype = publicId;

     systemid = systemId;

     //create a DTD node and write docname,publicid and system id into db

     // we don't put the dtd node into node stack

     DBSAXNode dtdNode = new DBSAXNode (connection, name, publicId, systemId,

                               currentNode, currentNode.getRootNodeID(), docid);

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

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

    * SAX Handler that receives notification of end of DTD

   public void endDTD() throws SAXException {

    */

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

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

                                       new String(ch, start, length), docid);

    */

   public void startCDATA() throws SAXException {

    */

   public void endCDATA() throws SAXException {

    */

   public void startEntity(String name) throws SAXException {

       processingDTD = true;

     }

    */

   public void endEntity(String name) throws SAXException {

       processingDTD = false;

     }

    */

   public void elementDecl(String name, String model)

                        throws org.xml.sax.SAXException {