Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents an XML document

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author: bojilova $'

 *     '$Date: 2000-09-01 13:47:19 -0700 (Fri, 01 Sep 2000) $'

 * '$Revision: 428 $'

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.PrintWriter;

import java.util.TreeSet;

import java.io.*;

import java.util.Stack;

import org.xml.sax.AttributeList;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.XMLReader;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.XMLReaderFactory;

/**

 * A class that represents an XML document. It can be created with a simple

 * document identifier from a database connection.  It also will write an

 * XML text document to a database connection using SAX.

 */

public class DocumentImpl {

  static final int ALL = 1;

  static final int WRITE = 2;

  static final int READ = 4;

  private Connection conn = null;

  private String docid = null;

  private String docname = null;

  private String doctype = null;

  private String system_id = null;

  private long rootnodeid;

  private ElementNode rootNode = null;

  private String doctitle = null;

  /**

   * Constructor, creates document from database connection, used 

   * for reading the document

   *

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   */

  public DocumentImpl(Connection conn, String docid) throws McdbException 

  {

    try {

      this.conn = conn;

      this.docid = docid;

      // Look up the document information

      getDocumentInfo(docid);

      // Download all of the document nodes using a single SQL query

      TreeSet nodeRecordList = getNodeRecordList(rootnodeid);

      // Create the elements from the downloaded data in the TreeSet

      rootNode = new ElementNode(nodeRecordList, rootnodeid);

    } catch (McdbException ex) {

      throw ex;

    } catch (Throwable t) {

      throw new McdbException("Error reading document " + docid + ".");

    }

  }

  /** 

   * Construct a new document instance, writing the contents to the database.

   * This method is called from DBSAXHandler because we need to know the

   * root element name for documents without a DOCTYPE before creating it.

   *

   * @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 ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (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 or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   *

   */

  public DocumentImpl(Connection conn, long rootnodeid, String docname, 

                      String doctype, String docid, String action, String user)

                      throws AccessionNumberException 

  {

    this.conn = conn;

    this.rootnodeid = rootnodeid;

    this.docname = docname;

    this.doctype = doctype;

    this.docid = docid;

    writeDocumentToDB(action, user);

  }

  /**

   * get the document name

   */

  public String getDocname() {

    return docname;

  }

  /**

   * get the document type (which is the PublicID)

   */

  public String getDoctype() {

    return doctype;

  }

  /**

   * get the system identifier

   */

  public String getSystemID() {

    return system_id;

  }

  /**

   * get the root node identifier

   */

  public long getRootNodeID() {

    return rootnodeid;

  }

  /** 

   * Get the document identifier (docid)

   */

  public String getDocID() {

    return docid;

  }

  /**

   * Create an XML document from the database for the document with ID docid

   */

  public String toString()

  {

    StringBuffer doc = new StringBuffer();

    // Append the resulting document to the StringBuffer and return it

    doc.append("<?xml version=\"1.0\"?>\n");

    if (docname != null) {

      if ((doctype != null) && (system_id != null)) {

        doc.append("<!DOCTYPE " + docname + " PUBLIC \"" + doctype + 

                   "\" \"" + system_id + "\">\n");

      } else {

        doc.append("<!DOCTYPE " + docname + ">\n");

      }

    }

    doc.append(rootNode.toString());

    return (doc.toString());

  }

  /**

   * Look up the document type information from the database

   *

   * @param docid the id of the document to look up

   */

  private void getDocumentInfo(String docid) throws McdbException 

