Metacat

/**

 *  '$RCSfile$'

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *

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

import org.apache.log4j.Logger;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.DefaultHandler;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

import org.xml.sax.ContentHandler;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

/**

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

 * for printing to the servlet output stream.

 */

public class MetacatResultSet extends DefaultHandler

{    

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

  private Vector results = new Vector();

  private Result currentResult = null;

  private String currentElementName = "";

  Attributes atts = null;

  /**

   * constructor that can process a dom.  WARNING: 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);

    }

  }

  /**

   * process a resultset using SAX

   */

  public MetacatResultSet(String xmlDoc)

    throws SAXException, IOException

  {

    double mrsStart = System.currentTimeMillis() / 1000;

    log.warn("###############parsing for paged results.....");

    XMLReader parser = null;

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

    parser = XMLReaderFactory.createXMLReader(parserName);

    parser.setContentHandler(this);

    parser.setErrorHandler(this);

    parser.parse(new InputSource(new StringReader(xmlDoc)));

    double mrsStop = System.currentTimeMillis() / 1000;

    log.warn("##############done parsing for paged results.  total time: " + 

      (mrsStop - mrsStart) + " seconds");

  }

  /**

   * process the beginning of an element

   */

  public void startElement(String uri, String localName, String qName, 

    Attributes atts) throws SAXException

  {

    //get the attributes

    this.atts = atts;

    if(localName.equals("document"))

    {

      currentResult = new Result();

    }

    else if(localName.equals("docid") ||

            localName.equals("docname") ||

            localName.equals("doctype") ||

            localName.equals("createdate") ||

            localName.equals("updatedate") ||

            localName.equals("param"))

    { //set the current element name

      currentElementName = localName;

    }

  }

  /**

   * process the end of an element

   */

  public void endElement(String uri, String localName, String qName)

    throws SAXException

  {

    if(localName.equals("document"))

    { //if we're closing a document, save the result

      addResult(new Result(currentResult));

      currentResult = new Result();

      currentElementName = "";

    }

  }

  /**

   * process character data

   */

  public void characters(char[] cbuf, int start, int len) 

    throws SAXException

  { //get the character data for each node we care about

    String s = new String(cbuf, start, len);

    if(currentElementName.equals("docid"))

    {

      currentResult.docid = s;

    }

    else if(currentElementName.equals("docname"))

    {

      currentResult.docname = s;

    }

    else if(currentElementName.equals("doctype"))

    {

      currentResult.doctype = s;

    }

    else if(currentElementName.equals("createdate"))

    {

      currentResult.createDate = s;

    }

    else if(currentElementName.equals("updatedate"))

    {

      currentResult.updateDate = s;

    }

    else if(currentElementName.equals("param"))

    { //add the returnfields to the hashtable

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

      {

        String attributeName = atts.getQName(i);

        String attributeValue = null;

        if(attributeName.equals("name"))

        {

          attributeValue = atts.getValue(i);

        }

        currentResult.returnfields.put(attributeValue, s);

      }

    }

  }

  /**

   * SAX Handler that receives notification of fatal parsing errors

   */

  public void fatalError(SAXParseException exception) throws SAXException

  {

      log.fatal("FATALERROR while parsing/caching resultset: " + 

        exception.getMessage());

      throw (new SAXException("Fatal error processing/caching resultset.", 

        exception));

  }

  /**

   * SAX Handler that receives notification of recoverable parsing errors

   */

  public void error(SAXParseException exception) throws SAXException

  {

      log.error("ERROR while parsing/caching resultset: " + 

        exception.getMessage());

      throw (new SAXException("Error in processing/caching resultset.", 

        exception));

  }

  /**

   * SAX Handler that receives notification of warnings

   */

  public void warning(SAXParseException exception) throws SAXException

  {

      log.warn("WARNING while parsing/caching resultset: " + 

        exception.getMessage());

      throw (new SAXException("Warning.", exception));

  }

  /**

   * 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

  {

    protected String docid;

    protected String docname;

    protected String doctype;

    protected String createDate;

    protected String updateDate;

    protected Hashtable returnfields;

    /**

     * copy constructor

     */

    public Result(Result r)

    {

      if(r != null)

      {

        docid = r.docid;

        docname = r.docname;

        doctype = r.doctype;

        createDate = r.createDate;

        updateDate = r.updateDate;

        returnfields = r.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;

    }

    /**

     * default constructor

     */

    public Result()

    {

      returnfields = new Hashtable();

    }

    /**

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

    }

  }

}

        logMetacat.warn("accessquery is: " + accessQuery);

            logMetacat.warn("Attribute query: " + self.toString());

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.io.StringReader;

import java.io.StringWriter;

import java.io.OutputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.StringTokenizer;

import java.util.Vector;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

      logMetacat.warn("SESSIONID: " + sessionid);

      logMetacat.warn("xmlquery: " + xmlquery);

      logMetacat.warn("qformat: " + qformat);

  /**

   * 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));

  }

    if(cachedQuerySpec != null && 

    }

    try

    }

      Hashtable docListResult = new Hashtable();

        logMetacat.warn("\n\n\n final query: " + query);

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

      //if they are not 0

      boolean tableHasRows = rs.next();

         if (returndocVec.size() != 0 && !returndocVec.contains(doctype)

                        && !qspec.isPercentageSearch())

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

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

        if (count == offset)

        {

          handleSubsetResult(qspec,resultsetBuffer, out, docListResult,

          // reset docListResult

          docListResult = new Hashtable();

     if (!docListResult.isEmpty())

                                           PrintWriter out, Hashtable partOfDoclist,

         partOfDoclist.remove(_keys.nextElement());

     _keys = partOfDoclist.keys();

     while (_keys.hasMoreElements()){

       Object key = _keys.nextElement();

                                        dbconn, useXMLIndex );

     Enumeration keys = partOfDoclist.keys();

     while (keys.hasMoreElements())

         key = (String) keys.nextElement();

     keys = queryresultDocList.keys();

     while (keys.hasMoreElements())

         key = (String) keys.nextElement();

                                              Hashtable partOfDoclist,

         Enumeration keylist = partOfDoclist.keys();

         while (keylist.hasMoreElements())

             doclist.append((String) keylist.nextElement());

    private Hashtable addReturnfield(Hashtable docListResult,

        Enumeration keylist = docListResult.keys();

        while (keylist.hasMoreElements())

          doclist.append((String) keylist.nextElement());

           logMetacat.warn("Extended query: " + extendedQuery);

                   if (docListResult.containsKey(docid)) {

                           put(docid,

                               removedelement + object.getXMLFieldValue());

                       docListResult.put(docid, object.getXMLFieldValue());

   private Hashtable addRelationship(Hashtable docListResult,

    Enumeration docidkeys = docListResult.keys();

    while (docidkeys.hasMoreElements())

      String docidkey = (String) docidkeys.nextElement();

    private Hashtable getAttributeValueForReturn(QuerySpecification squery,

            Hashtable docInformationList, String docList, boolean useXMLIndex)

                    if (docInformationList.containsKey(docid)) {