Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents an XML node and its contents

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author: daigle $'

 *     '$Date: 2010-02-03 13:29:30 -0800 (Wed, 03 Feb 2010) $'

 * '$Revision: 5208 $'

 *

 * 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.util.Hashtable;

import java.util.Enumeration;

import org.apache.log4j.Logger;

import org.xml.sax.SAXException;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.database.DatabaseService;

/**

 * A Class that represents an XML node and its contents and

 * can write its own representation to a database connection

 */

public class DBSAXNode extends BasicNode {

  private DBConnection	connection;

  private DBSAXNode	parentNode;

  private Logger logMetacat = Logger.getLogger(DBSAXNode.class);

  /**

   * Construct a new node instance for DOCUMENT nodes

   *

   * @param conn the JDBC Connection to which all information is written

   */

  public DBSAXNode (DBConnection conn, String docid) throws SAXException {

    super();

    this.connection = conn;

    this.parentNode = null;

    writeChildNodeToDB("DOCUMENT", null, null, docid);

    updateRootNodeID(getNodeID());

  }

  /**

   * Construct a new node instance for ELEMENT nodes

   *

   * @param conn the JDBC Connection to which all information is written

   * @param tagname the name of the node

   * @param parentNode the parent node for this node being created

   */

  public DBSAXNode (DBConnection conn, String qName, String lName,

                    DBSAXNode parentNode, long rootnodeid,

                    String docid, String doctype)

                                               throws SAXException {

    super(lName);

    this.connection = conn;

    this.parentNode = parentNode;

    setParentID(parentNode.getNodeID());

    setRootNodeID(rootnodeid);

    setDocID(docid);

    setNodeIndex(parentNode.incChildNum());

    writeChildNodeToDB("ELEMENT", qName, null, docid);

    //No writing XML Index from here. New Thread used instead.

    //updateNodeIndex(docid, doctype);

  }

  /**

   * Construct a new node instance for DTD nodes

   * This Node will write docname, publicId and systemId into db. Only

   * handle systemid  existed.(external dtd)

   *

   * @param conn the JDBC Connection to which all information is written

   * @param tagname the name of the node

   * @param parentNode the parent node for this node being created

   */

  public DBSAXNode (DBConnection conn, String docName, String publicId,

                    String systemId, DBSAXNode parentNode, long rootnodeid,

                    String docid) throws SAXException

  {

    super();

    this.connection = conn;

    this.parentNode = parentNode;

    setParentID(parentNode.getNodeID());

    setRootNodeID(rootnodeid);

    setDocID(docid);

    // insert dtd node only for external dtd definiation

    if (systemId != null)

    {

      //write docname to DB

      if (docName != null)

      {

        setNodeIndex(parentNode.incChildNum());

        writeDTDNodeToDB(DocumentImpl.DOCNAME, docName, docid);

      }

      //write publicId to DB

      if (publicId != null)

      {

        setNodeIndex(parentNode.incChildNum());

        writeDTDNodeToDB(DocumentImpl.PUBLICID, publicId, docid);

      }

      //write systemId to DB

      setNodeIndex(parentNode.incChildNum());

      writeDTDNodeToDB(DocumentImpl.SYSTEMID, systemId, docid);

    }

  }

  /** creates SQL code and inserts new node into DB connection */

  public long writeChildNodeToDB(String nodetype, String nodename,

                                 String data, String docid)

                                 throws SAXException {

    String limitedData = null;

    int leftover = 0;

    if (data != null) {

    	leftover = data.length();

    }

    int offset = 0;

    boolean moredata = true;

    long endNodeId = -1;

    // 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 > DBSAXHandler.MAXDATACHARS) {

        	limitedData = data.substring(offset, DBSAXHandler.MAXDATACHARS);

            leftover -= DBSAXHandler.MAXDATACHARS;

            offset += DBSAXHandler.MAXDATACHARS;

        } else {

        	limitedData = data;

            moredata = false;

        }

