/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 471

Added by bojilova about 24 years ago

Separate thread used for writing into xml_index table.
This cut the time of the response on insert almost in half.
The tread is started afterwards
(on end of document parsing and inserting into xml_nodes) from
DBSAXHandler and uses new(separate) db connection.
But I did not find a good way to show the work done of that thread.

     import java.sql.*;
     import java.util.Stack;
     import java.util.Vector;
     import java.util.Enumeration;
     import java.util.EmptyStackException;
     import org.xml.sax.Attributes;
-...
      * call when processing the XML stream and generating events
      */
     public class DBSAXHandler extends DefaultHandler
                               implements LexicalHandler, DeclHandler {
                               implements LexicalHandler, DeclHandler, Runnable {
        private boolean	atFirstElement;
        private boolean	processingDTD;
-...
        private String 	doctype;
        private String 	systemid;
        private boolean 	stackCreated = false;
        private Stack 	nodeStack;
        private Connection	conn = null;
        private Stack 	  nodeStack;
        private Vector   nodeIndex;
        private Connection	  conn = null;
        private DocumentImpl currentDocument;
        private DBSAXNode    rootNode;
        private String       action = null;
        private String       docid = null;
        private String       user = null;
        private String   action = null;
        private String   docid = null;
        private String   user = null;
        private Thread   xmlIndex;
        private boolean endDocument = false;
        private static final int MAXDATACHARS = 4000;
        private static final int MAXTITLELEN = 1000;
-...
          // if it doesn't already exist
          if (!stackCreated) {
            nodeStack = new Stack();
            nodeIndex = new Vector();
            stackCreated = true;
+         }
+       }
-...
          this.action = action;
          this.docid = docid;
          this.user = user;
          this.xmlIndex = new Thread(this);
          //this.xmlIndex.setPriority(Thread.MIN_PRIORITY);
+       }
        /** SAX Handler that receives notification of beginning of the document */
-...
        /** SAX Handler that receives notification of end of the document */
        public void endDocument() throws SAXException {
     // NOT NEEDED ANY MORE - use currentDocument.setTitle() from characters(cbuf,start,end)
     //     currentDocument.setTitleFromChildElement();
          MetaCatUtil.debugMessage("end Document");
     // NOT NEEDED ANY MORE - Accession# is generated at the very beginning before the parsing
     //     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())));
     //     }
          // Starting new thread for writing XML Index.
          // It calls the run method of the thread.
          try {
            xmlIndex.start();
          } catch (NullPointerException e) {
            xmlIndex = null;
            throw new
            SAXException("Problem with starting thread for writing XML Index. " +
                         e.getMessage());
+         }
+       }
        /** SAX Handler that is called at the start of each XML element */
-...
          currentNode = new DBSAXNode(conn, localName, parentNode,
                                      currentDocument.getRootNodeID(),docid,
                                      currentDocument.getDoctype());
          // Add all of the attributes
          for (int i=0; i<atts.getLength(); i++) {
            currentNode.setAttribute(atts.getLocalName(i), atts.getValue(i), docid);
-...
          // 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);
+      }
       // The run method of xmlIndex thread. It writes XML Index for the document.
       public void run () {
         DBSAXNode currNode = null;
         DBSAXNode prevNode = null;
         int step = 0;
         int counter = 0;
         try {
           // Opening separate db connection for writing XML Index
           MetaCatUtil util = new MetaCatUtil();
           Connection conn = util.getConnection();
           conn.setAutoCommit(false);
           // Going through the elements of the document and writing its Index
           Enumeration nodes = nodeIndex.elements();
           while ( nodes.hasMoreElements() ) {
             currNode = (DBSAXNode)nodes.nextElement();
             currNode.updateNodeIndex(conn, docid, currentDocument.getDoctype());
+          }
           conn.commit();
           conn.close();
         } catch (Exception e) {
           try {
             conn.rollback();
             conn.close();
           } catch (SQLException sqle) {}
           System.out.println("Error writing XML Index. " + e.getMessage());
+        }
+      }
       /** SAX Handler that is called for each XML text node */
       public void characters(char[] cbuf, int start, int len) throws SAXException {
          MetaCatUtil.debugMessage("CHARACTERS");

         this.conn = conn;
         this.parentNode = parentNode;
         writeChildNodeToDB("ELEMENT", getTagName(), null, docid);
         updateNodeIndex(docid, doctype);
         //No writing XML Index from here. New Thread used instead.
         //updateNodeIndex(docid, doctype);
+      }
       /** creates SQL code and inserts new node into DB connection */
