Metacat

import java.io.FileOutputStream;

import java.io.OutputStream;

import org.w3c.dom.*;

import javax.xml.parsers.DocumentBuilderFactory;

import org.xml.sax.InputSource;

import org.w3c.dom.ls.*;

         // if the user is a moderator, then pass a param to the 

  }

  /**

   * this method parses the xml results in the string buffer and returns

   * just those required by the paging params.

   */

  private StringBuffer getPagedResult(MetacatResultSet mrs, int pagestart, 

    int pagesize)

  {

    logMetacat.warn(mrs.toString());

    if(pagesize == 0)

    { //if pagesize is 0 then we return the whole resultset

      return new StringBuffer(mrs.toString());

    return new StringBuffer(mrs.serializeToXML(pagestart, pagestart + pagesize));

  }

    //try to get the cached version first    

    Hashtable sessionHash = MetaCatServlet.getSessionHash();

    HttpSession sess = (HttpSession)sessionHash.get(sessionid);

    QuerySpecification cachedQuerySpec = (QuerySpecification)sess.getAttribute("query");

    if(cachedQuerySpec != null && 

       cachedQuerySpec.printSQL(false).equals(qspec.printSQL(false)))

    { //use the cached resultset if the query was the same as the last

      MetacatResultSet mrs = (MetacatResultSet)sess.getAttribute("results");

      logMetacat.info("Using cached query results");

      //if the query is the same and the session contains the query

      //results, return those instead of rerunning the query

      if(mrs != null)

      { //print and return the cached buffer

        StringBuffer pagedResultBuffer = getPagedResult(mrs, pagestart, 

          pagesize);

        if(out != null)

        {

          out.println("<?xml version=\"1.0\"?>\n");

          out.println("<resultset>\n");

          out.println("  <query>" + xmlquery + "</query>\n");

          out.println(pagedResultBuffer.toString());

          out.println("\n</resultset>\n");

        }

        String returnString = "<?xml version=\"1.0\"?>\n";

        returnString += "<resultset>\n";

        returnString += "  <query>" + xmlquery + "</query>\n";

        returnString += pagedResultBuffer.toString();

        returnString += "\n</resultset>\n";

        return new StringBuffer(returnString);

      }

    }

    //no cached results...go on with a normal query

    //send out a new query

        ee.printStackTrace();

    //create a DOM to cache

    try

    {

      //cache the query result and the query

      logMetacat.info("Caching query and resultset");

      sess.setAttribute("query", qspec);

      MetacatResultSet mrs = processAndCacheResults(resultset.toString(), sess);

      sess.setAttribute("results", mrs);

      StringBuffer pagedResultBuffer = getPagedResult(mrs, pagestart, pagesize);

      String returnString = "<?xml version=\"1.0\"?>\n";

      returnString += "<resultset>\n";

      returnString += "  <query>" + xmlquery + "</query>\n";

      returnString += pagedResultBuffer.toString();

      returnString += "\n</resultset>\n";

      return new StringBuffer(returnString);

    }

    catch(Exception e)

    {

      logMetacat.error("################Could not parse resultset: " + e.getMessage());

    }

  /**

   * parse the dom of the resultset into a MetacatResultSet object so it can

   * be cached in a reasonable way

   */

  private MetacatResultSet processAndCacheResults(String resultset, HttpSession sess)

    throws Exception

  {

    StringReader sreader = new StringReader(resultset.toString());

    InputSource inputsource = new InputSource(sreader);

    logMetacat.warn("processing DOM");

    Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputsource);

    //got the dom, now process it into an MRS

    MetacatResultSet mrs = new MetacatResultSet(doc);

    return mrs;

  }

      String query = null;

      int count = 0;

      int index = 0;

      Hashtable docListResult = new Hashtable();

      PreparedStatement pstmt = null;

      String docid = null;

      String docname = null;

      String doctype = null;

      String createDate = null;

      String updateDate = null;

      StringBuffer document = null;

      int rev = 0;

      double startTime = 0;

      int offset = 1;

      ResultSet rs = null;

      offset = 1;

      startTime = System.currentTimeMillis() / 1000;

      rs = pstmt.executeQuery();

      //now we need to process the resultset based on pagesize and pagestart

      //if they are not 0

      logMetacat.warn("Time to execute query: "

         {

           }

           if (doctype != null)

           {

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

           }

           if (createDate != null)

           {

               document.append("<createdate>" + createDate + "</createdate>");

           }

           if (updateDate != null)

           {

             document.append("<updatedate>" + updateDate + "</updatedate>");

           }

           // Store the document id and the root node id

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

           count++;

/**

 *  '$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$'

 *     '$Date$'

 * '$Revision$'

 *

 * 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.io.*;

import java.util.*;

import org.w3c.dom.*;

import org.apache.xpath.*;

import org.apache.log4j.Logger;

/**

 * this class implements a metacat resultset and can be serialized to xml

 * for printing to the servlet output stream.

 */

public class MetacatResultSet

{

  private Logger log = Logger.getLogger(MetacatResultSet.class);

  private Vector results = new Vector();

  /**

   * default constructor

   */

  public MetacatResultSet()

  {

  }

  /**

   * constructor that can process a dom.  this is very slow.

   */

  public MetacatResultSet(Document d)

    throws Exception

  {

    log.warn("processing resultset...");

    NodeList nl = XPathAPI.selectNodeList(d, "//document");

    for(int i=0; i<nl.getLength(); i++)

    { //get each of the document nodes

      Node docNode = nl.item(i);

      Node docidNode = XPathAPI.selectSingleNode(docNode, "./docid");

      log.warn("processing " + docidNode.getFirstChild().getNodeValue());

      Node docnameNode = XPathAPI.selectSingleNode(docNode, "./docname");

      Node doctypeNode = XPathAPI.selectSingleNode(docNode, "./doctype");

      Node createdateNode = XPathAPI.selectSingleNode(docNode, "./createdate");

      Node updatedateNode = XPathAPI.selectSingleNode(docNode, "./updatedate");

      //process the returnfields

      NodeList returnfieldNL = XPathAPI.selectNodeList(docNode, "./param");

      Hashtable returnfieldHash = new Hashtable();

      for(int j=0; j<returnfieldNL.getLength(); j++)

      {

        Node returnfieldNode = returnfieldNL.item(j);

        Node nameNode = XPathAPI.selectSingleNode(returnfieldNode, "@name");

        String value = returnfieldNode.getFirstChild().getNodeValue();

        String name = nameNode.getNodeValue();

        returnfieldHash.put(name, value);

      }

      Result r = new Result(docidNode.getFirstChild().getNodeValue(),

                            docnameNode.getFirstChild().getNodeValue(),

                            doctypeNode.getFirstChild().getNodeValue(),

                            createdateNode.getFirstChild().getNodeValue(),

                            updatedateNode.getFirstChild().getNodeValue(),

                            returnfieldHash);

      addResult(r);

    }

  }

  /**

   * add a new result to the resultSet

   */

  public void addResult(Result r)

  {

    results.addElement(r);

  }

  /**

   * returns a vector of the results

   */

  public Vector getResults()

  {

    return results;

  }

  /**

   * serialize a selection of the results.  This will print the results from

   * start to end-1.  if end is 0, nothing will be printed.

   */

  public String serializeToXML(int start, int end)

  {

    StringBuffer sb = new StringBuffer();

    if(start > results.size() || end > results.size())

    { //make sure we don't go over the edge of the vector

      start = results.size() - 10;

      end = results.size();

    }

    for(int i=start; i<end; i++)

    {

      Result r = (Result)results.elementAt(i);

      sb.append(r.toString());

      sb.append("\n");

    }

    return sb.toString();

  }

  /**

   * returns an xml representation of this object

   */

  public String toString()

  {

    StringBuffer sb = new StringBuffer();

    for(int i=0; i<results.size(); i++)

    {

      Result r = (Result)results.elementAt(i);

      sb.append(r.toString());

      sb.append("\n");

    }

    return sb.toString();

  }

  /**

   * a class to store one result

   */

  public class Result

  {

    private String docid;

    private String docname;

    private String doctype;

    private String createDate;

    private String updateDate;

    private Hashtable returnfields;

    /**

     * constructor

     */

    public Result(String docid, String docname, String doctype, 

      String createDate, String updateDate, Hashtable returnfields)

    {

      this.docid = docid;

      this.doctype = doctype;

      this.createDate = createDate;

      this.updateDate = updateDate;

      this.returnfields = returnfields;

    }

    /**

     * returns serialized version of this result

     */

    public String toString()

    {

      StringBuffer sb = new StringBuffer();

      sb.append("<document>\n");

      sb.append("  <docid>" + docid + "</docid>\n");

      sb.append("  <docname>" + docname + "</docname>\n");

      sb.append("  <doctype>" + doctype + "</doctype>\n");

      sb.append("  <createdate>" + createDate + "</createdate>\n");

      sb.append("  <updatedate>" + updateDate + "</updatedate>\n");

      Enumeration keys = returnfields.keys();

      while(keys.hasMoreElements())

      {

        String key = (String)keys.nextElement();

        String value = (String)returnfields.get(key);

        sb.append("  <param name=\"" + key + "\">" + value + "</param>\n");

      }

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

      return sb.toString();

    }

  }

}