Metacat

/**

 *        Name: DBSAXDocument.java

 *     Purpose: A Class that writes an XML document main data

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

 *              National Center for Ecological Analysis and Synthesis

 *     Authors: Jivka Bojilova

 *

 *     Version: '$Id$'

 */

//package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Enumeration;

/** 

 * A Class that writes an XML document main data to a database connection

 */

public class DBSAXDocument {

    private Connection		conn;

    private long            rootnodeid;

    private String          docname;

    private String          doctype;

    /** 

     * Construct a new document instance

     *

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

     * @param rootnodeid - sequence id of the root node in the document

     * @param docname - the name of DTD, i.e. the name immediately following the DOCTYPE keyword - should be the root element name.

     * (Oracle's and IBM parsers are not aware if it is not the root element name)

     * @param doctype - Public ID of the DTD, i.e. the name immediately following the PUBLIC keyword in DOCTYPE declaration.

     *

     */

    public DBSAXDocument (Connection conn, long rootnodeid, String docname, String doctype)

    {

      this.conn = conn;

      this.rootnodeid = rootnodeid;

      this.docname = docname;

      this.doctype = doctype;

      writeDocumentToDB();

      System.out.println("DBSAXDocument.writeDocumentToDB");

    }

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

    private void writeDocumentToDB() {

        try {

          conn.setAutoCommit(false);

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_documents (docid, rootnodeid, docname, doctype) " +

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

          // Bind the values to the query

          pstmt.setLong(1, rootnodeid);

          pstmt.setString(2, docname);

          pstmt.setString(3, doctype);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          conn.commit();

          conn.setAutoCommit(true);

        } catch (SQLException e) {

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

        }

    }

}

source_doctype, public_id, /*

set echo off

DROP SEQUENCE xml_entity_id_seq;

DROP SEQUENCE xml_documents_id_seq;

DROP TRIGGER xml_documents_before_insert;

DROP TRIGGER xml_cat_entities_before_insert;

DROP TABLE xml_catalog_entities;

DROP TABLE xml_catalog;

	nodeindex	NUMBER(10),

	nodetype	VARCHAR2(20),

	nodename	VARCHAR2(100),

	nodedata	LONG,

 * Documents -- table to store XML documents

	docname		VARCHAR2(100),

	doctype		VARCHAR2(100),

CREATE SEQUENCE xml_documents_id_seq;

CREATE TRIGGER xml_documents_before_insert

BEFORE INSERT ON xml_documents FOR EACH ROW

BEGIN

  SELECT xml_documents_id_seq.nextval

    INTO :new.docid

    FROM dual;

END;

/

/* 

 * XML Catalog -- tables to store all external sources for XML documents

 */

CREATE TABLE xml_catalog (

	doctype		VARCHAR2(100),

	date_created	DATE,

	date_updated	DATE,

   CONSTRAINT xml_catalog_pk PRIMARY KEY (doctype)

);

CREATE TABLE xml_catalog_entities (

	entity_id	NUMBER(20),

	entity_name	VARCHAR2(100),

	entity_type	VARCHAR2(20),

	source_doctype	VARCHAR2(100),

	target_doctype	VARCHAR2(100),

	public_id	VARCHAR2(100),

	system_id	VARCHAR2(1000),

	date_created	DATE,

	date_updated	DATE,

   CONSTRAINT xml_catalog_entities_pk PRIMARY KEY (entity_id),

   CONSTRAINT xml_catalog_entities_uk UNIQUE (entity_type, source_doctype, target_doctype, public_id),

   CONSTRAINT xml_source_catalog_fk FOREIGN KEY (source_doctype) REFERENCES xml_catalog,

   CONSTRAINT xml_target_catalog_fk FOREIGN KEY (target_doctype) REFERENCES xml_catalog

);

CREATE SEQUENCE xml_entity_id_seq;

CREATE TRIGGER xml_cat_entities_before_insert

BEFORE INSERT ON xml_catalog_entities FOR EACH ROW

BEGIN

  SELECT xml_entity_id_seq.nextval

    INTO :new.entity_id

    FROM dual;

END;

/

//package edu.ucsb.nceas.metacat;

