Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that searches a relational DB for elements and 

 *             attributes that have free text matches a query string,

 *             or structured query matches to a path specified node in the 

 *             XML hierarchy.  It returns a result set consisting of the 

 *             document ID for each document that satisfies the query

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author: berkley $'

 *     '$Date: 2000-08-11 11:26:07 -0700 (Fri, 11 Aug 2000) $'

 * '$Revision: 342 $'

 */

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.*;

import java.util.Stack;

import java.util.Hashtable;

import java.util.Enumeration;

/** 

 * A Class that searches a relational DB for elements and 

 * attributes that have free text matches a query string,

 * or structured query matches to a path specified node in the 

 * XML hierarchy.  It returns a result set consisting of the 

 * document ID for each document that satisfies the query

 */

public class DBQuery {

  private Connection	conn = null;

  private String	parserName = null;

  /**

   * the main routine used to test the DBQuery utility.

   * <p>

   * Usage: java DBQuery <xmlfile>

   *

   * @param xmlfile the filename of the xml file containing the query

   */

  static public void main(String[] args) {

     if (args.length < 1)

     {

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

        System.err.println("USAGE: java DBQuery <xmlfile>");

        return;

     } else {

        try {

          String xmlfile  = args[0];

          // Open a connection to the database

          MetaCatUtil   util = new MetaCatUtil();

          Connection dbconn = util.openDBConnection();

          // Execute the query

          DBQuery queryobj = new DBQuery(dbconn, util.getOption("saxparser"));

          FileReader xml = new FileReader(new File(xmlfile));

          Hashtable nodelist = null;

          nodelist = queryobj.findDocuments(xml);

          // Print the reulting document listing

          StringBuffer result = new StringBuffer();

          String document = null;

          String docid = null;

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

          result.append("<resultset>\n"); 

  // following line removed by Dan Higgins to avoid insertion of query XML inside returned XML doc

  //        result.append("  <query>" + xmlfile + "</query>\n");

          Enumeration doclist = nodelist.keys(); 

          while (doclist.hasMoreElements()) {

            docid = (String)doclist.nextElement();

            document = (String)nodelist.get(docid);

            result.append("  <document>\n    " + document + 

                          "\n  </document>\n");

          }

          result.append("</resultset>\n");

          System.out.println(result);

        } catch (Exception e) {

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

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

          e.printStackTrace(System.err);

        }

     }

  }

  /**

   * construct an instance of the DBQuery class 

   *

   * <p>Generally, one would call the findDocuments() routine after creating 

   * an instance to specify the search query</p>

   *

   * @param conn the JDBC connection that we use for the query

   * @param parserName the fully qualified name of a Java class implementing

   *                   the org.xml.sax.XMLReader interface

   */

  public DBQuery( Connection conn, String parserName ) 

                  throws IOException, 

                         SQLException, 

                         ClassNotFoundException {

    this.conn = conn;

    this.parserName = parserName;

  }

  /** 

   * routine to search the elements and attributes looking to match query

   *

   * @param xmlquery the xml serialization of the query (@see pathquery.dtd)

   */

  public Hashtable findDocuments(Reader xmlquery) {

      Hashtable	 docListResult = new Hashtable();

      PreparedStatement pstmt;

      String docid = null;

      String docname = null;

      String doctype = null;

      String doctitle = null;

      StringBuffer document = null; 

      try {

        // Get the XML query and covert it into a SQL statment

        QuerySpecification qspec = new QuerySpecification(xmlquery, 

                                   parserName);

        //System.out.println(qspec.printSQL());

        pstmt = conn.prepareStatement( qspec.printSQL() );

        // Execute the SQL query using the JDBC connection

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean tableHasRows = rs.next();

        while (tableHasRows) {

          docid = rs.getString(1);

          docname = rs.getString(2);

          doctype = rs.getString(3);

          doctitle = rs.getString(4);

          document = new StringBuffer();

          document.append("<docid>").append(docid).append("</docid>");

          if (docname != null) {

            document.append("<docname>" + docname + "</docname>");

          }

          if (doctype != null) {

            document.append("<doctype>" + doctype + "</doctype>");

          }

          if (doctitle != null) {

            document.append("<doctitle>" + doctitle + "</doctitle>");

          }

          // Store the document id and the root node id

          docListResult.put(docid,(String)document.toString());

          // Advance to the next record in the cursor

          tableHasRows = rs.next();

        }

        pstmt.close();

      } catch (SQLException e) {

        System.err.println("Error getting id: " + e.getMessage());

      } catch (IOException ioe) {

        System.err.println("Error printing qspec:");

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

      }

    return docListResult;

  }

  /**

   * format a structured query as an XML document that conforms

   * to the pathquery.dtd and is appropriate for submission to the DBQuery

   * structured query engine

   *

   * @param params The list of parameters that  should be included in the query

   * @param doctype the type of documents to include in the result set -- use

   *        "any" or "ANY" for unfiltered result sets

   */

  public static String createSQuery(Hashtable params, String doctype)

