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 java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.EmptyStackException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

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

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

        DeclHandler, Runnable

{

    protected String catalogid = null;

    protected DocumentImpl currentDocument;

    protected String createDate = null;

    protected String updateDate = null;

    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;

    private boolean endDocument = false;

    protected int serverCode = 1;

    protected Hashtable namespaces = new Hashtable();

    protected boolean hitTextNode = false; // a flag to hit text node

    // 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();

    protected static final int MAXDATACHARS = 4000;

    //protected static final int MAXDATACHARS = 50;

    protected static final long INDEXDELAY = 10000;

    // methods writeChildNodeToDB, setAttribute, setNamespace,

    // writeTextForDBSAXNode will increase endNodeId.

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

    // DOCTITLE attr cleared from the db

    //   private static final int MAXTITLELEN = 1000;

    private boolean isRevisionDoc  = false;

    //HandlerTriple stuff

    TripleCollection tripleList = new TripleCollection();

    Triple currentTriple = new Triple();

    boolean startParseTriple = false;

    boolean hasTriple = false;

     * Construct an instance of the handler class

     */

        this.connection = conn;

        this.atFirstElement = true;

        this.processingDTD = false;

        this.updateDate = updateDate;

        // Create the stack for keeping track of node context

        // if it doesn't already exist

        if (!stackCreated) {

            nodeStack = new Stack();

            nodeIndex = new Vector();

            stackCreated = true;

    /**

     * Construct an instance of the handler class

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

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

     * @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.

            String user, String[] groups, String pub, int serverCode)

    {

        this(conn);

        this.action = action;

        this.docid = docid;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

        this.xmlIndex = new Thread(this);

    }

*/

    /**

     * Construct an instance of the handler class In this constructor, user can

     * specify the version need to upadate

     * @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.

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String revision, String user, String[] groups, String pub,

        this.docid = docid;

        this.revision = revision;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

        this.xmlIndex = new Thread(this);

    }

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

    public void startDocument() throws SAXException

    {

        // Create the document node representation as root

        rootNode = new DBSAXNode(connection, this.docid);

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

    {

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

                if (!isRevisionDoc)

                {

                  RelationHandler handler = new RelationHandler(docid, doctype,

                        "Failed to write triples into relation table "

                                + e.getMessage());

            }

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

    }

    public void startElement(String uri, String localName, String qName,

            Attributes atts) throws SAXException

    {

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

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

        // uri is namesapce

        logMetacat.info("Start ELEMENT(localName) " + localName);

        logMetacat.info("Start ELEMENT(uri) " + uri);

        DBSAXNode currentNode = null;

        try {

        } catch (EmptyStackException e) {

            parentNode = null;

        }

        // node

        // This will happend if the element is mixted

        if (hitTextNode && parentNode != null) {

            // write the textbuffer into db for parent node.

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, parentNode);

            // rest hitTextNode

            hitTextNode = false;

            // reset textbuffer

            textBuffer = null;

            textBuffer = new StringBuffer();

        if (atFirstElement) {

            atFirstElement = false;

            // If no DOCTYPE declaration: docname = root element

            // doctype = root element name or name space

            if (docname == null) {

                docname = localName;

                // if uri isn't null doctype = uri(namespace)

                // othewise root element

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

                    doctype = uri;

                } else {

                    doctype = docname;

                }

                logMetacat.info("DOCTYPE-a: " + doctype);

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

                // so could not be in schema, no namespace

                doctype = docname;

                // for validated XML Documents store a reference to XML DB

                // Catalog

                // Because this is select statement and it needn't to roll back

                // if

                // insert document action fialed.

                // In order to decrease DBConnection usage count, we get a new

                // dbconnection from pool

                int serialNumber = -1;

                    try {

                        // Get dbconnection

                        dbConn = DBConnectionPool

                                .getDBConnection("DBSAXHandler.startElement");

                        serialNumber = dbConn.getCheckOutSerialNumber();

                        ResultSet rs = stmt

                                .executeQuery("SELECT catalog_id FROM xml_catalog "

                                        + "WHERE entry_type = 'DTD' "

                                        + "AND public_id = '" + doctype + "'");

                        boolean hasRow = rs.next();

                        if (hasRow) {

                            catalogid = rs.getString(1);

                        }

                        stmt.close();

                    }//try

                    finally {

                        // Return dbconnection

                        DBConnectionPool.returnDBConnection(dbConn,

                                serialNumber);

                    }//finally

                }

                // specify

                //the revision

                if (!isRevisionDoc)

                {

                  //System.out.println("here!!!!!!!!!!!3");

                  currentDocument = new DocumentImpl(connection, rootNode

                        createDate, updateDate);

                }

                        + action, ane));

            }

        }

                parentNode, rootNode.getNodeID(), docid, doctype);

        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();

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

            String attributeName = atts.getQName(i);

            String attributeValue = atts.getValue(i);

            endNodeId = currentNode.setAttribute(attributeName, attributeValue,

                    docid);

            // 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();

        }

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

        // added as it is encountered

        nodeStack.push(currentNode);

        // Add the node to the vector used by thread for writing XML Index

        nodeIndex.addElement(currentNode);

        // start parsing triple

        if (doctype != null

                && MetaCatUtil.getOptionList(

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

                        doctype) && localName.equals("triple")) {

            startParseTriple = true;

            hasTriple = true;

            currentTriple = new Triple();

        }

    }

            (new Boolean(MetaCatUtil.getOption("usexmlindex"))).booleanValue();

                xmlIndex.start();

            } catch (NullPointerException e) {

                xmlIndex = null;

                        + e.getMessage());

        }

    }

     * thread is run asynchronously in order to more quickly return control to

     * the submitting user.  The run method checks to see if the document has

     * been fully inserted before trying to update the xml_index table.

     */

            {

             // stop 5 second

             Thread.sleep(5000);

             //make sure record is done

             checkDocumentTable();

             // Build the index for this document

             currentDocument.buildIndex();

            }

                    + e.getMessage());

    /*

     * 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

        int serialNumber = -1;

        try {

            // Opening separate db connection for writing XML Index

            dbConn = DBConnectionPool

                    .getDBConnection("DBSAXHandler.checkDocumentTable");

            serialNumber = dbConn.getCheckOutSerialNumber();

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

            boolean inxmldoc = false;

            long startTime = System.currentTimeMillis();

            while (!inxmldoc) {

                String xmlDocumentsCheck = "select distinct docid from xml_documents"

                        + " where docid ='"

                        + docid

                        + "' and "

                        + " rev ='"

                        + revision + "'";

                PreparedStatement xmlDocCheck = dbConn

                        .prepareStatement(xmlDocumentsCheck);

                // Increase usage count

                dbConn.increaseUsageCount(1);

                xmlDocCheck.execute();

                ResultSet doccheckRS = xmlDocCheck.getResultSet();

                boolean tableHasRows = doccheckRS.next();

                if (tableHasRows) {

                            "=========== found the correct document");

                }

                doccheckRS.close();

                xmlDocCheck.close();

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

                long stopTime = System.currentTimeMillis();

                if ((stopTime - startTime) > INDEXDELAY) { throw new Exception(

            }//while

        } catch (Exception e) {

            try {

                dbConn.rollback();

                //dbconn.close();

            } catch (SQLException sqle) {

            }

                    + e.getMessage());

        } finally {

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }//finally

    }

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

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

        // into different nodes

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

        // set hittextnode true

        hitTextNode = true;

        // if text buffer .size is greater than max, write it to db.

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS) {

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

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

            textBuffer = null;

            textBuffer = new StringBuffer();

    /**

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

     * white space

     */

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

            throws SAXException

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

        // but through characters() callback

        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

            endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data,

                    docid);

        }

    /**

     * 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

        endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

    }

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

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

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

                    currentNode);

            if (startParseTriple) {

                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);

                }

            }

        hitTextNode = false;

        // reset textbuff

        textBuffer = null;

        textBuffer = new StringBuffer();

        currentNode = (DBSAXNode) nodeStack.pop();

        //finishing parsing single triple

        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

    //

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

            throws SAXException

    {

        docname = name;

        doctype = publicId;

        systemid = systemId;

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

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

        logMetacat.info("Setting processingDTD to true");

        logMetacat.info("DOCNAME: " + docname);

        logMetacat.info("DOCTYPE: " + doctype);

        logMetacat.info("  SYSID: " + systemid);

     * SAX Handler that receives notification of end of DTD

     */

    public void endDTD() throws SAXException

    {

        logMetacat.info("end DTD");

     * SAX Handler that receives notification of comments in the DTD

     */

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

    {

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

            endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

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

        }

    }

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

     */

    public void startCDATA() throws SAXException

    {

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

     */

    public void endCDATA() throws SAXException

    {

     * SAX Handler that receives notification of the start of entities

     */

    public void startEntity(String name) throws SAXException

    {

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

            processingDTD = true;

        }

    }