Metacat

/**

 *      Name: DBSAXNode.java

 *   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

 *

 *   Version: '$Id: DBSAXNode.java 177 2000-06-20 01:42:11Z jones $'

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Enumeration;

/** 

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

  private DBSAXNode	parentNode;

  /** 

   * Construct a new node instance for DOCUMENT nodes

   *

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

   * @param tagname the name of the node

   */

  public DBSAXNode (Connection conn, String tagname) {

    super(tagname);

    this.conn = conn;

    this.parentNode = null;

    writeChildNodeToDB("DOCUMENT", tagname, null);

    setRootNodeID(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 (Connection conn, String tagname, DBSAXNode parentNode, 

                    DBSAXNode rootNode, DBSAXDocument currentDocument) {

    super(tagname);

    setParentID(parentNode.getNodeID());

    setRootNodeID(rootNode.getNodeID());

    setDocID(currentDocument.getDocID());

    setNodeIndex(parentNode.incChildNum());

    this.conn = conn;

    this.parentNode = parentNode;

    writeChildNodeToDB("ELEMENT", getTagName(), null);

    updateNodeIndex();

  }

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

  public void writeChildNodeToDB(String nodetype, String nodename,

                                 String data) {

    try {

      PreparedStatement pstmt;

      if (nodetype == "DOCUMENT") {

        pstmt = conn.prepareStatement(

            "INSERT INTO xml_nodes " +

            "(nodeid, nodetype, nodename) " +

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

      } else {

        pstmt = conn.prepareStatement(

            "INSERT INTO xml_nodes " +

            "(nodeid, nodetype, nodename, " +

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

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

      }

      // Bind the values to the query

      long nid = generateNodeID();

      pstmt.setLong(1, nid);

      pstmt.setString(2, nodetype);

      pstmt.setString(3, nodename);

      if (nodetype != "DOCUMENT") {

        if (nodetype == "ELEMENT") {

          pstmt.setLong(4, getParentID());

          pstmt.setLong(5, getRootNodeID());

          pstmt.setString(6, getDocID());

          pstmt.setString(7, data);

          pstmt.setInt(8, getNodeIndex());

        } else {

          pstmt.setLong(4, getNodeID());

          pstmt.setLong(5, getRootNodeID());

          pstmt.setString(6, getDocID());

          pstmt.setString(7, data);

          pstmt.setInt(8, incChildNum());

        }

      }

      // Do the insertion

      pstmt.execute();

      pstmt.close();

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

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

                                                     nodename + ", " + 

                                                     data + ")" );

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

    }

  }

  /** 

   * creates SQL code to put nodename for the document node 

   * into DB connection 

   */

  public void writeNodename(String nodename) {

      try {

        PreparedStatement pstmt;

        pstmt = conn.prepareStatement(

              "UPDATE xml_nodes set nodename = ? " +

              "WHERE nodeid = ?");

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

      }

  }

  /** 

   * creates SQL code to put root node id for the document node 

   * into DB connection 

   */

  public void writeRootNodeID(long rootnode_id) {

      try {

        PreparedStatement pstmt;

        pstmt = conn.prepareStatement(

              "UPDATE xml_nodes set rootnodeid = ? " +

              "WHERE nodeid = ?");

        // Bind the values to the query

        pstmt.setLong(1, rootnode_id);

        pstmt.setLong(2, getNodeID());

        // Do the insertion

        pstmt.execute();

        pstmt.close();

      } catch (SQLException e) {

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

      }

  }

  /** 

   * 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() {

      long nid=0;

      Statement stmt;

      try {

        stmt = conn.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 getting id: " + e.getMessage());

      }

      return nid;

  }

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

  public void setAttribute(String attName, String attValue) {

    if (attName != null) {

      // Enter the attribute in the hash table

      super.setAttribute(attName, attValue);

      // And enter the attribute in the database

      writeChildNodeToDB("ATTRIBUTE", attName, attValue);

    } else {

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

    }

  }

  /** 

   * 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

   */

  private void updateNodeIndex() {

    Hashtable pathlist = new Hashtable();

    boolean atStartingNode = true;

    boolean atRootDocumentNode = false;

    DBSAXNode nodePointer = this;

    StringBuffer currentPath = new StringBuffer();

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

        atStartingNode = false;

      } else {

        currentPath.insert(0, "/");

        currentPath.insert(0, nodePointer.getTagName());

        pathlist.put(currentPath.toString(), new Long(getNodeID()));

      }

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

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

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

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

    }

  }

  /** get the parent of this node */

  public DBSAXNode getParentNode() {

    return parentNode;

  }

}