        endNodeId =  writeChildNodeToDBDataLimited(nodetype, nodename,

              limitedData, docid);

    }

    return endNodeId;

  }

  /** creates SQL code and inserts new node into DB connection */

  public long writeChildNodeToDBDataLimited(String nodetype, String nodename,

                                 String data, String docid)

                                 throws SAXException

  {

    long nid = -1;

    try

    {

      PreparedStatement pstmt;

      if (nodetype == "DOCUMENT") {

        pstmt = connection.prepareStatement(

            "INSERT INTO xml_nodes " +

            "(nodetype, nodename, nodeprefix, docid) " +

            "VALUES (?, ?, ?, ?)");

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        logMetacat.debug("DBSAXNode.writeChildNodeToDBDataLimited - inserting doc name: " + nodename);

      } else {

          if(data != null && !data.trim().equals("")

             && !data.trim().equals("NaN") && !data.trim().equalsIgnoreCase("Infinity")){

              try{

                  double numberData = Double.parseDouble(data);

                  pstmt = connection.prepareStatement(

                      "INSERT INTO xml_nodes " +

                      "(nodetype, nodename, nodeprefix, docid, " +

                      "rootnodeid, parentnodeid, nodedata, nodeindex, nodedatanumerical) " +

                      "VALUES (?, ?, ?, ?, ?, ?, ?, ?, "+ numberData +")");

              } catch (NumberFormatException nfe) {

                  pstmt = connection.prepareStatement(

                      "INSERT INTO xml_nodes " +

                      "(nodetype, nodename, nodeprefix, docid, " +

                      "rootnodeid, parentnodeid, nodedata, nodeindex) " +

                      "VALUES (?, ?, ?, ?, ?, ?, ?, ?)");

              }

          } else {

              pstmt = connection.prepareStatement(

                  "INSERT INTO xml_nodes " +

                  "(nodetype, nodename, nodeprefix, docid, " +

                  "rootnodeid, parentnodeid, nodedata, nodeindex) " +

                  "VALUES (?, ?, ?, ?, ?, ?, ?, ?)");

          }

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

      }

      // Bind the values to the query

      pstmt.setString(1, nodetype);

      int idx;

      if ( nodename != null && (idx = nodename.indexOf(":")) != -1 ) {

        pstmt.setString(2, nodename.substring(idx+1));

        pstmt.setString(3, nodename.substring(0,idx));

      } else {

        pstmt.setString(2, nodename);

        pstmt.setString(3, null);

      }

      pstmt.setString(4, docid);

      if (nodetype != "DOCUMENT") {

        if (nodetype == "ELEMENT") {

          pstmt.setLong(5, getRootNodeID());

          pstmt.setLong(6, getParentID());

          pstmt.setString(7, data);

          pstmt.setInt(8, getNodeIndex());

        } else {

          pstmt.setLong(5, getRootNodeID());

          pstmt.setLong(6, getNodeID());

          pstmt.setString(7, data);

          pstmt.setInt(8, incChildNum());

        }

      }

      // Do the insertion

      logMetacat.debug("DBSAXNode.writeChildNodeToDBDataLimited - SQL insert: " + pstmt.toString());

      pstmt.execute();

      pstmt.close();

      // get the generated unique id afterward

      nid = DatabaseService.getDBAdapter().getUniqueID(connection.getConnections(), "xml_nodes");

      //should increase connection usage!!!!!!

      if (nodetype.equals("DOCUMENT")) {

        // Record the root node id that was generated from the database

        setRootNodeID(nid);

      }

      if (nodetype.equals("DOCUMENT") || nodetype.equals("ELEMENT")) {

        // Record the node id that was generated from the database

        setNodeID(nid);

        // Record the node type that was passed to the method

        setNodeType(nodetype);

      }

    } catch (SQLException sqle) {

      logMetacat.error("DBSAXNode.writeChildNodeToDBDataLimited - SQL error inserting node: " + 

    		  "(" + nodetype + ", " + nodename + ", " + data + ") : " + sqle.getMessage());

      sqle.printStackTrace(System.err);

      throw new SAXException(sqle.getMessage());

    }

    return nid;

  }

  /**

   * update rootnodeid=nodeid for 'DOCUMENT' type of nodes only

   */

  public void updateRootNodeID(long nodeid) throws SAXException {

      try {

        PreparedStatement pstmt;

        pstmt = connection.prepareStatement(

              "UPDATE xml_nodes set rootnodeid = ? " +

              "WHERE nodeid = ?");

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setLong(1, nodeid);

        pstmt.setLong(2, nodeid);

        // Do the update

        pstmt.execute();

        pstmt.close();

      } catch (SQLException e) {

        System.out.println("Error in DBSaxNode.updateRootNodeID: " +

                           e.getMessage());

        throw new SAXException(e.getMessage());

      }

  }

  /**

   * creates SQL code to put nodename for the document node

   * into DB connection

   */

  public void writeNodename(String nodename) throws SAXException {

      try {

        PreparedStatement pstmt;

        pstmt = connection.prepareStatement(

              "UPDATE xml_nodes set nodename = ? " +

              "WHERE nodeid = ?");

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setString(1, nodename);

        pstmt.setLong(2, getNodeID());

        // Do the insertion

        pstmt.execute();

        pstmt.close();

      } catch (SQLException e) {

        System.out.println("Error in DBSaxNode.writeNodeName: " +

                           e.getMessage());

        throw new SAXException(e.getMessage());

      }

  }

 /** creates SQL code and inserts new node into DB connection */

  public long writeDTDNodeToDB(String nodename, String data, String docid)

                                 throws SAXException

  {

    long nid = -1;

    try

    {

      PreparedStatement pstmt;

      logMetacat.info("DBSAXNode.writeDTDNodeToDB - Insert dtd into db: "+nodename +" "+data);

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

            try{

                double numberData = Double.parseDouble(data);

                pstmt = connection.prepareStatement(

                    "INSERT INTO xml_nodes " +

                    "(nodetype, nodename, docid, " +

                    "rootnodeid, parentnodeid, nodedata, nodeindex, nodedatanumerical) " +

                    "VALUES (?, ?, ?, ?, ?, ?, ?, "+ numberData +")");

            } catch (NumberFormatException nfe) {

                pstmt = connection.prepareStatement(

                    "INSERT INTO xml_nodes " +

                    "(nodetype, nodename,  docid, " +

                    "rootnodeid, parentnodeid, nodedata, nodeindex) " +

                    "VALUES (?, ?, ?, ?, ?, ?, ?)");

            }

        } else {

            pstmt = connection.prepareStatement(

                  "INSERT INTO xml_nodes " +

                  "(nodetype, nodename, docid, " +

                  "rootnodeid, parentnodeid, nodedata, nodeindex) " +

                  "VALUES (?, ?, ?, ?, ?, ?, ?)");

        }

       // Increase DBConnection usage count

      connection.increaseUsageCount(1);

      // Bind the values to the query

      pstmt.setString(1, DocumentImpl.DTD);

      pstmt.setString(2, nodename);

      pstmt.setString(3, docid);

      pstmt.setLong(4, getRootNodeID());

      pstmt.setLong(5, getParentID());

      pstmt.setString(6, data);

      pstmt.setInt(7, getNodeIndex());

      // Do the insertion

      pstmt.execute();

      pstmt.close();

      // get the generated unique id afterward

      nid = DatabaseService.getDBAdapter().getUniqueID(connection.getConnections(), "xml_nodes");

      //should incease connection usage!!!!!!

    } catch (SQLException e) {

      System.out.println("Error in DBSaxNode.writeDTDNodeToDB");

      System.err.println("Error inserting node: (" + DocumentImpl.DTD + ", " +

                                                     nodename + ", " +

                                                     data + ")" );

      System.err.println(e.getMessage());

      e.printStackTrace(System.err);

      throw new SAXException(e.getMessage());

    }

    return nid;

  }

  /** get next node id from DB connection */

  private long generateNodeID() throws SAXException {

      long nid=0;

      Statement stmt;

      DBConnection dbConn = null;

      int serialNumber = -1;

      try {

        // Get DBConnection

        dbConn=DBConnectionPool.getDBConnection("DBSAXNode.generateNodeID");

        serialNumber=dbConn.getCheckOutSerialNumber();

        stmt = dbConn.createStatement();

        stmt.execute("SELECT xml_nodes_id_seq.nextval FROM dual");

        ResultSet rs = stmt.getResultSet();

        boolean tableHasRows = rs.next();

        if (tableHasRows) {

          nid = rs.getLong(1);

        }

        stmt.close();

      } catch (SQLException e) {

        System.out.println("Error in DBSaxNode.generateNodeID: " +

                            e.getMessage());

        throw new SAXException(e.getMessage());

      }

      finally

      {

        // Return DBconnection

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

      return nid;

  }

  /** Add a new attribute to this node, or set its value */

  public long setAttribute(String attName, String attValue, String docid)

              throws SAXException

  {

    long nodeId = -1;

    if (attName != null)

    {

      // Enter the attribute in the hash table

      super.setAttribute(attName, attValue);

      // And enter the attribute in the database

      nodeId = writeChildNodeToDB("ATTRIBUTE", attName, attValue, docid);

    }

    else

    {

      System.err.println("Attribute name must not be null!");

      throw new SAXException("Attribute name must not be null!");

    }

    return nodeId;

  }

  /** Add a namespace to this node */

  public long setNamespace(String prefix, String uri, String docid)

              throws SAXException

  {

    long nodeId = -1;

    if (prefix != null)

    {

      // Enter the namespace in a hash table

      super.setNamespace(prefix, uri);

      // And enter the namespace in the database

      nodeId = writeChildNodeToDB("NAMESPACE", prefix, uri, docid);

    }

    else

    {

      System.err.println("Namespace prefix must not be null!");

      throw new SAXException("Namespace prefix must not be null!");

    }

    return nodeId;

  }

  /**

   * 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(DBConnection 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 (?, ?, ?, ?, ?)");

      // Increase usage count

      conn.increaseUsageCount(1);

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

        Long nodeid = (Long)pathlist.get(path);

        pstmt.setLong(1, nodeid.longValue());

        pstmt.setString(2, path);

        pstmt.executeUpdate();

      }

      // Close the database statement

      pstmt.close();

    } catch (SQLException sqe) {

      System.err.println("SQL Exception while inserting path to index in " +

                         "DBSAXNode.updateNodeIndex for document " + docid);

      System.err.println(sqe.getMessage());

      throw new SAXException(sqe.getMessage());

    }

  }

  /** get the parent of this node */

  public DBSAXNode getParentNode() {

    return parentNode;

  }

}