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.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.metacat.database.DBConnectionPool;

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

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

    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 int serverCode = 1;

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

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

    protected static final int MAXDATACHARS = 4000;

    //protected static final int MAXDATACHARS = 50;

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

    protected Vector<XMLSchema> schemaList = new Vector<XMLSchema>();

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

            nodeIndex = new Vector<DBSAXNode>();

    /**

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

    }

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

		logMetacat.info("end Document");

		// Starting new thread for writing XML Index.

		// It calls the run method of the thread.

				if (!isRevisionDoc) {

					RelationHandler handler = new RelationHandler(docid, doctype,

							connection, tripleList);

				}

			}

		} catch (Exception e) {

			logMetacat.error("Failed to write triples into relation table"

					+ e.getMessage());

			throw new SAXException("Failed to write triples into relation table "

					+ e.getMessage());

		}

		// If we get here, the document and schema parsed okay.  If there are

		// any schemas in the schema list, they are new and need to be registered.

    	for (XMLSchema xmlSchema : schemaList) {

    		String externalFileUri = xmlSchema.getExternalFileUri();

    		String fileNamespace = xmlSchema.getFileNamespace();

    		SchemaLocationResolver resolver =

    			new SchemaLocationResolver(fileNamespace, externalFileUri);

    		resolver.resolveNameSpace();

    	}

    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"

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

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

        DBSAXNode currentNode = null;

        try {

        } catch (EmptyStackException e) {

            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)

                    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

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

                {

                  currentDocument = new DocumentImpl(connection, rootNode

                        createDate, updateDate);

                        + action, ane));

            }

        }

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

        String prefix;

        String nsuri;

            prefix = (String) prefixes.nextElement();

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

            currentNode.setNamespace(prefix, nsuri, docid);

        }

        namespaces = null;

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

            String attributeName = atts.getQName(i);

            String attributeValue = atts.getValue(i);

            endNodeId = currentNode.setAttribute(attributeName, attributeValue,

                    docid);

            // table it will be registered.

                    && attributeName

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

            	// assuming parsing is successful.

        		// each namespace could have several schema locations.  parsedUri will

        		// hold a list of uri and files.

            	attributeValue = StringUtil.replaceTabsNewLines(attributeValue);

            	attributeValue = StringUtil.replaceDuplicateSpaces(attributeValue);

        		Vector<String> parsedUri = StringUtil.toVector(attributeValue, ' ');

        		for (int j = 0; j < parsedUri.size(); j = j + 2 ) {

        			if (j + 1 >= parsedUri.size()) {

        				throw new SAXException("Odd number of elements found when parsing schema location: " +

        						attributeValue + ". There should be an even number of uri/files in location.");

        			}

        			XMLSchema xmlSchema =

        				new XMLSchema(parsedUri.get(j), parsedUri.get(j + 1));

        			schemaList.add(xmlSchema);

        		}

        }

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

		nodeStack.push(currentNode);

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

		nodeIndex.addElement(currentNode);

		// start parsing triple

		try {

			if (doctype != null

				startParseTriple = true;

				hasTriple = true;

				currentTriple = new Triple();

			}

		} catch (PropertyNotFoundException pnfe) {

			pnfe.printStackTrace();

			throw (new SAXException("Error in DBSaxHandler.startElement " + action, pnfe));

		}

	}

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

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

        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;

        }

    }

     * SAX Handler that receives notification of the end of entities

     */

    public void endEntity(String name) throws SAXException

    {

        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

    {

        //System.out.println("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

    {

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

        //                        + value);

                + type + " " + valueDefault + " " + value);

     * SAX Handler that receives notification of internal entity declarations

     */

    public void internalEntityDecl(String name, String value)

            throws org.xml.sax.SAXException

    {

        //System.out.println("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

    {

        //System.out.println("EXTERNENTITYDECL: " + name + " " + publicId

        //                              + " " + systemId);

                + " " + systemId);

        // it doesn't signal for the DTD here

        processingDTD = false;

    }

    // the next section implements the ErrorHandler interface

    //

     * SAX Handler that receives notification of fatal parsing errors

     */

    public void fatalError(SAXParseException exception) throws SAXException