import oracle.xml.parser.v2.DTD;

   static int elementNo = 0;

   private String docname;

   private String doctype;

   private String systemid;

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

   public void startDocument() throws SAXException

   {

    System.out.println("start Document");

   }

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

   public void endDocument() throws SAXException

   {

    System.out.println("end Document");

   }

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

   public void setDoctype(DTD dtd) throws SAXException

   {

    // here is a bug: dtd.getPublicId() and dtd.getSustemId() return null.

    docname = dtd.getName();

    doctype = dtd.getPublicId();

    systemid = dtd.getSystemId();

    System.out.println("DOCTYPE: " + docname);

    System.out.println("DOCTYPE: " + doctype);

    System.out.println("DOCTYPE: " + systemid);

   }

   /** SAX Handler that receives notification of end of DTD 

     * All events in DTDHandler about all unparsed entities and the event in EntityResolver for the DTD file declaration

     * appear between setDoctype and endDoctype.

     * The rest of parsable external entities inside DTD file appear later in the elements from where they are referred to. */

   public void endDoctype() throws SAXException

   {

    System.out.println("end of DOCTYPE");

    if (doctype == null)

        doctype = DBEntityResolver.doctype;

   }

      elementNo++;

      if ((elementNo == 1) && (doctype == null))

        throw new SAXException("No DOCTYPE declaration or PUBLIC ID provided");

      int nodeIndex;

        nodeIndex = parentElement.incChildNum();

        nodeIndex = 0;

      currentElement = new DBSAXElement(conn, localName, parent_id, nodeIndex);

      // go to create document definition in the db

      // call once after insertion of the first element

      if (parent_id == 0) {

        long rootnodeid = currentElement.getElementID();

        new DBSAXDocument(conn, rootnodeid, docname, doctype);

      }

   /** SAX Handler called once for each comment found: 

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

     * For now works only for comments after the root element. */

   public void comment(String data) throws SAXException

   {

    if (elementNo > 0) {

      DBSAXElement currentElement = (DBSAXElement)elementStack.peek();

      currentElement.writeCommentToDB(data);

    }

   }

/**

 *        Name: DBSAXDocument.java

 *     Purpose: A Class that writes an XML document main data

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

 *              National Center for Ecological Analysis and Synthesis

 *     Authors: Jivka Bojilova

 *

 *     Version: '$Id$'

 */

//package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Enumeration;

/** 

 * A Class that writes an XML document main data to a database connection

 */

public class DBSAXDocument {

    private Connection		conn;

    private long            rootnodeid;

    private String          docname;

    private String          doctype;

    /** 

     * Construct a new document instance

     *

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

     * @param rootnodeid - sequence id of the root node in the document

     * @param docname - the name of DTD, i.e. the name immediately following the DOCTYPE keyword - should be the root element name.

     * (Oracle's and IBM parsers are not aware if it is not the root element name)

     * @param doctype - Public ID of the DTD, i.e. the name immediately following the PUBLIC keyword in DOCTYPE declaration.

     *

     */

    public DBSAXDocument (Connection conn, long rootnodeid, String docname, String doctype)

    {

      this.conn = conn;

      this.rootnodeid = rootnodeid;

      this.docname = docname;

      this.doctype = doctype;

      writeDocumentToDB();

      System.out.println("DBSAXDocument.writeDocumentToDB");

    }

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

    private void writeDocumentToDB() {

        try {

          conn.setAutoCommit(false);

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_documents (docid, rootnodeid, docname, doctype) " +

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

          // Bind the values to the query

          pstmt.setLong(1, rootnodeid);

          pstmt.setString(2, docname);

          pstmt.setString(3, doctype);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          conn.commit();

          conn.setAutoCommit(true);

        } catch (SQLException e) {

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

        }

    }

}

/**

 *        Name: DBSAXHandler.java

 *     Purpose: A Class that implements org.xml.sax.EntityResolver interface

 *              for resolving external entities

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

 *              National Center for Ecological Analysis and Synthesis

 *     Authors: Jivka Bojilova

 *

 *     Version: '$Id$'

 */

//package edu.ucsb.nceas.metacat;

import org.xml.sax.*;

import java.sql.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.util.Stack;

import java.util.EmptyStackException;

