Metacat

/**

 *  '$RCSfile$'

 *    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

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2003-07-29 09:08:20 -0700 (Tue, 29 Jul 2003) $'

 * '$Revision: 1764 $'

 *

 * 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

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.Reader;

import java.io.StringReader;

import java.util.Stack;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.EmptyStackException;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

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

 */

public class EmlSAXHandler extends DBSAXHandler implements 

                                                      AccessControlInterface

{

   private Vector allowRules = new Vector();

   private Vector denyRules = new Vector();

   private String documentId = null;

   private Vector subDocumentIdList = new Vector();

   private boolean processTopLeverAccess = false;

   private boolean processAdditionalAccess = false;

   private boolean processOtherAccess = false;

   private AccessSection accessObject= null;

   private AccessRule accessRule = null;

   private Vector accessObjectList = new Vector(); // store every access rule

   private Hashtable topLevelAccessControlMap = new Hashtable();

   private Hashtable additionalAccessControlMap = new Hashtable();// store 

                                                 //subtree access for single

                                                 // additionalmetacat

   private Vector additionalAccessMapList = new Vector();// store maps for 

                                                       // every addionalmetadata

   private Vector describesId = new Vector(); // store the ids in

                                      //additionalmetadata/describes

   private Stack subTreeInfoStack = new Stack();

   private Vector subTreeList = new Vector();// store the final subtree

   private Hashtable unChangableSubTreeHash = new Hashtable();

   private Stack currentUnChangedableSubtreeNodeStack =new Stack();

   private boolean startCriticalSubTree = false;

   private boolean firstElementForCriticalSubTree = false;

   private String firstElementNameForCriticalSubTree;

   private boolean needCheckingAccessModule = false;

   private Vector unChangableAccessSubTreeVector = new Vector();

   private Stack currentUnchangableAccessModuleNodeStack = new Stack();

   private AccessSection topAccessSection;

   // we need an another stack to store the access node which we pull out just

   // from xml. If a reference happend, we can use the stack the compare nodes

   private Stack storedAccessNodeStack = new Stack();

   // vector stored the data file id which will be write into relation table

   private Vector onlineDataFileIdVector = new Vector();

   // Indicator of inline data

   private boolean handleInlineData = false;

   private Stack   inlineDataNodeStack = null;

   private Hashtable inlineDataNameSpace = null;

   private FileWriter inlineDataFileWriter = null;

   private String inlineDataFileName = null;

   private int inLineDataIndex = 0;

   // Constant

   private static final String EML ="eml";

   private static final String DESCRIBES = "describes";

   private static final String ADDITIONALMETADATA = "additionalMetadata";

   private static final String ORDER = "order";

   private static final String ID ="id";

   private static final String REFERENCES = "references";

   public  static final String INLINE = "inline";

   private static final String ONLINE = "online";

   private static final String URL    = "url";

   private static final String PERMISSIONERROR ="User try to update a subtree"+

                               " which it doesn't have write permission!";

   private static final String UPDATEACCESSERROR = "User try to update a " + 

                      "access module which it doesn't have \"ALL\" permission!";

   private static final String TOPLEVEL = "top";

   private static final String SUBTREELEVEL ="subtree";

   private static final String RELATION = "Provides info for";

    /** Construct an instance of the handler class

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

    *

    */

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

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

                              throws SAXException

   {

     super(conn, action, docid, revision, user, groups, pub, serverCode);

     // Get the unchangable subtrees (user doesn't have write permission)

     try

     {

       PermissionController control = new PermissionController(docid);

       //unChangableSubTreeHash = getUnchangableSubTree(control, user, groups);

       //If the action is update and user doesn't have "ALL" permission

       // we need to check if user update access subtree

       if (action.equals("UPDATE") && 

         !control.hasPermission(user, groups, AccessControlInterface.ALLSTRING))

       {

         needCheckingAccessModule = true;

         unChangableAccessSubTreeVector = getAccessSubTreeListFromDB();

       }

     }

     catch (Exception e)

     {

       throw new SAXException(e.getMessage());

     }

   }

   /* Pass a permission control and get the list of unchangable subtree*/

   private Hashtable getUnchangableSubTree(PermissionController controller,

                                           String user, String[]groups)

                                           throws Exception

   {

     Hashtable list = null;

     Hashtable result = new Hashtable();

     // get unwritable sutree from controller

     list = controller.hasUnaccessableSubTree(user, groups, 

                                          AccessControlInterface.WRITESTRING);

      if (list != null)

      {

         Enumeration en = list.elements();

         while (en.hasMoreElements())

         {

           // Get  a subtree without node record list

           SubTree treeWithoutStack = (SubTree)en.nextElement();

           String subTreeId   = treeWithoutStack.getSubTreeId();

           MetaCatUtil.debugMessage("unchangable subtree id: " + subTreeId, 40);

           long   startNodeId = treeWithoutStack.getStartNodeId();

           MetaCatUtil.debugMessage("unchangable subtree startnodeid: " +

                                    startNodeId, 40);

           long   endNodeId   = treeWithoutStack.getEndNodeId();

           MetaCatUtil.debugMessage("unchangable subtree endnodeid: " +

                                     endNodeId, 40);

           // Get a subtree has the nodelist

           SubTree tree = new SubTree(docid, subTreeId, startNodeId, endNodeId);

           // add this tree to the result

           result.put(subTreeId, tree);

          }//while

      }//if

      return result;

   }

   /*

    * Get the subtree node info from xml_accesssubtree table

    */

   private Vector getAccessSubTreeListFromDB() throws Exception

   {

      Vector result = new Vector();

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String sql = "SELECT controllevel, subtreeid, startnodeid, endnodeid " + 

                   "FROM xml_accesssubtree WHERE docid like ? " +

                   "ORDER BY startnodeid ASC";

      try 

      {

        pstmt = connection.prepareStatement(sql);

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.execute();

        // Get result set

        rs = pstmt.getResultSet();

        while (rs.next())

        {

          String level = rs.getString(1);

          String sectionId = rs.getString(2);

          long startNodeId = rs.getLong(3);

          long endNodeId = rs.getLong(4);

          // create a new access section

          AccessSection accessObj = new AccessSection();

          accessObj.setControlLevel(level);

          accessObj.setDocId(docid);

          accessObj.setSubTreeId(sectionId);

          accessObj.setStartNodeId(startNodeId);

          accessObj.setEndNodeId(endNodeId); 

          Stack nodeStack = accessObj.getSubTreeNodeList();

          accessObj.setSubTreeNodeStack(nodeStack);

          // add this access obj into vector

          result.add(accessObj);

          // Get the top level access subtree control

          if ( level != null && level.equals(TOPLEVEL))

          {

            topAccessSection = accessObj;

          }

        }

        pstmt.close();

      }//try 

      catch (SQLException e) 

      {

        throw new 

        SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " + 

                      e.getMessage());

      }//catch

      finally

      {

        try

        {

          pstmt.close();

        }

        catch(SQLException ee)

        {

          throw new 

          SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " + 

          ee.getMessage());

        }

      }//finally

      return result;

   }

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

   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

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

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

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

    DBSAXNode parentNode = null;

    DBSAXNode currentNode = null;

   if (!handleInlineData)

   {

     // Get a reference to the parent node for the id

     try 

     {

       parentNode = (DBSAXNode)nodeStack.peek();

     } 

     catch (EmptyStackException e) 

     {

       parentNode = null;

     }

     //start handle inline data

     if (localName.equals(INLINE))

     {

       handleInlineData = true;

       inLineDataIndex ++;

       //intitialize namespace hash for in line data

       inlineDataNameSpace = new Hashtable();

       //initialize file writer

       String docidWithoutRev = MetaCatUtil.getDocIdFromString(docid);

       String seperator = MetaCatUtil.getOption("accNumSeparator");

       // the new file name will look like docid.rev.2

       inlineDataFileName = docidWithoutRev + seperator+revision+seperator +

                         inLineDataIndex;

       inlineDataFileWriter = createInlineDataFileWriter(inlineDataFileName);

     }

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

     {

       //compare text node data for unchangesubtree

       if (startCriticalSubTree)

       {

         compareTextNode(currentUnChangedableSubtreeNodeStack, textBuffer, 

                         PERMISSIONERROR);

       }//if

       //compare top level access module

       if (processTopLeverAccess && needCheckingAccessModule)

       {

          compareTextNode(currentUnchangableAccessModuleNodeStack, 

                          textBuffer, UPDATEACCESSERROR);

       }

       if (needCheckingAccessModule && 

       (processAdditionalAccess || processOtherAccess || processTopLeverAccess))

       {

        // stored the pull out nodes into storedNode stack

        NodeRecord nodeElement = new NodeRecord(-2, -2, -2, "TEXT", 

                      null, null, MetaCatUtil.normalize(textBuffer.toString()));

        storedAccessNodeStack.push(nodeElement);

      }

       // write the textbuffer into db for parent node.

        endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, parentNode);

        // rest hitTextNode

        hitTextNode =false;

        // reset textbuffer

        textBuffer = null;

        textBuffer = new StringBuffer();

     }

     // Document representation that points to the root document node

     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;

         }

         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

         doctype = docname;

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

       }

       rootNode.writeNodename(docname);

       try 

       {

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

         String catalogid = null;

         DBConnection dbConn = null;

         int serialNumber = -1;

         try

         {

            // Get dbconnection

            dbConn=DBConnectionPool.getDBConnection

                                          ("DBSAXHandler.startElement");

            serialNumber=dbConn.getCheckOutSerialNumber();

            Statement stmt = dbConn.createStatement();

            ResultSet rs = stmt.executeQuery(

                          "SELECT catalog_id FROM xml_catalog " +

                          "WHERE entry_type = 'Schema' " +

                          "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

         //create documentImpl object by the constructor which can specify

         //the revision

         currentDocument = new DocumentImpl(connection, rootNode.getNodeID(),

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

                               this.pub, catalogid, this.serverCode);

       } 

       catch (Exception ane) 

       {

         throw (new SAXException("Error in EMLSaxHandler.startElement " +

                                 action, ane));

       }

     }

     // Create the current node representation

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

                                 currentDocument.getRootNodeID(),docid,

                                 currentDocument.getDoctype());

     // Use a local variable to store the element node id

     // If this element is a start point of subtree(section), it will be stored

     // otherwise, it will be discated

     long startNodeId = currentNode.getNodeID();

     // Add all of the namespaces

     String prefix =null;

     String nsuri = null;

     Enumeration prefixes = namespaces.keys();

     while ( prefixes.hasMoreElements() ) 

     {

       prefix = (String)prefixes.nextElement();

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

       endNodeId = currentNode.setNamespace(prefix, nsuri, docid);

     }

     // Add all of the attributes

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

     {

       String attributeName = atts.getQName(i);

       String attributeValue = atts.getValue(i);

       endNodeId = 

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

       }

       else if (attributeName !=null && attributeName.equals(ID))

       {

         //check unchangedable subtree hash if contains this subtree id

         if (unChangableSubTreeHash.containsKey(attributeValue))

         {

           // this subtree couldn't be changed by the user and move it from hash

           SubTree currentUnChangedableSubtree = (SubTree)

                                  unChangableSubTreeHash.remove(attributeValue);

           currentUnChangedableSubtreeNodeStack = currentUnChangedableSubtree.

                                                         getSubTreeNodeStack();

           startCriticalSubTree = true;

           firstElementForCriticalSubTree = true;

         }

         // handle subtree info

         SubTree subTress = new SubTree();

         // set sub tree id

         subTress.setSubTreeId(attributeValue);

         // set sub tree sstart lement name

         subTress.setStartElementName(currentNode.getTagName());

         // set start node number

         subTress.setStartNodeId(startNodeId);

         // add to stack, but it didn't get end node id yet

         subTreeInfoStack.push(subTress);

       }

     }//for

     // handle access stuff

     if (localName.equals(ACCESS))

     {

       // if it is in addtionalmetacat

       if (parentNode.getTagName() == ADDITIONALMETADATA)

       {

         processAdditionalAccess = true;

       }

       else

       {

         //make sure the access is top level

         // this mean current node's parent's parent should be "eml"

         DBSAXNode tmpNode = (DBSAXNode) nodeStack.pop();// pop out parent node

         //peek out grandParentNode

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

         // put parent node back

         nodeStack.push(tmpNode);

         String grandParentTag = grandParentNode.getTagName();

         if (grandParentTag.equals(EML))

         {

           processTopLeverAccess = true;

         }

         else

         {

           // process other access embedded into resource level module

           processOtherAccess = true;

         }

       }

       // create access object 

       accessObject = new AccessSection();

         // set permission order

       String permOrder = currentNode.getAttribute(ORDER);

       accessObject.setPermissionOrder(permOrder);

       // set access id

       String accessId = currentNode.getAttribute(ID);

       accessObject.setSubTreeId(accessId);

       accessObject.setStartNodeId(startNodeId);

       accessObject.setDocId(docid);

       // load top level node stack to currentUnchangableAccessModuleNodeStack

       if (processTopLeverAccess && needCheckingAccessModule)

       {

         // get the node stack for

         currentUnchangableAccessModuleNodeStack = 

                                        topAccessSection.getSubTreeNodeStack();

       }

     }

     // Set up a access rule for allow

     else if (parentNode.getTagName() != null && 

       (parentNode.getTagName()).equals(ACCESS) && localName.equals(ALLOW))

     {

       accessRule = new AccessRule(); 

       //set permission type "allow"

       accessRule.setPermissionType(ALLOW);

     }

     // set up an access rule for den

     else if (parentNode.getTagName() != null 

       && (parentNode.getTagName()).equals(ACCESS) && localName.equals(DENY))

     {

       accessRule = new AccessRule();

       //set permission type "allow"

       accessRule.setPermissionType(DENY);

     }

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

    // handle critical subtree

    if (startCriticalSubTree && firstElementForCriticalSubTree)

    {

      //store the element name

      firstElementNameForCriticalSubTree = qName;

      firstElementForCriticalSubTree = false;

    }//for first element

    // handle critical subtree

    if (startCriticalSubTree)

    {

      compareElementNameSpaceAttributes(currentUnChangedableSubtreeNodeStack,

                                        namespaces, atts, localName, 

                                        PERMISSIONERROR);

    }

    //compare top access level module

    if (processTopLeverAccess && needCheckingAccessModule)

    {

      compareElementNameSpaceAttributes(currentUnchangableAccessModuleNodeStack, 

                                        namespaces, atts, localName, 

                                        UPDATEACCESSERROR);

    }

    // store access module element and attributes into stored stack

    if (needCheckingAccessModule && 

       (processAdditionalAccess || processOtherAccess || processTopLeverAccess))

    {

       // stored the pull out nodes into storedNode stack

       NodeRecord nodeElement = new NodeRecord(-2, -2, -2, "ELEMENT", 

                                localName, prefix, MetaCatUtil.normalize(null));

       storedAccessNodeStack.push(nodeElement);

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

       {

         String attributeName = atts.getQName(i);

         String attributeValue = atts.getValue(i);

         NodeRecord nodeAttribute = new NodeRecord(-2, -2, -2, "ATTRIBUTE",

                    attributeName, null, MetaCatUtil.normalize(attributeValue));

         storedAccessNodeStack.push(nodeAttribute);

       }

    }

    // reset name space

    namespaces = null;

    namespaces = new Hashtable();

   }//not inline data

   else

   {

       // we don't buffer the inline data in characters() method

       // so start character don't need to hand text node.

       // inline data may be the xml format.

       StringBuffer inlineElements = new StringBuffer();

       inlineElements.append("<").append(qName);

       // append attributes

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

       {

         String attributeName = atts.getQName(i);

         String attributeValue = atts.getValue(i);

         inlineElements.append(" ");

         inlineElements.append(attributeName);

         inlineElements.append("=\"");

         inlineElements.append(attributeValue);

         inlineElements.append("\"");

       }

       // append namespace

       String prefix =null;

       String nsuri = null;

       Enumeration prefixes = inlineDataNameSpace.keys();

       while ( prefixes.hasMoreElements() ) 

       {

         prefix = (String)prefixes.nextElement();

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

         inlineElements.append(" ");

         inlineElements.append("xmlns:");

         inlineElements.append(prefix);

         inlineElements.append("=\"");

         inlineElements.append(nsuri);

         inlineElements.append("\"");

       }

       inlineElements.append(">");

       //reset inline data name space

       inlineDataNameSpace = null;

       inlineDataNameSpace = new Hashtable();

       //write inline data into file

       MetaCatUtil.debugMessage("the inline element data is: "+ 

                                 inlineElements.toString(), 50);

       writeInlineDataIntoFile(inlineDataFileWriter, inlineElements);

   }//else

  }

  private void compareElementNameSpaceAttributes(Stack unchangableNodeStack, 

                                            Hashtable nameSpaces,

                                            Attributes attributes,

                                            String localName, String error) 

                                            throws SAXException

  {

     //Get element subtree node stack (element node)

      NodeRecord elementNode = null;

      try

      {

        elementNode= (NodeRecord) unchangableNodeStack.pop();

      }

      catch (EmptyStackException ee)

      {

        MetaCatUtil.debugMessage("Node stack is empty for element data", 35);

        throw new SAXException(error);

      }

      MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);

      MetaCatUtil.debugMessage("node type from stack: " + 

                                  elementNode.getNodeType(), 40);

      MetaCatUtil.debugMessage("node name from xml document: " + 

                                  localName, 40);

      MetaCatUtil.debugMessage("node name from stack: " +

                                  elementNode.getNodeName(), 40);

      MetaCatUtil.debugMessage("node data from stack: " +

                                  elementNode.getNodeData(), 40);

      MetaCatUtil.debugMessage("node id is: "+ elementNode.getNodeId(), 40);

      // if this node is not element or local name not equal or name space not

      // equals, throw an exception

      if (!elementNode.getNodeType().equals("ELEMENT") || 

          !localName.equals(elementNode.getNodeName()))

        //  (uri != null && !uri.equals(elementNode.getNodePrefix())))

      {

        MetaCatUtil.debugMessage("Inconsistence happend: ", 40);

        MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);

        MetaCatUtil.debugMessage("node type from stack: " + 

                                  elementNode.getNodeType(), 40);

        MetaCatUtil.debugMessage("node name from xml document: " + 

                                  localName, 40);

        MetaCatUtil.debugMessage("node name from stack: " +

                                  elementNode.getNodeName(), 40);

        MetaCatUtil.debugMessage("node data from stack: " +

                                  elementNode.getNodeData(), 40);

        MetaCatUtil.debugMessage("node id is: "+ elementNode.getNodeId(), 40);

        throw new SAXException(error);

      }

      //compare namespace

     Enumeration nameEn = nameSpaces.keys();

     while ( nameEn.hasMoreElements() ) 

     {

       //Get namespacke node stack (element node)

       NodeRecord nameNode = null;

       try

       { 

         nameNode = (NodeRecord) unchangableNodeStack.pop();

       }

       catch (EmptyStackException ee)

       {

         MetaCatUtil.debugMessage("Node stack is empty for namespace data", 35);

         throw new SAXException(error);

       }

       String prefixName = (String)nameEn.nextElement(); 

       String nameSpaceUri = (String)nameSpaces.get(prefixName);

       if (!nameNode.getNodeType().equals("NAMESPACE") || 

           !prefixName.equals(nameNode.getNodeName()) || 

           !nameSpaceUri.equals(nameNode.getNodeData()))

       { 

         MetaCatUtil.debugMessage("Inconsistence happend: ", 40);

         MetaCatUtil.debugMessage("current node type from xml is NAMESPACE", 40);

         MetaCatUtil.debugMessage("node type from stack: " + 

                                  nameNode.getNodeType(), 40);

         MetaCatUtil.debugMessage("current node name from xml is: " + 

                                   prefixName, 40);

         MetaCatUtil.debugMessage("node name from stack: " +

                                  nameNode.getNodeName(), 40);

         MetaCatUtil.debugMessage("current node data from xml is: " + 

                                   nameSpaceUri, 40);

         MetaCatUtil.debugMessage("node data from stack: " +

                                  nameNode.getNodeData(), 40);

         MetaCatUtil.debugMessage("node id is: "+ nameNode.getNodeId(), 40);

         throw new SAXException(error);

       }

     }//while

      //compare attributes

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

      {

        NodeRecord attriNode = null;

        try

        {

          attriNode = (NodeRecord)unchangableNodeStack.pop();

        }

        catch (EmptyStackException ee)

        {

          MetaCatUtil.debugMessage("Node stack is empty for attribute data", 35);

          throw new SAXException(error);

        }

        String attributeName = attributes.getQName(i);

        String attributeValue = attributes.getValue(i);

        MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);

        MetaCatUtil.debugMessage("node type from stack: " + 

                                   attriNode.getNodeType(), 40);

        MetaCatUtil.debugMessage("current node name from xml is: " + 

                                    attributeName, 40);

        MetaCatUtil.debugMessage("node name from stack: " +

                                    attriNode.getNodeName(), 40);

        MetaCatUtil.debugMessage("current node data from xml is: " + 

                                    attributeValue, 40);

        MetaCatUtil.debugMessage("node data from stack: " +

                                    attriNode.getNodeData(), 40);

        MetaCatUtil.debugMessage("node id  is: "+ attriNode.getNodeId(), 40);

        if (!attriNode.getNodeType().equals("ATTRIBUTE") || 

            !attributeName.equals(attriNode.getNodeName()) ||

            !attributeValue.equals(attriNode.getNodeData()))

        {

          MetaCatUtil.debugMessage("Inconsistence happend: ", 40);

          MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);

          MetaCatUtil.debugMessage("node type from stack: " + 

                                   attriNode.getNodeType(), 40);

          MetaCatUtil.debugMessage("current node name from xml is: " + 

                                    attributeName, 40);

          MetaCatUtil.debugMessage("node name from stack: " +

                                    attriNode.getNodeName(), 40);

          MetaCatUtil.debugMessage("current node data from xml is: " + 

                                    attributeValue, 40);

          MetaCatUtil.debugMessage("node data from stack: " +

                                    attriNode.getNodeData(), 40);

          MetaCatUtil.debugMessage("node is: "+ attriNode.getNodeId(), 40);

          throw new SAXException(error);

        }

      }//for

  }

  /* mehtod to compare current text node and node in db*/                                         

  private void compareTextNode(Stack nodeStack, StringBuffer text, String error) 

                               throws SAXException

  {

    NodeRecord node = null;

    //get node from current stack

    try

    { 

      node = (NodeRecord)nodeStack.pop();

    }

    catch (EmptyStackException ee)

    {

      MetaCatUtil.

          debugMessage("Node stack is empty for text data in startElement", 35);

      throw new SAXException(error);

    }

    MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);

    MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

    MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        text.toString(), 40);

    MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

    MetaCatUtil.debugMessage("node name from stack: " +

                                        node.getNodeName(), 40);

    MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);              

    if (!node.getNodeType().equals("TEXT") || 

        !(text.toString()).equals(node.getNodeData())) 

    { 

      MetaCatUtil.debugMessage("Inconsistence happend: ", 40);

      MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);

      MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

      MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        text.toString(), 40);

      MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

      MetaCatUtil.debugMessage("node name from stack: " +

                                        node.getNodeName(), 40);

      MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);

      throw new SAXException(error);

    }//if

  } 

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

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

  {

     MetaCatUtil.debugMessage("CHARACTERS", 50);

     if (!handleInlineData)

     {

        // buffer all text nodes for same element. This is for text was splited

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

        {

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

        }

     }

     else

     {