  {

    StringBuffer query=null;

    Enumeration elements;

    Enumeration keys;

    Object nextkey;

    Object nextelement;

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

    query.append("<pathquery version=\"1.0\"><meta_file_id>");

    if(params.containsKey("meta_file_id"))

    {

      query.append( ((String[])params.get("meta_file_id"))[0]);

    	query.append("</meta_file_id>");

    }

    else

    {

      query.append("unspecified</meta_file_id>");

    }

    query.append("<querytitle>");

    if(params.containsKey("querytitle"))

    {

      query.append(((String[])params.get("querytitle"))[0]);

    	query.append("</querytitle>");

    }

    else

    {

    	query.append("unspecified</querytitle>");

    }

    if (!doctype.equals("any") && 

        !doctype.equals("ANY") &&

        !doctype.equals("") ) 

    {

       query.append("<returndoctype>");

       query.append(doctype).append("</returndoctype>");

    }

    query.append("<querygroup operator=\"" + 

    		        ((String[])params.get("operator"))[0] + "\">");

    //anyfield is a special case because it does a 

    //free text search.  It does not have a <pathexpr>

    //tag.

    if(params.containsKey("anyfield") && 

    	 !((String[])params.get("anyfield"))[0].equals(""))

    {

    	query.append("<queryterm casesensitive=\"false\" " +

    			         "searchmode=\"contains\"><value>" +

    			         ((String[])params.get("anyfield"))[0] +

    			         "</value></queryterm>");

    }

    //this while loop finds the rest of the parameters

    //and attempts to query for the field specified

    //by the parameter.

    elements = params.elements();

    keys = params.keys();

    while(keys.hasMoreElements() && elements.hasMoreElements())

    {

      nextkey = keys.nextElement();

    	nextelement = elements.nextElement();

    	//make sure we aren't querying for any of these

    	//parameters since the are already in the query

      //in one form or another.

    	if(!nextkey.toString().equals("doctype") && 

    		 !nextkey.toString().equals("action")  &&

    		 !nextkey.toString().equals("qformat") && 

    		 !nextkey.toString().equals("anyfield") &&

    		 !nextkey.toString().equals("operator") &&

    		 !(((String[])nextelement)[0].equals("")) )

    	{

        query.append("<queryterm casesensitive=\"false\" " + 

    				         "searchmode=\"contains\">" +

    		             "<value>" +

        //add the query value

    		             ((String[])nextelement)[0] +

    		             "</value><pathexpr>" +

    		//add the path to query by 

                     nextkey.toString() + 

                     "</pathexpr></queryterm>");

    	}

    }

    query.append("</querygroup></pathquery>");

    return query.toString();

  }

  /**

   * format a simple free-text value query as an XML document that conforms

   * to the pathquery.dtd and is appropriate for submission to the DBQuery

   * structured query engine

   *

   * @param value the text string to search for in the xml catalog

   * @param doctype the type of documents to include in the result set -- use

   *        "any" or "ANY" for unfiltered result sets

   */

   public static String createQuery(String value, String doctype) {

     StringBuffer xmlquery = new StringBuffer();

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

     xmlquery.append("<pathquery version=\"1.0\">");

     xmlquery.append("<meta_file_id>Unspecified</meta_file_id>");

     xmlquery.append("<querytitle>Unspecified</querytitle>");

     if (!doctype.equals("any") && !doctype.equals("ANY")) {

       xmlquery.append("<returndoctype>");

       xmlquery.append(doctype).append("</returndoctype>");

     }

     xmlquery.append("<querygroup operator=\"UNION\">");

     xmlquery.append("<queryterm casesensitive=\"false\" ");

     xmlquery.append("searchmode=\"contains\">");

     xmlquery.append("<value>").append(value).append("</value>");

     xmlquery.append("</queryterm>");

     xmlquery.append("</querygroup>");

     xmlquery.append("</pathquery>");

     return (xmlquery.toString());

   }

  /**

   * format a simple free-text value query as an XML document that conforms

   * to the pathquery.dtd and is appropriate for submission to the DBQuery

   * structured query engine

   *

   * @param value the text string to search for in the xml catalog

   */

   public static String createQuery(String value) {

     return createQuery(value, "any");

   }

}

/**

 * '$Log$

 * 'Revision 1.10  2000/07/26 20:40:41  higgins

 * 'no message

 * '

 * 'Revision 1.9  2000/06/26 10:35:04  jones

 * 'Merged in substantial changes to DBWriter and associated classes and to

 * 'the MetaCatServlet in order to accomodate the new UPDATE and DELETE

 * 'functions.  The command line tools and the parameters for the

 * 'servlet have changed substantially.

 * '

 * 'Revision 1.8.2.2  2000/06/25 23:38:16  jones

 * 'Added RCSfile keyword

 * '

 * 'Revision 1.8.2.1  2000/06/25 23:34:17  jones

 * 'Changed documentation formatting, added log entries at bottom of source files

 * ''

 */