/** 

 * A database aware Class implementing EntityResolver interface for the SAX parser to

 * call when processing the XML stream and intercepting any external entities

 * (including the external DTD subset and external parameter entities, if any) before including them.

 */

public class DBEntityResolver implements EntityResolver

{

   static String doctype = null;

   static Connection conn = null;

   private int pIdCounter = 0;

   private long currentElementNo;

   /** Construct an instance of the DBEntityResolver clas

    *

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

    */

   public DBEntityResolver(Connection conn)

   {

      this.conn = conn;

   }

   /** The Parser call this method before opening any external entity 

     * except the top-level document entity (including the external DTD subset,

     * external entities referenced within the DTD, and external entities referenced 

     * within the document element)*/

   public InputSource resolveEntity (String publicId, String systemId)

            throws MalformedURLException

   {

     String dbSystemId;

     if (publicId != null) {

        pIdCounter += 1;

        currentElementNo = DBSAXHandler.elementNo;

        System.out.println("from DBEntityResolver: current element is " + DBSAXHandler.elementNo);

        System.out.println("from DBEntityResolver: " + pIdCounter + " " + publicId);

        // look at the db XML Catalog and get dbSystemId by this publicId

        if (currentElementNo == 0) {

            doctype = publicId;

            dbSystemId = getDTDSystemID (conn, publicId);

            if (dbSystemId == "")

                // register publicId in db and use the provided systemId

                if (systemId != "") {

                    System.out.println("from DBEntityResolver: " + systemId);

                    new URL(systemId);

                    registerDTDPublicID (conn, publicId, systemId);

                    return null;

                }

            new URL(dbSystemId);

            System.out.println("from DBEntityResolver: db System ID: " + dbSystemId);

            return new InputSource(dbSystemId);

        } 

        else {

            // look at the db XML Catalog and get dbSystemId by this publicId for a given doctype

            dbSystemId = getEntitySystemID (conn, doctype, publicId);

            if (dbSystemId == "")

                // register publicId in db for a given doctype and use the provided systemId

                if (systemId != "") {

                    System.out.println("from DBEntityResolver: " + systemId);

                    new URL(systemId);

                    registerEntityPublicID (conn, doctype, publicId, systemId);

                    return null;

                }

            new URL(dbSystemId);

            System.out.println("from DBEntityResolver: db System ID: " + dbSystemId);

            return new InputSource(dbSystemId);

        }  

     }

     if ( systemId != null) {

        System.out.println("from DBEntityResolver: " + systemId);

        new URL(systemId);

     }

     // use the default behaviour

     return null;

   }

   /** Look at db XML Catalog to get System ID (if any) for that Public ID.

     * Return empty string if there are not */

   private String getDTDSystemID (Connection conn, String publicId)

   {

        String system_id = "";

        Statement stmt;

        try {

          stmt = conn.createStatement();

          stmt.execute("SELECT system_id FROM xml_catalog_entities a, xml_catalog b " + 

                       "WHERE a.entity_type = 'DTD' AND a.source_doctype = b.doctype AND b.doctype = '" + publicId + "'");

          try {

            ResultSet rs = stmt.getResultSet();

            try {

              boolean tableHasRows = rs.next();

              if (tableHasRows) {

                try {

                  system_id = rs.getString(1);

                } catch (SQLException e) {

                  System.out.println("DBEntityResolver.getDTDSystemID() - Error with getString: " + e.getMessage());

                }

              }

            } catch (SQLException e) {

              System.out.println("DBEntityResolver.getDTDSystemID() - Error with next: " + e.getMessage());

            }

          } catch (SQLException e) {

            System.out.println("DBEntityResolver.getDTDSystemID() - Error with getrset: " + e.getMessage());

          }

          stmt.close();

        } catch (SQLException e) {

          System.out.println("DBEntityResolver.getDTDSystemID() - Error getting id: " + e.getMessage());

        }

        // return the selected System ID

        return system_id;

   }

   /** Register Public ID in db XML Catalog */

   private void registerDTDPublicID (Connection conn, String publicId, String systemId)