  {

    PreparedStatement pstmt;

    try {

      pstmt =

        conn.prepareStatement("SELECT docname,doctype,rootnodeid " +

                                "FROM xml_documents " +

                               "WHERE docid = ?");

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      if (tableHasRows) {

        this.docname    = rs.getString(1);

        this.doctype    = rs.getString(2);

        this.rootnodeid = rs.getLong(3);

      } 

      pstmt.close();

      if (this.doctype != null) {

        pstmt =

          conn.prepareStatement("SELECT system_id " +

                                  "FROM xml_catalog " +

                                 "WHERE public_id = ?");

        // Bind the values to the query

        pstmt.setString(1, doctype);

        pstmt.execute();

        rs = pstmt.getResultSet();

        tableHasRows = rs.next();

        if (tableHasRows) {

          this.system_id  = rs.getString(1);

        } 

        pstmt.close();

      }

    } catch (SQLException e) {

      throw new McdbException("Error accessing database connection.", e);

    }

    if (this.docname == null) {

      throw new McdbDocNotFoundException("Document not found: " + docid);

    }

  }

  /**

   * Look up the node data from the database

   *

   * @param rootnodeid the id of the root node of the node tree to look up

   */

  private TreeSet getNodeRecordList(long rootnodeid) throws McdbException 

  {

    PreparedStatement pstmt;

    TreeSet nodeRecordList = new TreeSet(new NodeComparator());

    long nodeid = 0;

    long parentnodeid = 0;

    long nodeindex = 0;

    String nodetype = null;

    String nodename = null;

    String nodedata = null;

    try {

      pstmt =

      conn.prepareStatement("SELECT nodeid,parentnodeid,nodeindex, " +

           "nodetype,nodename,"+               

           "replace(" +

           "replace(" +

           "replace(nodedata,'&','&') " +

           ",'<','&lt;') " +

           ",'>','>') " +

           "FROM xml_nodes WHERE rootnodeid = ?");

      // Bind the values to the query

      pstmt.setLong(1, rootnodeid);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      while (tableHasRows) {

        nodeid = rs.getLong(1);

        parentnodeid = rs.getLong(2);

        nodeindex = rs.getLong(3);

        nodetype = rs.getString(4);

        nodename = rs.getString(5);

        nodedata = rs.getString(6);

        // add the data to the node record list hashtable

        NodeRecord currentRecord = new NodeRecord(nodeid, parentnodeid, 

                                   nodeindex, nodetype, nodename, nodedata);

        nodeRecordList.add(currentRecord);

        // Advance to the next node

        tableHasRows = rs.next();

      } 

      pstmt.close();

    } catch (SQLException e) {

      throw new McdbException("Error accessing database connection.", e);

    }

    if (nodeRecordList != null) {

      return nodeRecordList;

    } else {

      throw new McdbException("Error getting node data: " + docid);

    }

  }

  /**

   * Write an XML file to the database, given a filename

   *

   * @param conn the JDBC connection to the database

   * @param filename the filename to be loaded into the database

   * @param action the action to be performed (INSERT OR UPDATE)

   * @param docid the docid to use for the INSERT OR UPDATE

   */

  public static String write( Connection conn, String filename, String action, 

                              String docid, String user, String group )

                throws IOException, SQLException, ClassNotFoundException,

                       SAXException, SAXParseException, Exception {

    return write(conn, new FileReader(new File(filename).toString()), 

                  action, docid, user, group);

  }

  /**

   * Write an XML file to the database, given a Reader

   *

   * @param conn the JDBC connection to the database

   * @param xml the xml stream to be loaded into the database

   * @param action the action to be performed (INSERT OR UPDATE)

   * @param docid the docid to use for the INSERT OR UPDATE

   */

  public static String write( Connection conn, Reader xml, String action, 

                              String docid, String user, String group )

                throws IOException, SQLException, ClassNotFoundException,

                       SAXException, SAXParseException, Exception {

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

      // Determine if the docid is OK for an UPDATE

      AccessionNumber ac = new AccessionNumber();

      String newdocid = ac.generate(docid, "UPDATE");

      // b' of the command line invocation

      if ( (user != null) &&  (group != null) ) { 

        if ( !hasWritePermission(conn, docid, user, group) ) {

          throw new Exception("User " + user + 

                " does not have permission to update XML Document #" + docid);

        }        

      }          

    }

