Metacat

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

 */

                          implements LexicalHandler, DeclHandler, Runnable {

   private boolean	atFirstElement;

// DOCTITLE attr cleared from the db

//   private static final int MAXTITLELEN = 1000;

    *

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

    */

       stackCreated = true;

     }

   }

    *

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

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

    *        resides.

    *

    */

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

   {

     this(conn);

     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

    *

    *        resides.

    *

    */

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

   {

     this(conn);

     this.serverCode = serverCode;

     this.xmlIndex = new Thread(this);

   }

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

   public void startDocument() throws SAXException {

     MetaCatUtil.debugMessage("start Document", 50);

     // Create the document node representation as root

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

     // added as it is encountered

     nodeStack.push(rootNode);

   }

       xmlIndex.start();

     } catch (NullPointerException e) {

       xmlIndex = null;

       SAXException("Problem with starting thread for writing XML Index. " +

                    e.getMessage());

     }

   }

   /** SAX Handler that is called at the start of Namespace */

                                          throws SAXException

   {

    MetaCatUtil.debugMessage("NAMESPACE", 50);

    namespaces.put(prefix, uri);

   }

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

   public void startElement(String uri, String localName,

               throws SAXException {

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

     DBSAXNode parentNode = null;

     DBSAXNode currentNode = null;

     // Document representation that points to the root document node

     if (atFirstElement) {

       atFirstElement = false;

       if (docname == null) {

         docname = localName;

         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.

         // dbconnection from pool

         String catalogid = null;

         DBConnection dbConn = null;

         int serialNumber = -1;

         if ( systemid != null ) {

           try

           {

            dbConn=DBConnectionPool.getDBConnection

                                          ("DBSAXHandler.startElement");

            serialNumber=dbConn.getCheckOutSerialNumber();

            Statement stmt = dbConn.createStatement();

            ResultSet rs = stmt.executeQuery(

                          "SELECT catalog_id FROM xml_catalog " +

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

            boolean hasRow = rs.next();

            if ( hasRow ) {

             DBConnectionPool.returnDBConnection(dbConn, serialNumber);

           }//finally

         }

         //create documentImpl object by the constructor which can specify

         //the revision

                               this.pub, catalogid, this.serverCode);

       } catch (Exception ane) {

                                 action, ane));

       }

     // Create the current node representation

     currentNode = new DBSAXNode(connection, qName, localName, parentNode,

                                 currentDocument.getRootNodeID(),docid,

                                 currentDocument.getDoctype());

     // Add all of the namespaces

     String prefix;

     String nsuri;

     // Add all of the attributes

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

       currentNode.setAttribute(atts.getQName(i), atts.getValue(i), docid);

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

    int counter = 0;

    try {

      // Opening separate db connection for writing XML Index

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

      serialNumber=dbConn.getCheckOutSerialNumber();

      dbConn.setAutoCommit(false);

      //the following while loop construct checks to make sure that 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

      while(!inxmldoc)

      {

        String xmlDocumentsCheck = "select distinct docid from xml_documents";

                                 dbConn.prepareStatement(xmlDocumentsCheck);

        // Increase usage count

        dbConn.increaseUsageCount(1);

        ResultSet doccheckRS = xmlDocCheck.getResultSet();

        boolean tableHasRows = doccheckRS.next();

        Vector docids = new Vector();

        {

          docids.add(doccheckRS.getString(1).trim());

          tableHasRows = doccheckRS.next();

        }

        for(int i=0; i<docids.size(); i++)

        {

          String d = ((String)docids.elementAt(i)).trim();

        }

        xmlDocCheck.close();

      }

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

      //if this is a package file

      String packagedoctype = MetaCatUtil.getOption("packagedoctype");

      Vector packagedoctypes = new Vector();

      packagedoctypes = MetaCatUtil.getOptionList(packagedoctype);

      if ( packagedoctypes.contains(doctype) )

      {

        // write the package info to xml_relation table

        if ( aclid != null ) {

          runAccessControlList(dbConn, aclid);

        }

      }

      // if it is an access file

      else if ( MetaCatUtil.getOptionList(

                     MetaCatUtil.getOption("accessdoctype")).contains(doctype) )

      {

        // write ACL for the package

        //runAccessControlList(dbConn, docid);

      }

      //dbconn.close();

    } catch (Exception e) {

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

  }

  // It runs in xmlIndex thread. It writes ACL for a package.

  private void runAccessControlList (DBConnection conn, String aclid)

                                                throws Exception

  {

    // read the access file from xml_nodes

    // parse the access file and store the access info into xml_access

    new AccessControlList(conn, aclid, //new StringReader(xml),

                          user, groups, serverCode);

    conn.commit();

     int leftover = len;

     int offset = start;

     boolean moredata = true;

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

     }

   }

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

    * Ignorable white space

    */

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

     // but through characters() callback

     MetaCatUtil.debugMessage("IGNORABLEWHITESPACE", 50);

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

     String data = null;

     int leftover = len;

     int offset = start;

     boolean moredata = true;

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

     }

   }

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

    */

          throws SAXException {

     MetaCatUtil.debugMessage("PI", 50);

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

   //

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

               throws SAXException {

     docname = name;

     doctype = publicId;

     systemid = systemId;

     MetaCatUtil.debugMessage("Start DTD", 50);

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

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

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

   }

    */

   public void endDTD() throws SAXException {

     MetaCatUtil.debugMessage("end DTD", 50);

   }

    * SAX Handler that receives notification of comments in the DTD

    */

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

     }

   }

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

    */

   public void startCDATA() throws SAXException {

     MetaCatUtil.debugMessage("start CDATA", 50);

   }

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

    */

   public void endCDATA() throws SAXException {

     MetaCatUtil.debugMessage("end CDATA", 50);

   }

    * SAX Handler that receives notification of the start of entities

    */

   public void startEntity(String name) throws SAXException {

     }

   }

    * SAX Handler that receives notification of the end of entities

    */

   public void endEntity(String name) throws SAXException {

     }

   }

    * SAX Handler that receives notification of element declarations

    */

   public void elementDecl(String name, String model)

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

   }

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

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

                        + value, 50);

   }

    * SAX Handler that receives notification of internal entity declarations

    */

   public void internalEntityDecl(String name, String value)

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

   }

    * SAX Handler that receives notification of external entity declarations

    */

   public void externalEntityDecl(String name, String publicId,

                        String systemId)

                        throws org.xml.sax.SAXException {

//                              + " " + systemId);

                              + " " + systemId, 50);

     // it processes other external entity, not the DTD;

     // it doesn't signal for the DTD here

   // the next section implements the ErrorHandler interface

   //

    * SAX Handler that receives notification of fatal parsing errors

    */

   public void fatalError(SAXParseException exception) throws SAXException {

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

   }

    * SAX Handler that receives notification of recoverable parsing errors

    */

   public void error(SAXParseException exception) throws SAXException {

     throw (new SAXException("Processing error.", exception));

   }

    * SAX Handler that receives notification of warnings

    */

   public void warning(SAXParseException exception) throws SAXException {

     throw (new SAXException("Warning.", exception));

   }

   // Helper, getter and setter methods

   //

   /**

    * get the document name

    */