-...
+          }
+      }
       /**
        * creates SQL code to put doc ID for the document node and for
        * comment/PI nodes under document node into DB connection
        */
     /*
       public void writeDocID(String doc_id) {
           try {
             PreparedStatement pstmt;
             pstmt = conn.prepareStatement(
                   "UPDATE xml_nodes set docid = ? " +
                   "WHERE nodeid = ?");
             // Bind the values to the query
             pstmt.setString(1, doc_id);
             pstmt.setLong(2, getNodeID());
             // Do the insertion
             pstmt.execute();
             pstmt.close();
             // for comments and PI on the top
             pstmt = conn.prepareStatement(
                   "UPDATE xml_nodes set docid = ? " +
                   "WHERE parentnodeid = ?");
             // Bind the values to the query
             pstmt.setString(1, doc_id);
             pstmt.setLong(2, getNodeID());
             // Do the insertion
             pstmt.execute();
             pstmt.close();
           } catch (SQLException e) {
             System.out.println(e.getMessage());
+          }
+      }
     */
       /** get next node id from DB connection */
       private long generateNodeID() throws SAXException {
           long nid=0;
-...
+      }
       /**
        * NOT USED
        * Update the node index (xml_index) for this node by generating
        * test strings that represent all of the relative and absolute
        * paths through the XML tree from document root to this node
-...
           pstmt.setLong(5, getParentID());
           // Step through the hashtable and insert each of the path values
           Enumeration en = pathlist.keys();
           while (en.hasMoreElements()) {
             String path = (String)en.nextElement();
             Long nodeid = (Long)pathlist.get(path);
             pstmt.setLong(1, nodeid.longValue());
             pstmt.setString(2, path);
             pstmt.executeUpdate();
             //System.out.println(nodeid + " ==> " + path);
+          }
           // Close the database statement
           pstmt.close();
         } catch (SQLException sqe) {
           System.err.println("SQL Exception while inserting path to index.");
           System.err.println(sqe.getMessage());
           throw new SAXException(sqe.getMessage());
+        }
+      }
       /**
        * USED FROM SEPARATE THREAD RUNNED from DBSAXHandler on endDocument()
        * Update the node index (xml_index) for this node by generating
        * test strings that represent all of the relative and absolute
        * paths through the XML tree from document root to this node
        */
       public void updateNodeIndex(Connection conn, String docid, String doctype)
                    throws SAXException
+      {
         Hashtable pathlist = new Hashtable();
         boolean atStartingNode = true;
         boolean atRootDocumentNode = false;
         DBSAXNode nodePointer = this;
         StringBuffer currentPath = new StringBuffer();
         int counter = 0;
         // Create a Hashtable of all of the paths to reach this node
         // including absolute paths and relative paths
         while (!atRootDocumentNode) {
           if (atStartingNode) {
             currentPath.insert(0, nodePointer.getTagName());
             pathlist.put(currentPath.toString(), new Long(getNodeID()));
             counter++;
             atStartingNode = false;
           } else {
             currentPath.insert(0, "/");
             currentPath.insert(0, nodePointer.getTagName());
             pathlist.put(currentPath.toString(), new Long(getNodeID()));
             counter++;
+          }
           // advance to the next parent node
           nodePointer = nodePointer.getParentNode();
           // If we're at the DOCUMENT node (root of DOM tree), add
           // the root "/" to make the absolute path
           if (nodePointer.getNodeType().equals("DOCUMENT")) {
             currentPath.insert(0, "/");
             pathlist.put(currentPath.toString(), new Long(getNodeID()));
             counter++;
             atRootDocumentNode = true;
+          }
+        }
         try {
           // Create an insert statement to reuse for all of the path insertions
           PreparedStatement pstmt = conn.prepareStatement(
                   "INSERT INTO xml_index (nodeid, path, docid, doctype, " +
                    "parentnodeid) " +
                   "VALUES (?, ?, ?, ?, ?)");
           ((OraclePreparedStatement)pstmt).setExecuteBatch(counter);
           pstmt.setString(3, docid);
           pstmt.setString(4, doctype);
           pstmt.setLong(5, getParentID());
           // Step through the hashtable and insert each of the path values
           Enumeration en = pathlist.keys();
           while (en.hasMoreElements()) {
             String path = (String)en.nextElement();

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 471

Added by bojilova about 24 years ago