    try {

        XMLReader parser = initializeParser(conn, action, docid, user);

        conn.setAutoCommit(false);

        parser.parse(new InputSource(xml));

        conn.commit();

        conn.setAutoCommit(true);

        return docid;

      } catch (SAXParseException e) {

        conn.rollback();

        throw e;

      } catch (SAXException e) {

        // If its a problem with the accession number its ok, just the 

        // accession number was regenerated

        AccessionNumberGeneratedException ang = null;

        try {

          Exception embedded = e.getException();

          if ((embedded != null) && 

              (embedded instanceof AccessionNumberGeneratedException)) {

            ang = (AccessionNumberGeneratedException)e.getException();

          }

        } catch (ClassCastException cce) {

          // Do nothing and just fall through to the ang != null test

        }

        if (ang != null) {

          conn.commit();

          conn.setAutoCommit(true);

          return (ang.getMessage());

        } else {

          conn.rollback();

          throw e;

        }

      } catch (Exception e) {

        conn.rollback();

        throw e;

      }

  }

  /**

   * Delete an XML file from the database (actually, just make it a revision

   * in the xml_revisions table)

   *

   * @param docid the ID of the document to be deleted from the database

   */

  public static void delete( Connection conn, String docid,

                                 String user, String group )

                throws IOException, SQLException, ClassNotFoundException, 

                       AccessionNumberException, Exception {

    AccessionNumber ac = new AccessionNumber();

    String newdocid = ac.generate(docid, "DELETE");

    if ( (user != null) &&  (group != null) ) {

      if ( !hasWritePermission(conn, docid, user, group) ) {

        throw new Exception("User " + user + 

                " does not have permission to delete XML Document #" + docid);

      }          

    }

    conn.setAutoCommit(false);

    // Copy the record to the xml_revisions table

    DocumentImpl.archiveDocRevision( conn, docid, user );

    // Now delete it from the xml_documents table

    Statement stmt = conn.createStatement();

    stmt.execute("DELETE FROM xml_index WHERE docid = '" + docid + "'");

    stmt.execute("DELETE FROM xml_documents WHERE docid = '" + docid + "'");

    stmt.close();

    conn.commit();

  }

  /** Check for "write" permissions from DB connection */

  private static boolean hasWritePermission(Connection conn, String docid, 

                                     String user, String group) 

                                     throws SQLException {

    PreparedStatement pstmt;

    // checking if user is owner of docid

    try {

      pstmt = conn.prepareStatement(

                   "SELECT docid FROM xml_documents " +

                   "WHERE docid LIKE ? AND user_owner LIKE ?");

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.setString(2, user);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean hasRow = rs.next();

      pstmt.close();

      if (hasRow) {

        return true;

      }

    } catch (SQLException e) {

      throw new 

        SQLException("Error getting document's owner: " + e.getMessage());

    }

    // checking access type from xml_access table

    int accesstype = 0;

    try {

      pstmt = conn.prepareStatement(

                   "SELECT access_type FROM xml_access " +

                   "WHERE docid LIKE ? " + 

                   "AND principal_name LIKE ? " +

                   "AND principal_type = 'user' " +

                   "AND sysdate BETWEEN begin_time AND end_time " +

                   "UNION " +

                   "SELECT access_type FROM xml_access " +

                   "WHERE docid LIKE ? " + 

                   "AND principal_name LIKE ? " +

                   "AND principal_type = 'group' " +

                   "AND sysdate BETWEEN begin_time AND end_time");

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.setString(2, user);

      pstmt.setString(3, docid);

      pstmt.setString(2, group);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean hasRows = rs.next();

      while ( hasRows ) {

        accesstype = rs.getInt(1);

        if ( (accesstype & WRITE) == WRITE ) {

          pstmt.close();

          return true;

        }

        hasRows = rs.next();

      }

      pstmt.close();

      return false;

    } catch (SQLException e) {

      throw new 

      SQLException("Error getting document's permissions: " + e.getMessage());

    }

  }

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

  private void writeDocumentToDB(String action, String user) 

               throws AccessionNumberException {

    try {

      PreparedStatement pstmt = null;

      if (action.equals("INSERT")) {

        AccessionNumber ac = new AccessionNumber();

        this.docid = ac.generate(docid, "INSERT");

        pstmt = conn.prepareStatement(

            "INSERT INTO xml_documents " +

            "(docid, rootnodeid, docname, doctype, " +

            "user_owner, user_updated, date_created, date_updated) " +

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

        // Bind the values to the query

        pstmt.setString(1, this.docid);

        pstmt.setLong(2, rootnodeid);

        pstmt.setString(3, docname);

        pstmt.setString(4, doctype);

        pstmt.setString(5, user);

        pstmt.setString(6, user);

      } else if (action.equals("UPDATE")) {

        // Save the old document entry in a backup table

        DocumentImpl.archiveDocRevision( conn, docid, user );

        // Delete index for the old version of docid

        // The new index is inserting on the next calls to DBSAXNode

        pstmt = conn.prepareStatement(

                "DELETE FROM xml_index WHERE docid='" + this.docid + "'");

        pstmt.execute();

        pstmt.close();

        // Update the new document to reflect the new node tree

        pstmt = conn.prepareStatement(

            "UPDATE xml_documents " +

            "SET rootnodeid = ?, docname = ?, doctype = ?, " +

            "user_updated = ?, date_updated = sysdate WHERE docid LIKE ?");

        // Bind the values to the query

        pstmt.setLong(1, rootnodeid);

        pstmt.setString(2, docname);

        pstmt.setString(3, doctype);

        pstmt.setString(4, user);

        pstmt.setString(5, this.docid);

      } else {

        System.err.println("Action not supported: " + action);

      }

      // Do the insertion

      pstmt.execute();

      pstmt.close();

    } catch (SQLException e) {

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

    } catch (AccessionNumberException ane) {

      MetaCatUtil.debugMessage("Invalid accession number.");

      MetaCatUtil.debugMessage(ane.getMessage());

      throw ane;

    } catch (Exception e) {

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

    }

  }

  /**

   * Get the document title

   */

  public String getTitle() {

    return doctitle;

  }

  /**

   * Set the document title

   *

   * @param title the new title for the document

   */

  public void setTitle( String title ) {

    this.doctitle = title;

    try {

      PreparedStatement pstmt;

      pstmt = conn.prepareStatement(

            "UPDATE xml_documents " +

            " SET doctitle = ? " +

            "WHERE docid = ?");

      // Bind the values to the query

      pstmt.setString(1, doctitle);

      pstmt.setString(2, docid);

      // Do the insertion

      pstmt.execute();

      pstmt.close();

    } catch (SQLException e) {

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

    }

  }

  /**

   * Look up the title of the first child element named "title"

   * and record it as the document title

   */

  public void setTitleFromChildElement() {

    String title = null;

    long assigned_id=0;

    PreparedStatement pstmt;

    try {

      pstmt = conn.prepareStatement(

              "SELECT nodedata FROM xml_nodes " +

              "WHERE nodetype = 'TEXT' " +

              "AND rootnodeid = ? " +

              "AND parentnodeid IN " +

              "  (SELECT nodeid FROM xml_nodes " +

              "  WHERE nodename = 'title' " +

              "  AND nodetype =  'ELEMENT' " +

              "  AND rootnodeid = ? ) " +

              "ORDER BY nodeid");

      // The above query might be slow, and probably will be because

      // it gets ALL of the title elements while searching for one

      // title in a small subtree but it avoids the problem of using

      // Oracle's Hierarchical Query syntax which is not portable --

      // the commented out SQL that follows shows an equivalent query

      // using Oracle-specific hierarchical query

      /*

      pstmt = conn.prepareStatement(

              "SELECT nodedata FROM xml_nodes " +

              "WHERE nodetype = 'TEXT' " +

              "AND parentnodeid IN " +

              "(SELECT nodeid FROM xml_nodes " +

              "WHERE nodename = 'title' " +

              "START WITH nodeid = ? " +

              "CONNECT BY PRIOR nodeid = parentnodeid)");

      */

      // Bind the values to the query

      pstmt.setLong(1, rootnodeid);

      pstmt.setLong(2, rootnodeid);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      if (tableHasRows) {

        title = rs.getString(1);

      }

      pstmt.close();

    } catch (SQLException e) {

      System.out.println("Error getting title: " + e.getMessage());

    }

    // assign the new title

    this.setTitle(title);

  }

  /** Save a document entry in the xml_revisions table */

  private static void archiveDocRevision(Connection conn, String docid,

                                         String user) throws SQLException {

    // create a record in xml_revisions table 

    // for that document as selected from xml_documents

    PreparedStatement pstmt = conn.prepareStatement(

      "INSERT INTO xml_revisions " +

        "(revisionid, docid, rootnodeid, docname, doctype, doctitle, " +

        "user_owner, user_updated, date_created, date_updated) " +

      "SELECT null, ?, rootnodeid, docname, doctype, doctitle," + 

        "user_owner, ?, sysdate, sysdate "+

      "FROM xml_documents " +

      "WHERE docid = ?");

    // Bind the values to the query and execute it

    pstmt.setString(1, docid);

    pstmt.setString(2, user);

    pstmt.setString(3, docid);

    pstmt.execute();

    pstmt.close();

  }

  /** Save a document entry in the xml_revisions table */

/*

  private static void archiveDocRevision(Connection conn, String docid,

                                         String user) throws SQLException {

    // First get all of the values we need

    long rnodeid = -1;

    String docname = null;

    String doctype = null;

    String doctitle = null;

    String user_owner = null;

    Date date_created = null;

    PreparedStatement pstmt = conn.prepareStatement(

      "SELECT rootnodeid,docname,doctype,doctitle,user_owner,date_created " +

      "FROM xml_documents " +

      "WHERE docid = ?");

    // Bind the values to the query and execute it

    pstmt.setString(1, docid);

    pstmt.execute();

    ResultSet rs = pstmt.getResultSet();

    boolean tableHasRows = rs.next();

    if (tableHasRows) {

      rnodeid      = rs.getLong(1);

      docname      = rs.getString(2);

      doctype      = rs.getString(3);

      doctitle     = rs.getString(4);

      user_owner   = rs.getString(5);

      date_created = rs.getDate(6);

    }

    pstmt.close();

    MetaCatUtil.debugMessage(new Long(rnodeid).toString());

    MetaCatUtil.debugMessage(docname);

    MetaCatUtil.debugMessage(doctitle);

    //MetaCatUtil.debugMessage(date_created.toString());

    // Next create the new record in the other table using the values selected

    pstmt = conn.prepareStatement(

       "INSERT INTO xml_revisions " +

       "(revisionid, docid, rootnodeid, docname, doctype, doctitle, " +

       "user_owner, user_updated, date_created, date_updated) " +

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

    // Bind the values to the query and execute it

    pstmt.setString(1, docid);

    pstmt.setLong(2, rnodeid);

    pstmt.setString(3, docname);

    pstmt.setString(4, doctype);

    pstmt.setString(5, doctitle);

    pstmt.setString(6, user_owner);

    pstmt.setString(7, user);

    //pstmt.setDate(6, date_created);

    pstmt.execute();

    pstmt.close();

  }

*/

  /**

   * Set up the parser handlers for writing the document to the database

   */

  private static XMLReader initializeParser(Connection conn,

                           String action, String docid, String user) {

    XMLReader parser = null;

    //

    // Set up the SAX document handlers for parsing

    //

    try {

      ContentHandler chandler   = new DBSAXHandler(conn, action, docid, user);

      EntityResolver dbresolver = new DBEntityResolver(conn, 

                                      (DBSAXHandler)chandler);

      DTDHandler dtdhandler     = new DBDTDHandler(conn);

      // Get an instance of the parser

      MetaCatUtil util = new MetaCatUtil();

      String parserName = util.getOption("saxparser");

      parser = XMLReaderFactory.createXMLReader(parserName);

      // Turn off validation

      parser.setFeature("http://xml.org/sax/features/validation", false);

      // Set Handlers in the parser

      parser.setProperty("http://xml.org/sax/properties/declaration-handler",

                         chandler);

      parser.setProperty("http://xml.org/sax/properties/lexical-handler",

                         chandler);

      parser.setContentHandler((ContentHandler)chandler);

      parser.setEntityResolver((EntityResolver)dbresolver);

      parser.setDTDHandler((DTDHandler)dtdhandler);

      parser.setErrorHandler((ErrorHandler)chandler);

    } catch (Exception e) {

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

    }

    return parser;

  }

  /**

   * the main routine used to test the DBWriter utility.

   * <p>

   * Usage: java DocumentImpl <-f filename -a action -d docid>

   *

   * @param filename the filename to be loaded into the database

   * @param action the action to perform (READ, INSERT, UPDATE, DELETE)

   * @param docid the id of the document to process

   */

  static public void main(String[] args) {

    try {

      String filename = null;

      String action   = null;

      String docid    = null;

      // Parse the command line arguments

      for ( int i=0 ; i < args.length; ++i ) {

        if ( args[i].equals( "-f" ) ) {

          filename =  args[++i];

        } else if ( args[i].equals( "-a" ) ) {

          action =  args[++i];

        } else if ( args[i].equals( "-d" ) ) {

          docid =  args[++i];

        } else {

          System.err.println

            ( "   args[" +i+ "] '" +args[i]+ "' ignored." );

        }

      }

      // Check if the required arguments are provided

      boolean argsAreValid = false;

      if (action != null) {

        if (action.equals("INSERT")) {

          if (filename != null) {

            argsAreValid = true;

          } 

        } else if (action.equals("UPDATE")) {

          if ((filename != null) && (docid != null)) {

            argsAreValid = true;

          } 

        } else if (action.equals("DELETE")) {

          if (docid != null) {

            argsAreValid = true;

          } 

        } else if (action.equals("READ")) {

          if (docid != null) {

            argsAreValid = true;

          } 

        } 

      } 

      // Print usage message if the arguments are not valid

      if (!argsAreValid) {

        System.err.println("Wrong number of arguments!!!");

        System.err.println(

              "USAGE: java DocumentImpl <-a INSERT> [-d docid] <-f filename>");

        System.err.println(

              "   OR: java DocumentImpl <-a UPDATE -d docid -f filename>");

        System.err.println(

              "   OR: java DocumentImpl <-a DELETE -d docid>");

        System.err.println(

              "   OR: java DocumentImpl <-a READ -d docid>");

        return;

      }

      // Open a connection to the database

      MetaCatUtil util = new MetaCatUtil();

      Connection dbconn = util.openDBConnection();

      // Execute the action requested (READ, INSERT, UPDATE, DELETE)

      if (action.equals("READ")) {

          DocumentImpl xmldoc = new DocumentImpl( dbconn, docid );

          System.out.println(xmldoc.toString());

      } else if (action.equals("DELETE")) {

        DocumentImpl.delete(dbconn, docid, null, null);

        System.out.println("Document deleted: " + docid);

      } else {

        String newdocid = DocumentImpl.write(dbconn, filename, action, docid,

                                                                  null, null);

        if ((docid != null) && (!docid.equals(newdocid))) {

          if (action.equals("INSERT")) {

            System.out.println("New document ID generated!!! ");

          } else if (action.equals("UPDATE")) {

            System.out.println("ERROR: Couldn't update document!!! ");

          }

        } else if ((docid == null) && (action.equals("UPDATE"))) {

          System.out.println("ERROR: Couldn't update document!!! ");

        }

        System.out.println("Document processing finished for: " + filename

              + " (" + newdocid + ")");

      }

    } catch (McdbException me) {

      me.toXml(new PrintWriter(System.err));

    } catch (AccessionNumberException ane) {

      System.out.println("ERROR: Couldn't delete document!!! ");

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

    } catch (Exception e) {

      System.err.println("EXCEPTION HANDLING REQUIRED");

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

      e.printStackTrace(System.err);

    }

  }

}