   {

        try {

          conn.setAutoCommit(false);

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_catalog (doctype) VALUES (?)");

          // Bind the values to the query

          pstmt.setString(1, publicId);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_catalog_entities (entity_id, entity_type, source_doctype, system_id) " +

                "VALUES (null, 'DTD', ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, publicId);

          pstmt.setString(2, systemId);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          conn.commit();

          conn.setAutoCommit(true);

        } catch (SQLException e) {

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

        }

   }

   /** Look at db XML Catalog to get System ID (if any) for that Public ID and doctype.

     * Return empty string if there are not */

   private String getEntitySystemID (Connection conn, String doctype, String publicId)

   {

        String system_id = "";

        Statement stmt;

        try {

          stmt = conn.createStatement();

          stmt.execute("SELECT system_id FROM xml_catalog_entities " + 

                       "WHERE entity_type = 'ENTITY' AND source_doctype = '" + doctype + "' AND public_id = '" + publicId + "'");

          try {

            ResultSet rs = stmt.getResultSet();

            try {

              boolean tableHasRows = rs.next();

              if (tableHasRows) {

                try {

                  system_id = rs.getString(1);

                } catch (SQLException e) {

                  System.out.println("DBEntityResolver.getEntitySystemID() - Error with getString: " + e.getMessage());

                }

              }

            } catch (SQLException e) {

              System.out.println("DBEntityResolver.getEntitySystemID() - Error with next: " + e.getMessage());

            }

          } catch (SQLException e) {

            System.out.println("DBEntityResolver.getEntitySystemID() - Error with getrset: " + e.getMessage());

          }

          stmt.close();

        } catch (SQLException e) {

          System.out.println("DBEntityResolver.getEntitySystemID() - Error getting id: " + e.getMessage());

        }

        // return the selected System ID number

        return system_id;

   }

   /** Register Public ID in db XML Catalog */

   private void registerEntityPublicID (Connection conn, String doctype, String publicId, String systemId)

   {

        try {

          conn.setAutoCommit(false);

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_catalog_entities (entity_id, entity_name, entity_type, source_doctype, public_id, system_id) " +

                "VALUES (null, null, 'ENTITY', ?, ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, doctype);

          pstmt.setString(2, publicId);

          pstmt.setString(3, systemId);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          conn.commit();

          conn.setAutoCommit(true);

        } catch (SQLException e) {

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

        }

   }

}

//package edu.ucsb.nceas.metacat;

                         long parent_id, int nodeIndex) {

      super(tagname, parent_id, nodeIndex);

                "nodename, parentnodeid, nodeindex) VALUES (null, ?, ?, ?, ?)");

          //pstmt.setInt(4, null);

            pstmt.setInt(4, getNodeIndex());

    /** creates SQL code and inserts comment into DB connection */

    void writeCommentToDB(String data) {

        try {

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_nodes (nodeid, nodetype, " +

                "nodename, parentnodeid, nodedata) VALUES (null, ?, null, ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, "COMMENT");

          pstmt.setLong(2, getElementID());

          pstmt.setString(3, data);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

        } catch (SQLException e) {

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

        }

    }

//package edu.ucsb.nceas.metacat;

                         long parent_id, int nodeIndex) {

      super(tagname, parent_id, nodeIndex);

                "nodename, parentnodeid, nodeindex) VALUES (null, ?, ?, ?, ?)");

          //pstmt.setInt(4, null);

            pstmt.setInt(4, getNodeIndex());

    /** creates SQL code and inserts comment into DB connection */

    void writeCommentToDB(String data) {

        try {

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_nodes (nodeid, nodetype, " +

                "nodename, parentnodeid, nodedata) VALUES (null, ?, null, ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, "COMMENT");

          pstmt.setLong(2, getElementID());

          pstmt.setString(3, data);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

        } catch (SQLException e) {

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

        }

    }

/**

 *        Name: DBDTDHandler.java

 *     Purpose: A Class that implements org.xml.sax.DTDHandler interface

 *              for resolving external entities

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

 *              National Center for Ecological Analysis and Synthesis

 *     Authors: Jivka Bojilova

 *

 *     Version: '$Id$'

 */

//package edu.ucsb.nceas.metacat;

import org.xml.sax.*;

import java.sql.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.util.Stack;

import java.util.EmptyStackException;

/** 

 * A database aware Class implementing DTDHandler interface for the SAX parser to

 * call when processing the XML stream and intercepting notations and unparsed entities

 */

public class DBDTDHandler implements DTDHandler

{

   private Connection	conn = null;

   /** Construct an instance of the DBDTDHandler clas

    *

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

    */

   public DBDTDHandler(Connection conn)

   {

      this.conn = conn;

   }

   /** Notation declarations are not signaled */

   public void notationDecl(String name, String publicId, String systemId)

            throws SAXException

   {

    System.out.println("from DBDTDHandler.notationDecl");

    System.out.println(name);

    System.out.println(publicId);

    System.out.println(systemId);

    return;

   }

   /** All are reported after startDocument and before startElement event*/

   public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName)

            throws SAXException

   {

    System.out.println("from DBDTDHandler.unparsedEntityDecl");

    System.out.print(name);

    System.out.print(publicId);

    System.out.print(systemId);

    System.out.println(notationName);

    Connection conn = DBEntityResolver.conn;

    String doctype = DBEntityResolver.doctype;

    if ( getEntitySystemID(conn, doctype, publicId) == "" ) 

        registerEntityPublicID(conn, doctype, publicId, systemId);

    return;

   }

   /** Look at db XML Catalog to get System ID (if any) for that Public ID and doctype.

     * Return empty string if there are not */

   private String getEntitySystemID (Connection conn, String doctype, String publicId)

   {

        String system_id = "";

        Statement stmt;

        try {

          stmt = conn.createStatement();

          stmt.execute("SELECT system_id FROM xml_catalog_entities " + 

                       "WHERE entity_type = 'ENTITY' AND source_doctype = '" + doctype + "' AND public_id = '" + publicId + "'");

          try {

            ResultSet rs = stmt.getResultSet();

            try {

              boolean tableHasRows = rs.next();

              if (tableHasRows) {

                try {

                  system_id = rs.getString(1);

                } catch (SQLException e) {

                  System.out.println("DBEntityResolver.getEntitySystemID() - Error with getString: " + e.getMessage());

                }

              }

            } catch (SQLException e) {

              System.out.println("DBEntityResolver.getEntitySystemID() - Error with next: " + e.getMessage());

            }

          } catch (SQLException e) {

            System.out.println("DBEntityResolver.getEntitySystemID() - Error with getrset: " + e.getMessage());

          }

          stmt.close();

        } catch (SQLException e) {

          System.out.println("DBEntityResolver.getEntitySystemID() - Error getting id: " + e.getMessage());

        }

        // return the selected System ID

        return system_id;

   }

   /** Register Public ID in db XML Catalog */

   private void registerEntityPublicID (Connection conn, String doctype, String publicId, String systemId)

   {

        try {

          conn.setAutoCommit(false);

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_catalog_entities (entity_id, entity_name, entity_type, source_doctype, public_id, system_id) " +

                "VALUES (null, null, 'ENTITY', ?, ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, doctype);

          pstmt.setString(2, publicId);

          pstmt.setString(3, systemId);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

          conn.commit();

          conn.setAutoCommit(true);

        } catch (SQLException e) {

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

        }

   }

}

//package edu.ucsb.nceas.metacat;

  static  String 	defaultDB = "jdbc:oracle:thin:@penelope.nceas.ucsb.edu:1526:DEV8";

    try {

      } catch (Exception e) {

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

     } catch (Exception e) {

       System.err.println("here is the URL exception");

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

      EntityResolver xmlEntityResolver = new DBEntityResolver(conn);

      DTDHandler xmlDTDHandler         = new DBDTDHandler(conn);

      parser.setEntityResolver(xmlEntityResolver);

      parser.setDTDHandler(xmlDTDHandler);

//package edu.ucsb.nceas.metacat;

    private Hashtable	attributes;

    private int         childNum;

    private int         nodeIndex;

     * @param nodeIndex - number of the element in the order for a given parent node

     * Every element initializes childNum to 0 when created and has interface incChildNum

     * when new child is created

    public BasicElement (String tagname, long parent_id, int nodeIndex) {

      this.nodeIndex = nodeIndex;

      this.childNum = 0;

    public BasicElement (long element_id, String tagname, long parent_id, int nodeIndex) {

      this(tagname,parent_id,nodeIndex);

    /** Get nodeIndex of the element */

    public int getNodeIndex() {

      return this.nodeIndex;

    }

    /** increase childNum when new child for the element is created */

    public int incChildNum() {

      return ++this.childNum;    

    }    

//package edu.ucsb.nceas.metacat;

    private Hashtable	attributes;

    private int         childNum;

    private int         nodeIndex;

     * @param nodeIndex - number of the element in the order for a given parent node

     * Every element initializes childNum to 0 when created and has interface incChildNum

     * when new child is created

    public BasicElement (String tagname, long parent_id, int nodeIndex) {

      this.nodeIndex = nodeIndex;

      this.childNum = 0;

    public BasicElement (long element_id, String tagname, long parent_id, int nodeIndex) {

      this(tagname,parent_id,nodeIndex);

    /** Get nodeIndex of the element */

    public int getNodeIndex() {

      return this.nodeIndex;

    }

    /** increase childNum when new child for the element is created */

    public int incChildNum() {

      return ++this.childNum;    

    }    

//package edu.ucsb.nceas.metacat;

  static  String 	defaultDB = "jdbc:oracle:thin:@penelope.nceas.ucsb.edu:1526:DEV8";

    try {

      } catch (Exception e) {

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

     } catch (Exception e) {

       System.err.println("here is the URL exception");

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

      EntityResolver xmlEntityResolver = new DBEntityResolver(conn);

      DTDHandler xmlDTDHandler         = new DBDTDHandler(conn);

      parser.setEntityResolver(xmlEntityResolver);

      parser.setDTDHandler(xmlDTDHandler);

//package edu.ucsb.nceas.metacat;

                         long parent_id, int nodeIndex) {

      super(tagname, parent_id, nodeIndex);

                "nodename, parentnodeid, nodeindex) VALUES (null, ?, ?, ?, ?)");

          //pstmt.setInt(4, null);

            pstmt.setInt(4, getNodeIndex());

    /** creates SQL code and inserts comment into DB connection */

    void writeCommentToDB(String data) {

        try {

          PreparedStatement pstmt;

          pstmt = conn.prepareStatement(

                "INSERT INTO xml_nodes (nodeid, nodetype, " +

                "nodename, parentnodeid, nodedata) VALUES (null, ?, null, ?, ?)");

          // Bind the values to the query

          pstmt.setString(1, "COMMENT");

          pstmt.setLong(2, getElementID());

          pstmt.setString(3, data);

          // Do the insertion

          pstmt.execute();

          pstmt.close();

        } catch (SQLException e) {

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

        }

    }

//package edu.ucsb.nceas.metacat;

    private Hashtable	attributes;

    private int         childNum;

    private int         nodeIndex;

     * @param nodeIndex - number of the element in the order for a given parent node

     * Every element initializes childNum to 0 when created and has interface incChildNum

     * when new child is created

    public BasicElement (String tagname, long parent_id, int nodeIndex) {

      this.nodeIndex = nodeIndex;

      this.childNum = 0;

    public BasicElement (long element_id, String tagname, long parent_id, int nodeIndex) {

      this(tagname,parent_id,nodeIndex);

    /** Get nodeIndex of the element */

    public int getNodeIndex() {

      return this.nodeIndex;

    }

    /** increase childNum when new child for the element is created */

    public int incChildNum() {

      return ++this.childNum;    

    }    

//package edu.ucsb.nceas.metacat;

  static  String 	defaultDB = "jdbc:oracle:thin:@penelope.nceas.ucsb.edu:1526:DEV8";

    try {

      } catch (Exception e) {

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

     } catch (Exception e) {

       System.err.println("here is the URL exception");

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

      EntityResolver xmlEntityResolver = new DBEntityResolver(conn);

      DTDHandler xmlDTDHandler         = new DBDTDHandler(conn);

      parser.setEntityResolver(xmlEntityResolver);

      parser.setDTDHandler(xmlDTDHandler);

//package edu.ucsb.nceas.metacat;

import oracle.xml.parser.v2.DTD;

   static int elementNo = 0;

   private String docname;

   private String doctype;

   private String systemid;

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

   public void startDocument() throws SAXException

   {