/src/edu/ucsb/nceas/metacat/DBQuery.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/DBQuery.java @ 6129

-            jones
+/**
-            jones
+ *  '$RCSfile$'
-            sgarg
+ *    Purpose: A Class that searches a relational DB for elements and
-            jones
+ *             attributes that have free text matches a query string,
-            sgarg
+ *             or structured query matches to a path specified node in the
  *             XML hierarchy.  It returns a result set consisting of the
-            jones
+ *             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
             jones
-            jones
+ *   '$Author$'
  *     '$Date$'
  * '$Revision$'
             jones
  * 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
-            jones
+ */
-            bojilova
+package edu.ucsb.nceas.metacat;
             jones
-            leinfelder
+import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.io.Writer;
-            jones
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-            leinfelder
+import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.StringTokenizer;
 import java.util.Vector;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
             jones
-            tao
+import javax.servlet.ServletOutputStream;
-            tao
+import javax.servlet.http.HttpServletResponse;
             jones
-            sgarg
+import org.apache.log4j.Logger;
             tao
-            daigle
+import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;
-            daigle
+import edu.ucsb.nceas.metacat.database.DBConnection;
 import edu.ucsb.nceas.metacat.database.DBConnectionPool;
-            daigle
+import edu.ucsb.nceas.metacat.properties.PropertyService;
-            daigle
+import edu.ucsb.nceas.metacat.util.AuthUtil;
-            daigle
+import edu.ucsb.nceas.metacat.util.DocumentUtil;
-            daigle
+import edu.ucsb.nceas.metacat.util.MetacatUtil;
-            jones
+import edu.ucsb.nceas.morpho.datapackage.Triple;
 import edu.ucsb.nceas.morpho.datapackage.TripleCollection;
-            daigle
+import edu.ucsb.nceas.utilities.PropertyNotFoundException;
             jones
             harris
-            sgarg
+/**
-            jones
+ * 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
-            jones
+ */
-            jones
+public class DBQuery
+{
             jones
-            jones
+    static final int ALL = 1;
             sgarg
-            jones
+    static final int WRITE = 2;
             sgarg
-            jones
+    static final int READ = 4;
             berkley
     private String qformat = "xml";
             leinfelder
     // are we combining the query with docid list and, if so, using INTERSECT or UNION?
     private String operator = null;
             jones
-            jones
+    //private Connection conn = null;
     private String parserName = null;
             bojilova
-            sgarg
+    private Logger logMetacat = Logger.getLogger(DBQuery.class);
-            harris
+    /** true if the metacat spatial option is installed **/
     private final boolean METACAT_SPATIAL = true;
-            tao
+    /** useful if you just want to grab a list of docids. Since the docids can be very long,
          it is a vector of vector  **/
-            perry
+    Vector docidOverride = new Vector();
             tao
     // a hash table serves as query reuslt cache. Key of hashtable
-            tao
+    // is a query string and value is result xml string
-            tao
+    private static Hashtable queryResultCache = new Hashtable();
     // Capacity of the query result cache
-            daigle
+    private static final int QUERYRESULTCACHESIZE;
     static {
     	int qryRsltCacheSize = 0;
     	try {
-            daigle
+    		qryRsltCacheSize = Integer.parseInt(PropertyService.getProperty("database.queryresultCacheSize"));
-            daigle
+    	} catch (PropertyNotFoundException pnfe) {
     		System.err.println("Could not get QUERYRESULTCACHESIZE property in static block: "
 					+ pnfe.getMessage());
+    	}
     	QUERYRESULTCACHESIZE = qryRsltCacheSize;
+    }
             perry
-            tao
+    // Size of page for non paged query
     private static final int NONPAGESIZE = 99999999;
-            jones
+    /**
      * the main routine used to test the DBQuery utility.
      * <p>
      * Usage: java DBQuery <xmlfile>
-            leinfelder
+     * NOTE: encoding should be provided for best results
-            jones
+     * @param xmlfile the filename of the xml file containing the query
      */
     static public void main(String[] args)
+    {
             bojilova
-            jones
+        if (args.length < 1) {
             System.err.println("Wrong number of arguments!!!");
             System.err.println("USAGE: java DBQuery [-t] [-index] <xmlfile>");
             return;
         } else {
             try {
             bojilova
-            jones
+                int i = 0;
                 boolean showRuntime = false;
                 boolean useXMLIndex = false;
                 if (args[i].equals("-t")) {
                     showRuntime = true;
                     i++;
+                }
                 if (args[i].equals("-index")) {
                     useXMLIndex = true;
                     i++;
+                }
                 String xmlfile = args[i];
             bojilova
-            jones
+                // Time the request if asked for
                 double startTime = System.currentTimeMillis();
             sgarg
-            jones
+                // Open a connection to the database
                 //Connection dbconn = util.openDBConnection();
             sgarg
-            jones
+                double connTime = System.currentTimeMillis();
             sgarg
-            jones
+                // Execute the query
-            jones
+                DBQuery queryobj = new DBQuery();
-            leinfelder
+                Reader xml = new InputStreamReader(new FileInputStream(new File(xmlfile)));
-            jones
+                Hashtable nodelist = null;
-            tao
+                //nodelist = queryobj.findDocuments(xml, null, null, useXMLIndex);
             sgarg
-            jones
+                // 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");
             sgarg
-            jones
+                if (!showRuntime) {
                     Enumeration doclist = nodelist.keys();
                     while (doclist.hasMoreElements()) {
                         docid = (String) doclist.nextElement();
                         document = (String) nodelist.get(docid);
                         result.append("  <document>\n    " + document
                                 + "\n  </document>\n");
+                    }
             bojilova
-            jones
+                    result.append("</resultset>\n");
+                }
                 // Time the request if asked for
                 double stopTime = System.currentTimeMillis();
                 double dbOpenTime = (connTime - startTime) / 1000;
                 double readTime = (stopTime - connTime) / 1000;
                 double executionTime = (stopTime - startTime) / 1000;
                 if (showRuntime) {
                     System.out.print("  " + executionTime);
                     System.out.print("  " + dbOpenTime);
                     System.out.print("  " + readTime);
                     System.out.print("  " + nodelist.size());
                     System.out.println();
+                }
                 //System.out.println(result);
                 //write into a file "result.txt"
                 if (!showRuntime) {
                     File f = new File("./result.txt");
-            leinfelder
+                    Writer fw = new OutputStreamWriter(new FileOutputStream(f));
-            jones
+                    BufferedWriter out = new BufferedWriter(fw);
                     out.write(result.toString());
                     out.flush();
                     out.close();
                     fw.close();
+                }
             sgarg
-            jones
+            } catch (Exception e) {
                 System.err.println("Error in DBQuery.main");
                 System.err.println(e.getMessage());
                 e.printStackTrace(System.err);
+            }
+        }
+    }
             sgarg
-            jones
+    /**
      * construct an instance of the DBQuery class
             tao
-            jones
+     * <p>
      * Generally, one would call the findDocuments() routine after creating an
      * instance to specify the search query
      * </p>
             tao
-            jones
+     * @param parserName the fully qualified name of a Java class implementing
      *            the org.xml.sax.XMLReader interface
      */
-            daigle
+    public DBQuery() throws PropertyNotFoundException
             jones
-            daigle
+        String parserName = PropertyService.getProperty("xml.saxparser");
-            jones
+        this.parserName = parserName;
             jones
             sgarg
-            perry
+    /**
+     *
      * Construct an instance of DBQuery Class
      * BUT accept a docid Vector that will supersede
      * the query.printSQL() method
+     *
      * If a docid Vector is passed in,
      * the docids will be used to create a simple IN query
      * without the multiple subselects of the printSQL() method
+     *
      * Using this constructor, we just check for
      * a docidOverride Vector in the findResultDoclist() method
+     *
      * @param docids List of docids to display in the resultset
      */
-            daigle
+    public DBQuery(Vector docids) throws PropertyNotFoundException
             perry
-            tao
+    	// since the query will be too long to be handled, so we divided the
     	// docids vector into couple vectors.
-            daigle
+    	int size = (new Integer(PropertyService.getProperty("database.appResultsetSize"))).intValue();
-            daigle
+    	logMetacat.info("DBQuery.DBQuery - The size of select doicds is "+docids.size());
     	logMetacat.info("DBQuery.DBQuery - The application result size in metacat.properties is "+size);
-            tao
+    	Vector subset = new Vector();
     	if (docids != null && docids.size() > size)
+    	{
     		int index = 0;
     		for (int i=0; i< docids.size(); i++)
+    		{
     			if (index < size)
+    			{
     				subset.add(docids.elementAt(i));
     				index ++;
+    			}
     			else
+    			{
     				docidOverride.add(subset);
     				subset = new Vector();
     				subset.add(docids.elementAt(i));
     			    index = 1;
+    			}
+    		}
     		if (!subset.isEmpty())
+    		{
     			docidOverride.add(subset);
+    		}
+    	}
     	else
+    	{
     		this.docidOverride.add(docids);
+    	}
-            daigle
+        String parserName = PropertyService.getProperty("xml.saxparser");
-            perry
+        this.parserName = parserName;
+    }
             tao
   /**
    * Method put the search result set into out printerwriter
    * @param resoponse the return response
    * @param out the output printer
    * @param params the paratermer hashtable
    * @param user the user name (it maybe different to the one in param)
    * @param groups the group array
    * @param sessionid  the sessionid
    */
   public void findDocuments(HttpServletResponse response,
-            leinfelder
+                                       Writer out, Hashtable params,
-            tao
+                                       String user, String[] groups,
-            daigle
+                                       String sessionid) throws PropertyNotFoundException
             tao
-            daigle
+    boolean useXMLIndex = (new Boolean(PropertyService.getProperty("database.usexmlindex")))
-            tao
+               .booleanValue();
     findDocuments(response, out, params, user, groups, sessionid, useXMLIndex);
+  }
-            jones
+    /**
-            tao
+     * Method put the search result set into out printerwriter
      * @param resoponse the return response
      * @param out the output printer
      * @param params the paratermer hashtable
      * @param user the user name (it maybe different to the one in param)
      * @param groups the group array
      * @param sessionid  the sessionid
-            jones
+     */
-            tao
+    public void findDocuments(HttpServletResponse response,
-            leinfelder
+                                         Writer out, Hashtable params,
-            tao
+                                         String user, String[] groups,
                                          String sessionid, boolean useXMLIndex)
             jones
-            berkley
+      int pagesize = 0;
       int pagestart = 0;
-            daigle
+      long transferWarnLimit = 0;
             berkley
       if(params.containsKey("pagesize") && params.containsKey("pagestart"))
+      {
         String pagesizeStr = ((String[])params.get("pagesize"))[0];
         String pagestartStr = ((String[])params.get("pagestart"))[0];
         if(pagesizeStr != null && pagestartStr != null)
+        {
           pagesize = (new Integer(pagesizeStr)).intValue();
           pagestart = (new Integer(pagestartStr)).intValue();
+        }
+      }
-            daigle
+      String xmlquery = null;
       String qformat = null;
-            tao
+      // get query and qformat
-            daigle
+      try {
     	xmlquery = ((String[])params.get("query"))[0];
             tao
-            daigle
+        logMetacat.info("DBQuery.findDocuments - SESSIONID: " + sessionid);
         logMetacat.info("DBQuery.findDocuments - xmlquery: " + xmlquery);
-            daigle
+        qformat = ((String[])params.get("qformat"))[0];
-            daigle
+        logMetacat.info("DBQuery.findDocuments - qformat: " + qformat);
             daigle
       catch (Exception ee)
+      {
-            daigle
+        logMetacat.error("DBQuery.findDocuments - Couldn't retrieve xmlquery or qformat value from "
-            daigle
+                  +"params hashtable in DBQuery.findDocuments: "
                   + ee.getMessage());
+      }
-            tao
+      // Get the XML query and covert it into a SQL statment
       QuerySpecification qspec = null;
       if ( xmlquery != null)
+      {
          xmlquery = transformQuery(xmlquery);
          try
+         {
            qspec = new QuerySpecification(xmlquery,
                                           parserName,
-            daigle
+                                          PropertyService.getProperty("document.accNumSeparator"));
             tao
          catch (Exception ee)
+         {
-            daigle
+           logMetacat.error("DBQuery.findDocuments - error generating QuerySpecification object: "
-            sgarg
+                                    + ee.getMessage());
             tao
+      }
             tao
             tao
-            daigle
+      if (qformat != null && qformat.equals(MetacatUtil.XMLFORMAT))
             tao
         //xml format
-            berkley
+        if(response != null)
+        {
             response.setContentType("text/xml");
+        }
-            berkley
+        createResultDocument(xmlquery, qspec, out, user, groups, useXMLIndex,
           pagesize, pagestart, sessionid, qformat);
-            tao
+      }//if
       else
+      {
         //knb format, in this case we will get whole result and sent it out
-            berkley
+        response.setContentType("text/html");
-            leinfelder
+        Writer nonout = null;
-            tao
+        StringBuffer xml = createResultDocument(xmlquery, qspec, nonout, user,
-            berkley
+                                                groups, useXMLIndex, pagesize,
-            berkley
+                                                pagestart, sessionid, qformat);
             sgarg
-            tao
+        //transfer the xml to html
         try
+        {
-            daigle
+         long startHTMLTransform = System.currentTimeMillis();
-            tao
+         DBTransform trans = new DBTransform();
          response.setContentType("text/html");
             sgarg
-            berkley
+         // if the user is a moderator, then pass a param to the
-            sgarg
+         // xsl specifying the fact
-            daigle
+         if(AuthUtil.isModerator(user, groups)){
-            sgarg
+        	 params.put("isModerator", new String[] {"true"});
+         }
-            tao
+         trans.transformXMLDocument(xml.toString(), "-//NCEAS//resultset//EN",
                                  "-//W3C//HTML//EN", qformat, out, params,
                                  sessionid);
-            daigle
+         long transformRunTime = System.currentTimeMillis() - startHTMLTransform;
          transferWarnLimit = Long.parseLong(PropertyService.getProperty("dbquery.transformTimeWarnLimit"));
          if (transformRunTime > transferWarnLimit) {
          	logMetacat.warn("DBQuery.findDocuments - The time to transfrom resultset from xml to html format is "
                   		                             + transformRunTime);
+         }
-            daigle
+          MetacatUtil.writeDebugToFile("---------------------------------------------------------------------------------------------------------------Transfrom xml to html  "
-            daigle
+                             + transformRunTime);
           MetacatUtil.writeDebugToDelimiteredFile(" " + transformRunTime, false);
             tao
         catch(Exception e)
+        {
-            daigle
+         logMetacat.error("DBQuery.findDocuments - Error in MetaCatServlet.transformResultset:"
-            sgarg
+                                +e.getMessage());
             tao
       }//else
             berkley
             berkley
             tao
   /**
    * Transforms a hashtable of documents to an xml or html result and sent
    * the content to outputstream. Keep going untill hastable is empty. stop it.
    * add the QuerySpecification as parameter is for ecogrid. But it is duplicate
    * to xmlquery String
    * @param xmlquery
    * @param qspec
    * @param out
    * @param user
    * @param groups
    * @param useXMLIndex
    * @param sessionid
    * @return
    */
     public StringBuffer createResultDocument(String xmlquery,
                                               QuerySpecification qspec,
-            leinfelder
+                                              Writer out,
-            tao
+                                              String user, String[] groups,
                                               boolean useXMLIndex)
+    {
-            berkley
+    	return createResultDocument(xmlquery,qspec,out, user,groups, useXMLIndex, 0, 0,"", qformat);
             tao
             sgarg
-            tao
+  /*
    * Transforms a hashtable of documents to an xml or html result and sent
-            tao
+   * the content to outputstream. Keep going untill hastable is empty. stop it.
    * add the QuerySpecification as parameter is for ecogrid. But it is duplicate
    * to xmlquery String
-            tao
+   */
-            tao
+  public StringBuffer createResultDocument(String xmlquery,
                                             QuerySpecification qspec,
-            leinfelder
+                                            Writer out,
-            tao
+                                            String user, String[] groups,
-            berkley
+                                            boolean useXMLIndex, int pagesize,
-            berkley
+                                            int pagestart, String sessionid,
                                             String qformat)
             tao
     DBConnection dbconn = null;
     int serialNumber = -1;
     StringBuffer resultset = new StringBuffer();
             berkley
     //try to get the cached version first
-            daigle
+    // Hashtable sessionHash = MetaCatServlet.getSessionHash();
     // HttpSession sess = (HttpSession)sessionHash.get(sessionid);
             berkley
             tao
-            tao
+    resultset.append("<?xml version=\"1.0\"?>\n");
     resultset.append("<resultset>\n");
-            berkley
+    resultset.append("  <pagestart>" + pagestart + "</pagestart>\n");
     resultset.append("  <pagesize>" + pagesize + "</pagesize>\n");
     resultset.append("  <nextpage>" + (pagestart + 1) + "</nextpage>\n");
     resultset.append("  <previouspage>" + (pagestart - 1) + "</previouspage>\n");
-            tao
+    resultset.append("  <query>" + xmlquery + "</query>");
-            berkley
+    //send out a new query
-            tao
+    if (out != null)
             jones
-            leinfelder
+    	try {
     	  out.write(resultset.toString());
 		} catch (IOException e) {
 			logMetacat.error(e.getMessage(), e);
+		}
             jones
-            tao
+    if (qspec != null)
             tao
-            tao
+      try
+      {
             sgarg
-            tao
+        //checkout the dbconnection
         dbconn = DBConnectionPool.getDBConnection("DBQuery.findDocuments");
         serialNumber = dbconn.getCheckOutSerialNumber();
             tao
-            tao
+        //print out the search result
         // search the doc list
-            tao
+        Vector givenDocids = new Vector();
         StringBuffer resultContent = new StringBuffer();
         if (docidOverride == null || docidOverride.size() == 0)
+        {
-            daigle
+        	logMetacat.debug("DBQuery.createResultDocument - Not in map query");
-            tao
+        	resultContent = findResultDoclist(qspec, out, user, groups,
                     dbconn, useXMLIndex, pagesize, pagestart,
-            berkley
+                    sessionid, givenDocids, qformat);
             tao
         else
+        {
-            daigle
+        	logMetacat.debug("DBQuery.createResultDocument - In map query");
-            tao
+        	// since docid can be too long to be handled. We divide it into several parts
         	for (int i= 0; i<docidOverride.size(); i++)
+        	{
-            daigle
+        	   logMetacat.debug("DBQuery.createResultDocument - in loop===== "+i);
-            tao
+        		givenDocids = (Vector)docidOverride.elementAt(i);
         		StringBuffer subset = findResultDoclist(qspec, out, user, groups,
                         dbconn, useXMLIndex, pagesize, pagestart,
-            berkley
+                        sessionid, givenDocids, qformat);
-            tao
+        		resultContent.append(subset);
+        	}
+        }
-            tao
+        resultset.append(resultContent);
-            tao
+      } //try
       catch (IOException ioe)
+      {
-            daigle
+        logMetacat.error("DBQuery.createResultDocument - IO error: " + ioe.getMessage());
             tao
       catch (SQLException e)
+      {
-            daigle
+        logMetacat.error("DBQuery.createResultDocument - SQL Error: " + e.getMessage());
             tao
       catch (Exception ee)
+      {
-            daigle
+        logMetacat.error("DBQuery.createResultDocument - General exception: "
-            sgarg
+                                 + ee.getMessage());
-            berkley
+        ee.printStackTrace();
             tao
       finally
+      {
         DBConnectionPool.returnDBConnection(dbconn, serialNumber);
       } //finally
     }//if
-            tao
+    String closeRestultset = "</resultset>";
     resultset.append(closeRestultset);
     if (out != null)
+    {
-            leinfelder
+      try {
 		out.write(closeRestultset);
 		} catch (IOException e) {
 			logMetacat.error(e.getMessage(), e);
+		}
             tao
             tao
-            berkley
+    //default to returning the whole resultset
-            tao
+    return resultset;
   }//createResultDocuments
             sgarg
-            tao
+    /*
      * Find the doc list which match the query
      */
     private StringBuffer findResultDoclist(QuerySpecification qspec,
-            leinfelder
+                                      Writer out,
-            tao
+                                      String user, String[]groups,
-            berkley
+                                      DBConnection dbconn, boolean useXMLIndex,
-            berkley
+                                      int pagesize, int pagestart, String sessionid,
                                       Vector givenDocids, String qformat)
-            tao
+                                      throws Exception
+    {
-            tao
+      StringBuffer resultsetBuffer = new StringBuffer();
-            berkley
+      String query = null;
       int count = 0;
       int index = 0;
-            berkley
+      ResultDocumentSet docListResult = new ResultDocumentSet();
-            berkley
+      PreparedStatement pstmt = null;
       String docid = null;
       String docname = null;
       String doctype = null;
       String createDate = null;
       String updateDate = null;
       StringBuffer document = null;
-            berkley
+      boolean lastpage = false;
-            berkley
+      int rev = 0;
       double startTime = 0;
-            tao
+      int offset = 1;
-            daigle
+      long startSelectionTime = System.currentTimeMillis();
-            berkley
+      ResultSet rs = null;
             tao
       // this is a hack for offset. in postgresql 7, if the returned docid list is too long,
       //the extend query which base on the docid will be too long to be run. So we
       // have to cut them into different parts. Page query don't need it somehow.
       if (out == null)
             tao
         // for html page, we put everything into one page
-            sgarg
+        offset =
-            daigle
+            (new Integer(PropertyService.getProperty("database.webResultsetSize"))).intValue();
             tao
       else
+      {
           offset =
-            daigle
+              (new Integer(PropertyService.getProperty("database.appResultsetSize"))).intValue();
             tao
             sgarg
-            perry
+      /*
        * Check the docidOverride Vector
        * if defined, we bypass the qspec.printSQL() method
        * and contruct a simpler query based on a
        * list of docids rather than a bunch of subselects
        */
-            tao
+      if ( givenDocids == null || givenDocids.size() == 0 ) {
-            perry
+          query = qspec.printSQL(useXMLIndex);
       } else {
-            leinfelder
+    	  // condition for the docids
     	  StringBuffer docidCondition = new StringBuffer();
     	  docidCondition.append( " docid IN (" );
-            tao
+          for (int i = 0; i < givenDocids.size(); i++) {
-            leinfelder
+        	  docidCondition.append("'");
         	  docidCondition.append( (String)givenDocids.elementAt(i) );
         	  docidCondition.append("'");
         	  if (i < givenDocids.size()-1) {
         		  docidCondition.append(",");
+        	  }
             perry
-            leinfelder
+          docidCondition.append( ") " );
     	  // include the docids, either exclusively, or in conjuction with the query
     	  if (operator == null) {
     		  query = "SELECT docid, docname, doctype, date_created, date_updated, rev FROM xml_documents WHERE";
               query = query + docidCondition.toString();
     	  } else {
     		  // start with the keyword query, but add conditions
               query = qspec.printSQL(useXMLIndex);
               String myOperator = "";
               if (!query.endsWith("WHERE")) {
 	              if (operator.equalsIgnoreCase(QueryGroup.UNION)) {
 	            	  myOperator =  " OR ";
+	              }
 	              else {
 	            	  myOperator =  " AND ";
+	              }
+              }
               query = query + myOperator + docidCondition.toString();
+    	  }
             perry
-            tao
+      String ownerQuery = getOwnerQuery(user);
-            daigle
+      //logMetacat.debug("query: " + query);
-            daigle
+      logMetacat.debug("DBQuery.findResultDoclist - owner query: " + ownerQuery);
-            tao
+      // if query is not the owner query, we need to check the permission
       // otherwise we don't need (owner has all permission by default)
       if (!query.equals(ownerQuery))
+      {
         // set user name and group
         qspec.setUserName(user);
         qspec.setGroup(groups);
         // Get access query
         String accessQuery = qspec.getAccessQuery();
-            sgarg
+        if(!query.endsWith("WHERE")){
             query = query + accessQuery;
         } else {
             query = query + accessQuery.substring(4, accessQuery.length());
+        }
             tao
             tao
-            daigle
+      logMetacat.debug("DBQuery.findResultDoclist - final selection query: " + query);
-            tao
+      String selectionAndExtendedQuery = null;
-            tao
+      // we only get cache for public
       if (user != null && user.equalsIgnoreCase("public")
-            daigle
+     		 && pagesize == 0 && PropertyService.getProperty("database.queryCacheOn").equals("true"))
             tao
-            tao
+    	  selectionAndExtendedQuery = query +qspec.getReturnDocList()+qspec.getReturnFieldList();
    	      String cachedResult = getResultXMLFromCache(selectionAndExtendedQuery);
-            daigle
+   	      logMetacat.debug("DBQuery.findResultDoclist - The key of query cache is " + selectionAndExtendedQuery);
-            tao
+   	      //System.out.println("==========the string from cache is "+cachedResult);
    	      if (cachedResult != null)
+   	      {
-            daigle
+   	    	logMetacat.info("DBQuery.findResultDoclist - result from cache !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-            tao
+   	    	 if (out != null)
+   	         {
-            leinfelder
+   	             out.write(cachedResult);
             tao
    	    	 resultsetBuffer.append(cachedResult);
    	    	 return resultsetBuffer;
+   	      }
+      }
-            berkley
+      startTime = System.currentTimeMillis() / 1000;
-            tao
+      pstmt = dbconn.prepareStatement(query);
-            berkley
+      rs = pstmt.executeQuery();
             berkley
-            tao
+      double queryExecuteTime = System.currentTimeMillis() / 1000;
-            daigle
+      logMetacat.debug("DBQuery.findResultDoclist - Time to execute select docid query is "
-            sgarg
+                    + (queryExecuteTime - startTime));
-            daigle
+      MetacatUtil.writeDebugToFile("\n\n\n\n\n\nExecute selection query  "
-            tao
+              + (queryExecuteTime - startTime));
-            daigle
+      MetacatUtil.writeDebugToDelimiteredFile(""+(queryExecuteTime - startTime), false);
             berkley
-            berkley
+      boolean tableHasRows = rs.next();
             berkley
       if(pagesize == 0)
       { //this makes sure we get all results if there is no paging
-            tao
+        pagesize = NONPAGESIZE;
         pagestart = NONPAGESIZE;
             berkley
       int currentIndex = 0;
-            tao
+      while (tableHasRows)
+      {
-            daigle
+        logMetacat.debug("DBQuery.findResultDoclist - getting result: " + currentIndex);
-            tao
+        docid = rs.getString(1).trim();
-            daigle
+        logMetacat.debug("DBQuery.findResultDoclist -  processing: " + docid);
-            tao
+        docname = rs.getString(2);
         doctype = rs.getString(3);
-            daigle
+        logMetacat.debug("DBQuery.findResultDoclist - processing: " + doctype);
-            tao
+        createDate = rs.getString(4);
         updateDate = rs.getString(5);
         rev = rs.getInt(6);
             berkley
-            tao
+         Vector returndocVec = qspec.getReturnDocList();
        if (returndocVec.size() == 0 || returndocVec.contains(doctype))
             tao
-            daigle
+          logMetacat.debug("DBQuery.findResultDoclist - NOT Back tracing now...");
-            tao
+           document = new StringBuffer();
             sgarg
-            tao
+           String completeDocid = docid
-            daigle
+                            + PropertyService.getProperty("document.accNumSeparator");
-            tao
+           completeDocid += rev;
            document.append("<docid>").append(completeDocid).append("</docid>");
            if (docname != null)
+           {
                document.append("<docname>" + docname + "</docname>");
             berkley
            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
             berkley
            docListResult.addResultDocument(
              new ResultDocument(docid, (String) document.toString()));
-            daigle
+           logMetacat.info("DBQuery.findResultDoclist - real result: " + docid);
-            berkley
+           currentIndex++;
-            berkley
+           count++;
-            tao
+        }//else
             berkley
-            tao
+        // when doclist reached the offset number, send out doc list and empty
         // the hash table
-            tao
+        if (count == offset && pagesize == NONPAGESIZE)
-            berkley
+        { //if pagesize is not 0, do this later.
-            tao
+          //reset count
-            berkley
+          //logMetacat.warn("############doing subset cache");
-            tao
+          count = 0;
-            berkley
+          handleSubsetResult(qspec, resultsetBuffer, out, docListResult,
-            berkley
+                              user, groups,dbconn, useXMLIndex, qformat);
-            berkley
+          //reset docListResult
           docListResult = new ResultDocumentSet();
             tao
             berkley
-            daigle
+       logMetacat.debug("DBQuery.findResultDoclist - currentIndex: " + currentIndex);
        logMetacat.debug("DBQuery.findResultDoclist - page comparator: " + (pagesize * pagestart) + pagesize);
-            berkley
+       if(currentIndex >= ((pagesize * pagestart) + pagesize))
+       {
          ResultDocumentSet pagedResultsHash = new ResultDocumentSet();
          for(int i=pagesize*pagestart; i<docListResult.size(); i++)
+         {
            pagedResultsHash.put(docListResult.get(i));
+         }
          docListResult = pagedResultsHash;
          break;
+       }
-            tao
+       // Advance to the next record in the cursor
        tableHasRows = rs.next();
-            berkley
+       if(!tableHasRows)
+       {
-            berkley
+         ResultDocumentSet pagedResultsHash = new ResultDocumentSet();
          //get the last page of information then break
-            tao
+         if(pagesize != NONPAGESIZE)
             berkley
            for(int i=pagesize*pagestart; i<docListResult.size(); i++)
+           {
              pagedResultsHash.put(docListResult.get(i));
+           }
            docListResult = pagedResultsHash;
+         }
          lastpage = true;
-            berkley
+         break;
+       }
-            tao
+     }//while
             berkley
-            tao
+     rs.close();
      pstmt.close();
-            daigle
+     long docListTime = System.currentTimeMillis() - startSelectionTime;
      long docListWarnLimit = Long.parseLong(PropertyService.getProperty("dbquery.findDocListTimeWarnLimit"));
      if (docListTime > docListWarnLimit) {
     	 logMetacat.warn("DBQuery.findResultDoclist - Total time to get docid list is: "
                           + docListTime);
+     }
-            daigle
+     MetacatUtil.writeDebugToFile("---------------------------------------------------------------------------------------------------------------Total selection: "
-            daigle
+             + docListTime);
      MetacatUtil.writeDebugToDelimiteredFile(" "+ docListTime, false);
-            tao
+     //if docListResult is not empty, it need to be sent.
-            berkley
+     if (docListResult.size() != 0)
             tao
             tao
-            tao
+       handleSubsetResult(qspec,resultsetBuffer, out, docListResult,
-            berkley
+                              user, groups,dbconn, useXMLIndex, qformat);
             tao
             tao
-            berkley
+     resultsetBuffer.append("\n<lastpage>" + lastpage + "</lastpage>\n");
      if (out != null)
+     {
-            leinfelder
+         out.write("\n<lastpage>" + lastpage + "</lastpage>\n");
             berkley
             tao
      // now we only cached none-paged query and user is public
      if (user != null && user.equalsIgnoreCase("public")
-            daigle
+    		 && pagesize == NONPAGESIZE && PropertyService.getProperty("database.queryCacheOn").equals("true"))
             tao
        //System.out.println("the string stored into cache is "+ resultsetBuffer.toString());
-            tao
+  	   storeQueryResultIntoCache(selectionAndExtendedQuery, resultsetBuffer.toString());
             tao
             berkley
-            tao
+     return resultsetBuffer;
     }//findReturnDoclist
             sgarg
-            tao
+    /*
      * Send completed search hashtable(part of reulst)to output stream
      * and buffer into a buffer stream
      */
     private StringBuffer handleSubsetResult(QuerySpecification qspec,
                                            StringBuffer resultset,
-            leinfelder
+                                           Writer out, ResultDocumentSet partOfDoclist,
-            tao
+                                           String user, String[]groups,
-            berkley
+                                       DBConnection dbconn, boolean useXMLIndex,
                                        String qformat)
-            tao
+                                       throws Exception
+   {
-            daigle
+     double startReturnFieldTime = System.currentTimeMillis();
-            sgarg
+     // check if there is a record in xml_returnfield
      // and get the returnfield_id and usage count
      int usage_count = getXmlReturnfieldsTableId(qspec, dbconn);
      boolean enterRecords = false;
-            daigle
+     // get value of database.xmlReturnfieldCount
-            daigle
+     int count = (new Integer(PropertyService
-            daigle
+                            .getProperty("database.xmlReturnfieldCount")))
-            sgarg
+                            .intValue();
             sgarg
-            sgarg
+     // set enterRecords to true if usage_count is more than the offset
-            sgarg
+     // specified in metacat.properties
-            sgarg
+     if(usage_count > count){
          enterRecords = true;
+     }
             berkley
-            sgarg
+     if(returnfield_id < 0){
-            daigle
+         logMetacat.warn("DBQuery.handleSubsetResult - Error in getting returnfield id from"
-            sgarg
+                                  + "xml_returnfield table");
-            berkley
+         enterRecords = false;
             sgarg
      // get the hashtable containing the docids that already in the
      // xml_queryresult table
-            daigle
+     logMetacat.info("DBQuery.handleSubsetResult - size of partOfDoclist before"
-            sgarg
+                             + " docidsInQueryresultTable(): "
-            sgarg
+                             + partOfDoclist.size());
-            daigle
+     long startGetReturnValueFromQueryresultable = System.currentTimeMillis();
-            sgarg
+     Hashtable queryresultDocList = docidsInQueryresultTable(returnfield_id,
                                                         partOfDoclist, dbconn);
      // remove the keys in queryresultDocList from partOfDoclist
      Enumeration _keys = queryresultDocList.keys();
      while (_keys.hasMoreElements()){
-            berkley
+         partOfDoclist.remove((String)_keys.nextElement());
             sgarg
             daigle
      long queryResultReturnValuetime = System.currentTimeMillis() - startGetReturnValueFromQueryresultable;
      long queryResultWarnLimit =
     	 Long.parseLong(PropertyService.getProperty("dbquery.findQueryResultsTimeWarnLimit"));
      if (queryResultReturnValuetime > queryResultWarnLimit) {
     	 logMetacat.warn("DBQuery.handleSubsetResult - Time to get return fields from xml_queryresult table is (Part1 in return fields) " +
     		 queryResultReturnValuetime);
+     }
-            daigle
+     MetacatUtil.writeDebugToFile("-----------------------------------------Get fields from xml_queryresult(Part1 in return fields) " +
-            daigle
+    		 queryResultReturnValuetime);
      MetacatUtil.writeDebugToDelimiteredFile(" " + queryResultReturnValuetime,false);
      long startExtendedQuery = System.currentTimeMillis();
-            sgarg
+     // backup the keys-elements in partOfDoclist to check later
      // if the doc entry is indexed yet
      Hashtable partOfDoclistBackup = new Hashtable();
-            berkley
+     Iterator itt = partOfDoclist.getDocids();
      while (itt.hasNext()){
        Object key = itt.next();
-            sgarg
+         partOfDoclistBackup.put(key, partOfDoclist.get(key));
+     }
-            daigle
+     logMetacat.info("DBQuery.handleSubsetResult - size of partOfDoclist after"
-            sgarg
+                             + " docidsInQueryresultTable(): "
-            sgarg
+                             + partOfDoclist.size());
             sgarg
      //add return fields for the documents in partOfDoclist
      partOfDoclist = addReturnfield(partOfDoclist, qspec, user, groups,
-            berkley
+                                        dbconn, useXMLIndex, qformat);
-            daigle
+     long extendedQueryRunTime = startExtendedQuery - System.currentTimeMillis();
      long extendedQueryWarnLimit =
     	 Long.parseLong(PropertyService.getProperty("dbquery.extendedQueryRunTimeWarnLimit"));
      if (extendedQueryRunTime > extendedQueryWarnLimit) {
     	 logMetacat.warn("DBQuery.handleSubsetResult - Get fields from index and node table (Part2 in return fields) "
         		                                          + extendedQueryRunTime);
+     }
-            daigle
+     MetacatUtil.writeDebugToFile("-----------------------------------------Get fields from extened query(Part2 in return fields) "
-            daigle
+             + extendedQueryRunTime);
-            daigle
+     MetacatUtil.writeDebugToDelimiteredFile(" "
-            daigle
+             + extendedQueryRunTime, false);
-            sgarg
+     //add relationship part part docid list for the documents in partOfDocList
-            tao
+     //partOfDoclist = addRelationship(partOfDoclist, qspec, dbconn, useXMLIndex);
             sgarg
-            daigle
+     long startStoreReturnField = System.currentTimeMillis();
-            berkley
+     Iterator keys = partOfDoclist.getDocids();
-            tao
+     String key = null;
      String element = null;
-            sgarg
+     String query = null;
-            daigle
+     int offset = (new Integer(PropertyService
-            daigle
+                               .getProperty("database.queryresultStringLength")))
-            sgarg
+                               .intValue();
-            berkley
+     while (keys.hasNext())
             tao
-            berkley
+         key = (String) keys.next();
-            sgarg
+         element = (String)partOfDoclist.get(key);
             tao
-            sgarg
+	 // check if the enterRecords is true, elements is not null, element's
          // length is less than the limit of table column and if the document
-            sgarg
+         // has been indexed already
-            sgarg
+         if(enterRecords && element != null
-            sgarg
+		&& element.length() < offset
 		&& element.compareTo((String) partOfDoclistBackup.get(key)) != 0){
-            sgarg
+             query = "INSERT INTO xml_queryresult (returnfield_id, docid, "
-            sgarg
+                 + "queryresult_string) VALUES (?, ?, ?)";
-            sgarg
+             PreparedStatement pstmt = null;
              pstmt = dbconn.prepareStatement(query);
-            sgarg
+             pstmt.setInt(1, returnfield_id);
              pstmt.setString(2, key);
              pstmt.setString(3, element);
             tao
-            sgarg
+             dbconn.increaseUsageCount(1);
-            tao
+             try
+             {
             	 pstmt.execute();
+             }
              catch(Exception e)
+             {
-            daigle
+            	 logMetacat.warn("DBQuery.handleSubsetResult - couldn't insert the element to xml_queryresult table "+e.getLocalizedMessage());
             tao
              finally
+             {
                 pstmt.close();
+             }
             sgarg
             tao
-            sgarg
+         // A string with element
          String xmlElement = "  <document>" + element + "</document>";
             berkley
-            sgarg
+         //send single element to output
          if (out != null)
+         {
-            leinfelder
+             out.write(xmlElement);
             sgarg
          resultset.append(xmlElement);
      }//while
             tao
-            daigle
+     double storeReturnFieldTime = System.currentTimeMillis() - startStoreReturnField;
      long storeReturnFieldWarnLimit =
     	 Long.parseLong(PropertyService.getProperty("dbquery.storeReturnFieldTimeWarnLimit"));
      if (storeReturnFieldTime > storeReturnFieldWarnLimit) {
     	 logMetacat.warn("DBQuery.handleSubsetResult - Time to store new return fields into xml_queryresult table (Part4 in return fields) "
                    + storeReturnFieldTime);
+     }
-            daigle
+     MetacatUtil.writeDebugToFile("-----------------------------------------Insert new record to xml_queryresult(Part4 in return fields) "
-            daigle
+             + storeReturnFieldTime);
      MetacatUtil.writeDebugToDelimiteredFile(" " + storeReturnFieldTime, false);
             tao
-            berkley
+     Enumeration keysE = queryresultDocList.keys();
      while (keysE.hasMoreElements())
             sgarg
-            berkley
+         key = (String) keysE.nextElement();
-            sgarg
+         element = (String)queryresultDocList.get(key);
          // A string with element
          String xmlElement = "  <document>" + element + "</document>";
          //send single element to output
          if (out != null)
+         {
-            leinfelder
+             out.write(xmlElement);
             sgarg
          resultset.append(xmlElement);
      }//while
-            daigle
+     double returnFieldTime = System.currentTimeMillis() - startReturnFieldTime;
      long totalReturnFieldWarnLimit =
     	 Long.parseLong(PropertyService.getProperty("dbquery.totalReturnFieldTimeWarnLimit"));
      if (returnFieldTime > totalReturnFieldWarnLimit) {
     	 logMetacat.warn("DBQuery.handleSubsetResult - Total time to get return fields is: "
                            + returnFieldTime);
+     }
      MetacatUtil.writeDebugToFile("DBQuery.handleSubsetResult - ---------------------------------------------------------------------------------------------------------------"+
     		 "Total to get return fields  " + returnFieldTime);
      MetacatUtil.writeDebugToDelimiteredFile("DBQuery.handleSubsetResult - "+ returnFieldTime, false);
-            sgarg
+     return resultset;
+ }
    /**
     * Get the docids already in xml_queryresult table and corresponding
     * queryresultstring as a hashtable
     */
    private Hashtable docidsInQueryresultTable(int returnfield_id,
-            berkley
+                                              ResultDocumentSet partOfDoclist,
-            sgarg
+                                              DBConnection dbconn){
          Hashtable returnValue = new Hashtable();
          PreparedStatement pstmt = null;
          ResultSet rs = null;
          // get partOfDoclist as string for the query
-            berkley
+         Iterator keylist = partOfDoclist.getDocids();
-            sgarg
+         StringBuffer doclist = new StringBuffer();
-            berkley
+         while (keylist.hasNext())
             sgarg
              doclist.append("'");
-            berkley
+             doclist.append((String) keylist.next());
-            sgarg
+             doclist.append("',");
          }//while
          if (doclist.length() > 0)
+         {
              doclist.deleteCharAt(doclist.length() - 1); //remove the last comma
              // the query to find out docids from xml_queryresult
              String query = "select docid, queryresult_string from "
                           + "xml_queryresult where returnfield_id = " +
                           returnfield_id +" and docid in ("+ doclist + ")";
-            daigle
+             logMetacat.info("DBQuery.docidsInQueryresultTable - Query to get docids from xml_queryresult:"
-            sgarg
+                                      + query);
             sgarg
              try {
                  // prepare and execute the query
                  pstmt = dbconn.prepareStatement(query);
                  dbconn.increaseUsageCount(1);
                  pstmt.execute();
                  rs = pstmt.getResultSet();
                  boolean tableHasRows = rs.next();
                  while (tableHasRows) {
                      // store the returned results in the returnValue hashtable
                      String key = rs.getString(1);
                      String element = rs.getString(2);
                      if(element != null){
                          returnValue.put(key, element);
                      } else {
-            daigle
+                         logMetacat.info("DBQuery.docidsInQueryresultTable - Null elment found ("
-            sgarg
+                         + "DBQuery.docidsInQueryresultTable)");
             sgarg
                      tableHasRows = rs.next();
+                 }
                  rs.close();
                  pstmt.close();
              } catch (Exception e){
-            daigle
+                 logMetacat.error("DBQuery.docidsInQueryresultTable - Error getting docids from "
                                           + "queryresult: " + e.getMessage());
             sgarg
+         }
          return returnValue;
+     }
    /**
     * Method to get id from xml_returnfield table
     * for a given query specification
     */
-            sgarg
+   private int returnfield_id;
-            sgarg
+   private int getXmlReturnfieldsTableId(QuerySpecification qspec,
                                            DBConnection dbconn){
        int id = -1;
-            sgarg
+       int count = 1;
-            sgarg
+       PreparedStatement pstmt = null;
        ResultSet rs = null;
        String returnfield = qspec.getSortedReturnFieldString();
        // query for finding the id from xml_returnfield
-            sgarg
+       String query = "SELECT returnfield_id, usage_count FROM xml_returnfield "
             + "WHERE returnfield_string LIKE ?";
-            daigle
+       logMetacat.info("DBQuery.getXmlReturnfieldsTableId - ReturnField Query:" + query);
             sgarg
        try {
            // prepare and run the query
            pstmt = dbconn.prepareStatement(query);
-            sgarg
+           pstmt.setString(1,returnfield);
-            sgarg
+           dbconn.increaseUsageCount(1);
            pstmt.execute();
            rs = pstmt.getResultSet();
            boolean tableHasRows = rs.next();
            // if record found then increase the usage count
            // else insert a new record and get the id of the new record
            if(tableHasRows){
                // get the id
                id = rs.getInt(1);
-            sgarg
+               count = rs.getInt(2) + 1;
-            sgarg
+               rs.close();
                pstmt.close();
                // increase the usage count
                query = "UPDATE xml_returnfield SET usage_count ='" + count
                    + "' WHERE returnfield_id ='"+ id +"'";
-            daigle
+               logMetacat.info("DBQuery.getXmlReturnfieldsTableId - ReturnField Table Update:"+ query);
             sgarg
                pstmt = dbconn.prepareStatement(query);
                dbconn.increaseUsageCount(1);
                pstmt.execute();
                pstmt.close();
            } else {
                rs.close();
                pstmt.close();
                // insert a new record
                query = "INSERT INTO xml_returnfield (returnfield_string, usage_count)"
-            sgarg
+                   + "VALUES (?, '1')";
-            daigle
+               logMetacat.info("DBQuery.getXmlReturnfieldsTableId - ReturnField Table Insert:"+ query);
-            sgarg
+               pstmt = dbconn.prepareStatement(query);
-            sgarg
+               pstmt.setString(1, returnfield);
-            sgarg
+               dbconn.increaseUsageCount(1);
                pstmt.execute();
                pstmt.close();
                // get the id of the new record
-            sgarg
+               query = "SELECT returnfield_id FROM xml_returnfield "
                    + "WHERE returnfield_string LIKE ?";
-            daigle
+               logMetacat.info("DBQuery.getXmlReturnfieldsTableId - ReturnField query after Insert:" + query);
-            sgarg
+               pstmt = dbconn.prepareStatement(query);
-            sgarg
+               pstmt.setString(1, returnfield);
-            sgarg
+               dbconn.increaseUsageCount(1);
                pstmt.execute();
                rs = pstmt.getResultSet();
                if(rs.next()){
                    id = rs.getInt(1);
                } else {
                    id = -1;
+               }
                rs.close();
                pstmt.close();
             tao
             tao
-            sgarg
+       } catch (Exception e){
-            daigle
+           logMetacat.error("DBQuery.getXmlReturnfieldsTableId - Error getting id from xml_returnfield in "
-            sgarg
+                                     + "DBQuery.getXmlReturnfieldsTableId: "
-            sgarg
+                                     + e.getMessage());
-            sgarg
+           id = -1;
+       }
             sgarg
        returnfield_id = id;
        return count;
             tao
             sgarg
-            tao
+    /*
      * A method to add return field to return doclist hash table
      */
-            berkley
+    private ResultDocumentSet addReturnfield(ResultDocumentSet docListResult,
-            tao
+                                      QuerySpecification qspec,
                                       String user, String[]groups,
-            berkley
+                                      DBConnection dbconn, boolean useXMLIndex,
                                       String qformat)
-            tao
+                                      throws Exception
+    {
       PreparedStatement pstmt = null;
       ResultSet rs = null;
       String docid = null;
       String fieldname = null;
-            leinfelder
+      String fieldtype = null;
-            tao
+      String fielddata = null;
       String relation = null;
       if (qspec.containsExtendedSQL())
+      {
         qspec.setUserName(user);
         qspec.setGroup(groups);
         Vector extendedFields = new Vector(qspec.getReturnFieldList());
         Vector results = new Vector();
-            berkley
+        Iterator keylist = docListResult.getDocids();
-            tao
+        StringBuffer doclist = new StringBuffer();
         Vector parentidList = new Vector();
         Hashtable returnFieldValue = new Hashtable();
-            berkley
+        while (keylist.hasNext())
             tao
-            berkley
+          String key = (String)keylist.next();
-            tao
+          doclist.append("'");
-            berkley
+          doclist.append(key);
-            tao
+          doclist.append("',");
+        }
         if (doclist.length() > 0)
+        {
           Hashtable controlPairs = new Hashtable();
           doclist.deleteCharAt(doclist.length() - 1); //remove the last comma
-            tao
+          boolean tableHasRows = false;
             tao
             tao
            String extendedQuery =
-            tao
+               qspec.printExtendedSQL(doclist.toString(), useXMLIndex);
-            daigle
+           logMetacat.info("DBQuery.addReturnfield - Extended query: " + extendedQuery);
             sgarg
-            sgarg
+           if(extendedQuery != null){
-            daigle
+//        	   long extendedQueryStart = System.currentTimeMillis();
-            sgarg
+               pstmt = dbconn.prepareStatement(extendedQuery);
                //increase dbconnection usage count
                dbconn.increaseUsageCount(1);
                pstmt.execute();
                rs = pstmt.getResultSet();
                tableHasRows = rs.next();
                while (tableHasRows) {
                    ReturnFieldValue returnValue = new ReturnFieldValue();
                    docid = rs.getString(1).trim();
                    fieldname = rs.getString(2);
             berkley
                    if(qformat.toLowerCase().trim().equals("xml"))
+                   {
                        byte[] b = rs.getBytes(3);
-            leinfelder
+                       fielddata = new String(b, 0, b.length, MetaCatServlet.DEFAULT_ENCODING);
             berkley
                    else
+                   {
                        fielddata = rs.getString(3);
+                   }
                    //System.out.println("raw fielddata: " + fielddata);
-            daigle
+                   fielddata = MetacatUtil.normalize(fielddata);
-            berkley
+                   //System.out.println("normalized fielddata: " + fielddata);
-            sgarg
+                   String parentId = rs.getString(4);
-            leinfelder
+                   fieldtype = rs.getString(5);
-            sgarg
+                   StringBuffer value = new StringBuffer();
             sgarg
-            leinfelder
+                   //handle case when usexmlindex is true differently
                    //at one point merging the nodedata (for large text elements) was
                    //deemed unnecessary - but now it is needed.  but not for attribute nodes
-            sgarg
+                   if (useXMLIndex || !containsKey(parentidList, parentId)) {
-            leinfelder
+                	   //merge node data only for non-ATTRIBUTEs
                 	   if (fieldtype != null && !fieldtype.equals("ATTRIBUTE")) {
 	                	   //try merging the data
 	                	   ReturnFieldValue existingRFV =
 	                		   getArrayValue(parentidList, parentId);
-            berkley
+	                	   if (existingRFV != null && !existingRFV.getFieldType().equals("ATTRIBUTE")) {
-            leinfelder
+	                		   fielddata = existingRFV.getFieldValue() + fielddata;
+	                	   }
+                	   }
-            berkley
+                	   //System.out.println("fieldname: " + fieldname + " fielddata: " + fielddata);
             berkley
-            sgarg
+                       value.append("<param name=\"");
                        value.append(fieldname);
                        value.append("\">");
                        value.append(fielddata);
                        value.append("</param>");
                        //set returnvalue
                        returnValue.setDocid(docid);
                        returnValue.setFieldValue(fielddata);
-            leinfelder
+                       returnValue.setFieldType(fieldtype);
-            sgarg
+                       returnValue.setXMLFieldValue(value.toString());
                        // Store it in hastable
                        putInArray(parentidList, parentId, returnValue);
+                   }
                    else {
             berkley
-            sgarg
+                       // need to merge nodedata if they have same parent id and
                        // node type is text
                        fielddata = (String) ( (ReturnFieldValue)
                                              getArrayValue(
                            parentidList, parentId)).getFieldValue()
                            + fielddata;
-            berkley
+                       //System.out.println("fieldname: " + fieldname + " fielddata: " + fielddata);
-            sgarg
+                       value.append("<param name=\"");
                        value.append(fieldname);
                        value.append("\">");
                        value.append(fielddata);
                        value.append("</param>");
                        returnValue.setDocid(docid);
                        returnValue.setFieldValue(fielddata);
-            leinfelder
+                       returnValue.setFieldType(fieldtype);
-            sgarg
+                       returnValue.setXMLFieldValue(value.toString());
                        // remove the old return value from paretnidList
                        parentidList.remove(parentId);
                        // store the new return value in parentidlit
                        putInArray(parentidList, parentId, returnValue);
+                   }
                    tableHasRows = rs.next();
                } //while
                rs.close();
                pstmt.close();
             sgarg
-            sgarg
+               // put the merger node data info into doclistReult
                Enumeration xmlFieldValue = (getElements(parentidList)).
                    elements();
                while (xmlFieldValue.hasMoreElements()) {
                    ReturnFieldValue object =
                        (ReturnFieldValue) xmlFieldValue.nextElement();
                    docid = object.getDocid();
-            berkley
+                   if (docListResult.containsDocid(docid)) {
-            sgarg
+                       String removedelement = (String) docListResult.
                            remove(docid);
                        docListResult.
-            berkley
+                           addResultDocument(new ResultDocument(docid,
                                removedelement + object.getXMLFieldValue()));
             sgarg
                    else {
-            berkley
+                       docListResult.addResultDocument(
                          new ResultDocument(docid, object.getXMLFieldValue()));
             sgarg
                } //while
-            daigle
+//               double docListResultEnd = System.currentTimeMillis() / 1000;
 //               logMetacat.warn(
 //                   "Time to prepare ResultDocumentSet after"
 //                   + " execute extended query: "
 //                   + (docListResultEnd - extendedQueryEnd));
             sgarg
-            tao
+       }//if doclist lenght is great than zero
      }//if has extended query
             sgarg
-            tao
+      return docListResult;
     }//addReturnfield
             sgarg
             tao
-            tao
+  /**
    * removes the <?xml version="1.0"?> tag from the beginning.  This takes a
    * string as a param instead of a hashtable.
+   *
    * @param xmlquery a string representing a query.
    */
    private  String transformQuery(String xmlquery)
+   {
      xmlquery = xmlquery.trim();
      int index = xmlquery.indexOf("?>");
      if (index != -1)
+     {
        return xmlquery.substring(index + 2, xmlquery.length());
+     }
      else
+     {
        return xmlquery;
+     }
+   }
             tao
    /*
-            tao
+    * Method to store query string and result xml string into query result
-            tao
+    * cache. If the size alreay reache the limitation, the cache will be
     * cleared first, then store them.
     */
-            tao
+   private void storeQueryResultIntoCache(String query, String resultXML)
             tao
 	   synchronized (queryResultCache)
+	   {
 		   if (queryResultCache.size() >= QUERYRESULTCACHESIZE)
+		   {
 			   queryResultCache.clear();
+		   }
-            tao
+		   queryResultCache.put(query, resultXML);
             tao
+	   }
+   }
    /*
-            tao
+    * Method to get result xml string from query result cache.
     * Note: the returned string can be null.
-            tao
+    */
-            tao
+   private String getResultXMLFromCache(String query)
             tao
-            tao
+	   String resultSet = null;
-            tao
+	   synchronized (queryResultCache)
+	   {
           try
+          {
-            daigle
+        	 logMetacat.info("DBQuery.getResultXMLFromCache - Get query from cache");
-            tao
+		     resultSet = (String)queryResultCache.get(query);
             tao
+          }
           catch (Exception e)
+          {
         	  resultSet = null;
+          }
+	   }
 	   return resultSet;
+   }
    /**
     * Method to clear the query result cache.
     */
    public static void clearQueryResultCache()
+   {
 	   synchronized (queryResultCache)
+	   {
 		   queryResultCache.clear();
+	   }
+   }
             tao
-            jones
+    /*
      * A method to search if Vector contains a particular key string
      */
     private boolean containsKey(Vector parentidList, String parentId)
+    {
             sgarg
-            jones
+        Vector tempVector = null;
             sgarg
-            jones
+        for (int count = 0; count < parentidList.size(); count++) {
             tempVector = (Vector) parentidList.get(count);
-            sgarg
+            if (parentId.compareTo((String) tempVector.get(0)) == 0) { return true; }
             jones
         return false;
             sgarg
             leinfelder
-            jones
+    /*
      * A method to put key and value in Vector
      */
     private void putInArray(Vector parentidList, String key,
             ReturnFieldValue value)
+    {
             sgarg
-            jones
+        Vector tempVector = null;
-            leinfelder
+        //only filter if the field type is NOT an attribute (say, for text)
         String fieldType = value.getFieldType();
         if (fieldType != null && !fieldType.equals("ATTRIBUTE")) {
 	        for (int count = 0; count < parentidList.size(); count++) {
 	            tempVector = (Vector) parentidList.get(count);
 	            if (key.compareTo((String) tempVector.get(0)) == 0) {
 	                tempVector.remove(1);
 	                tempVector.add(1, value);
 	                return;
+	            }
+	        }
             jones
             sgarg
-            jones
+        tempVector = new Vector();
         tempVector.add(0, key);
         tempVector.add(1, value);
         parentidList.add(tempVector);
         return;
             sgarg
-            jones
+    /*
      * A method to get value in Vector given a key
      */
     private ReturnFieldValue getArrayValue(Vector parentidList, String key)
             tao
             sgarg
-            jones
+        Vector tempVector = null;
             sgarg
-            berkley
+        for (int count = 0; count < parentidList.size(); count++) {
-            jones
+            tempVector = (Vector) parentidList.get(count);
             sgarg
-            berkley
+            if (key.compareTo((String) tempVector.get(0)) == 0) { return (ReturnFieldValue) tempVector
                     .get(1); }
             jones
         return null;
             tao
             berkley
-            jones
+    /*
      * A method to get enumeration of all values in Vector
      */
     private Vector getElements(Vector parentidList)
             berkley
-            sgarg
+        Vector enumVector = new Vector();
-            jones
+        Vector tempVector = null;
             sgarg
-            jones
+        for (int count = 0; count < parentidList.size(); count++) {
             tempVector = (Vector) parentidList.get(count);
             jones
-            sgarg
+            enumVector.add(tempVector.get(1));
             jones
-            sgarg
+        return enumVector;
             berkley
             sgarg
             tao
             sgarg
-            jones
+    /*
      * A method to create a query to get owner's docid list
      */
     private String getOwnerQuery(String owner)
             berkley
-            jones
+        if (owner != null) {
             owner = owner.toLowerCase();
+        }
         StringBuffer self = new StringBuffer();
             sgarg
-            jones
+        self.append("SELECT docid,docname,doctype,");
         self.append("date_created, date_updated, rev ");
         self.append("FROM xml_documents WHERE docid IN (");
         self.append("(");
         self.append("SELECT DISTINCT docid FROM xml_nodes WHERE \n");
         self.append("nodedata LIKE '%%%' ");
         self.append(") \n");
         self.append(") ");
         self.append(" AND (");
         self.append(" lower(user_owner) = '" + owner + "'");
         self.append(") ");
         return self.toString();
             berkley
             sgarg
-            jones
+    /**
      * 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
             tao
-            jones
+     * @param params The list of parameters that should be included in the
      *            query
      */
-            daigle
+    public static String createSQuery(Hashtable params) throws PropertyNotFoundException
             berkley
-            jones
+        StringBuffer query = new StringBuffer();
         Enumeration elements;
         Enumeration keys;
         String filterDoctype = null;
         String casesensitive = null;
         String searchmode = null;
         Object nextkey;
         Object nextelement;
         //add the xml headers
         query.append("<?xml version=\"1.0\"?>\n");
-            tao
+        query.append("<pathquery version=\"1.2\">\n");
             berkley
             tao
-            jones
+        if (params.containsKey("meta_file_id")) {
             query.append("<meta_file_id>");
             query.append(((String[]) params.get("meta_file_id"))[0]);
             query.append("</meta_file_id>");
             berkley
             sgarg
-            jones
+        if (params.containsKey("returndoctype")) {
             String[] returnDoctypes = ((String[]) params.get("returndoctype"));
             for (int i = 0; i < returnDoctypes.length; i++) {
                 String doctype = (String) returnDoctypes[i];
             jones
-            jones
+                if (!doctype.equals("any") && !doctype.equals("ANY")
                         && !doctype.equals("")) {
                     query.append("<returndoctype>").append(doctype);
                     query.append("</returndoctype>");
+                }
+            }
+        }
             jones
-            jones
+        if (params.containsKey("filterdoctype")) {
             String[] filterDoctypes = ((String[]) params.get("filterdoctype"));
             for (int i = 0; i < filterDoctypes.length; i++) {
                 query.append("<filterdoctype>").append(filterDoctypes[i]);
                 query.append("</filterdoctype>");
+            }
+        }
             jones
-            jones
+        if (params.containsKey("returnfield")) {
             String[] returnfield = ((String[]) params.get("returnfield"));
             for (int i = 0; i < returnfield.length; i++) {
                 query.append("<returnfield>").append(returnfield[i]);
                 query.append("</returnfield>");
+            }
+        }
             sgarg
-            jones
+        if (params.containsKey("owner")) {
             String[] owner = ((String[]) params.get("owner"));
             for (int i = 0; i < owner.length; i++) {
                 query.append("<owner>").append(owner[i]);
                 query.append("</owner>");
+            }
+        }
             jones
-            jones
+        if (params.containsKey("site")) {
             String[] site = ((String[]) params.get("site"));
             for (int i = 0; i < site.length; i++) {
                 query.append("<site>").append(site[i]);
                 query.append("</site>");
+            }
+        }
             sgarg
-            jones
+        //allows the dynamic switching of boolean operators
         if (params.containsKey("operator")) {
             query.append("<querygroup operator=\""
                     + ((String[]) params.get("operator"))[0] + "\">");
         } else { //the default operator is UNION
             query.append("<querygroup operator=\"UNION\">");
+        }
             tao
-            jones
+        if (params.containsKey("casesensitive")) {
             casesensitive = ((String[]) params.get("casesensitive"))[0];
         } else {
             casesensitive = "false";
+        }
             sgarg
-            jones
+        if (params.containsKey("searchmode")) {
             searchmode = ((String[]) params.get("searchmode"))[0];
         } else {
             searchmode = "contains";
             tao
-            jones
+        //anyfield is a special case because it does a
         //free text search. It does not have a <pathexpr>
         //tag. This allows for a free text search within the structured
         //query. This is useful if the INTERSECT operator is used.
         if (params.containsKey("anyfield")) {
             String[] anyfield = ((String[]) params.get("anyfield"));
             //allow for more than one value for anyfield
             for (int i = 0; i < anyfield.length; i++) {
-            berkley
+                if (anyfield[i] != null && !anyfield[i].equals("")) {
-            jones
+                    query.append("<queryterm casesensitive=\"" + casesensitive
                             + "\" " + "searchmode=\"" + searchmode
                             + "\"><value>" + anyfield[i]
                             + "</value></queryterm>");
+                }
+            }
             tao
             sgarg
-            jones
+        //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();
             sgarg
-            jones
+            //make sure we aren't querying for any of these
             //parameters since the are already in the query
             //in one form or another.
             Vector ignoredParams = new Vector();
             ignoredParams.add("returndoctype");
             ignoredParams.add("filterdoctype");
             ignoredParams.add("action");
             ignoredParams.add("qformat");
             ignoredParams.add("anyfield");
             ignoredParams.add("returnfield");
             ignoredParams.add("owner");
             ignoredParams.add("site");
             ignoredParams.add("operator");
-            tao
+            ignoredParams.add("sessionid");
-            berkley
+            ignoredParams.add("pagesize");
             ignoredParams.add("pagestart");
-            berkley
+            ignoredParams.add("searchmode");
             sgarg
-            jones
+            // Also ignore parameters listed in the properties file
             // so that they can be passed through to stylesheets
-            daigle
+            String paramsToIgnore = PropertyService
-            daigle
+                    .getProperty("database.queryignoredparams");
-            jones
+            StringTokenizer st = new StringTokenizer(paramsToIgnore, ",");
             while (st.hasMoreTokens()) {
                 ignoredParams.add(st.nextToken());
+            }
             if (!ignoredParams.contains(nextkey.toString())) {
                 //allow for more than value per field name
                 for (int i = 0; i < ((String[]) nextelement).length; i++) {
                     if (!((String[]) nextelement)[i].equals("")) {
                         query.append("<queryterm casesensitive=\""
                                 + casesensitive + "\" " + "searchmode=\""
-            tao
+                                + searchmode + "\">" + "<value>" +
-            jones
+                                //add the query value
                                 ((String[]) nextelement)[i]
-            tao
+                                + "</value><pathexpr>" +
-            jones
+                                //add the path to query by
                                 nextkey.toString() + "</pathexpr></queryterm>");
+                    }
+                }
+            }
+        }
         query.append("</querygroup></pathquery>");
         //append on the end of the xml and return the result as a string
         return query.toString();
+    }
             sgarg
-            jones
+    /**
      * 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
             tao
-            jones
+     * @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)
             tao
-            jones
+        StringBuffer xmlquery = new StringBuffer();
         xmlquery.append("<?xml version=\"1.0\"?>\n");
         xmlquery.append("<pathquery version=\"1.0\">");
             sgarg
-            jones
+        if (!doctype.equals("any") && !doctype.equals("ANY")) {
             xmlquery.append("<returndoctype>");
             xmlquery.append(doctype).append("</returndoctype>");
+        }
             sgarg
-            jones
+        xmlquery.append("<querygroup operator=\"UNION\">");
         //chad added - 8/14
         //the if statement allows a query to gracefully handle a null
         //query. Without this if a nullpointerException is thrown.
         if (!value.equals("")) {
             xmlquery.append("<queryterm casesensitive=\"false\" ");
             xmlquery.append("searchmode=\"contains\">");
             xmlquery.append("<value>").append(value).append("</value>");
             xmlquery.append("</queryterm>");
             tao
-            jones
+        xmlquery.append("</querygroup>");
         xmlquery.append("</pathquery>");
             sgarg
-            jones
+        return (xmlquery.toString());
+    }
             sgarg
-            jones
+    /**
      * 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
             tao
-            jones
+     * @param value the text string to search for in the xml catalog
      */
     public static String createQuery(String value)
             tao
-            jones
+        return createQuery(value, "any");
             tao
             sgarg
-            jones
+    /**
      * Check for "READ" permission on @docid for @user and/or @group from DB
      * connection
      */
     private boolean hasPermission(String user, String[] groups, String docid)
             throws SQLException, Exception
             tao
-            jones
+        // Check for READ permission on @docid for @user and/or @groups
         PermissionController controller = new PermissionController(docid);
         return controller.hasPermission(user, groups,
                 AccessControlInterface.READSTRING);
+    }
             sgarg
-            jones
+    /**
      * Get all docIds list for a data packadge
             tao
-            jones
+     * @param dataPackageDocid, the string in docId field of xml_relation table
      */
     private Vector getCurrentDocidListForDataPackage(String dataPackageDocid)
             tao
-            jones
+        DBConnection dbConn = null;
         int serialNumber = -1;
         Vector docIdList = new Vector();//return value
         PreparedStatement pStmt = null;
         ResultSet rs = null;
         String docIdInSubjectField = null;
         String docIdInObjectField = null;
             sgarg
-            jones
+        // Check the parameter
         if (dataPackageDocid == null || dataPackageDocid.equals("")) { return docIdList; }//if
             tao
-            jones
+        //the query stirng
         String query = "SELECT subject, object from xml_relation where docId = ?";
         try {
             dbConn = DBConnectionPool
                     .getDBConnection("DBQuery.getCurrentDocidListForDataPackage");
             serialNumber = dbConn.getCheckOutSerialNumber();
             pStmt = dbConn.prepareStatement(query);
             //bind the value to query
             pStmt.setString(1, dataPackageDocid);
             sgarg
-            jones
+            //excute the query
             pStmt.execute();
             //get the result set
             rs = pStmt.getResultSet();
             //process the result
             while (rs.next()) {
                 //In order to get the whole docIds in a data packadge,
                 //we need to put the docIds of subject and object field in
                 // xml_relation
                 //into the return vector
                 docIdInSubjectField = rs.getString(1);//the result docId in
                                                       // subject field
                 docIdInObjectField = rs.getString(2);//the result docId in
                                                      // object field
             tao
-            jones
+                //don't put the duplicate docId into the vector
                 if (!docIdList.contains(docIdInSubjectField)) {
                     docIdList.add(docIdInSubjectField);
+                }
             sgarg
-            jones
+                //don't put the duplicate docId into the vector
                 if (!docIdList.contains(docIdInObjectField)) {
                     docIdList.add(docIdInObjectField);
+                }
             }//while
             //close the pStmt
             pStmt.close();
         }//try
         catch (SQLException e) {
-            daigle
+            logMetacat.error("DBQuery.getCurrentDocidListForDataPackage - Error in getDocidListForDataPackage: "
-            sgarg
+                    + e.getMessage());
-            jones
+        }//catch
         finally {
             try {
                 pStmt.close();
             }//try
             catch (SQLException ee) {
-            daigle
+                logMetacat.error("DBQuery.getCurrentDocidListForDataPackage - SQL Error: "
-            sgarg
+                                + ee.getMessage());
-            jones
+            }//catch
             finally {
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
             }//fianlly
         }//finally
         return docIdList;
     }//getCurrentDocidListForDataPackadge()
             sgarg
-            jones
+    /**
      * Get all docIds list for a data packadge
             tao
-            jones
+     * @param dataPackageDocid, the string in docId field of xml_relation table
      */
-            tao
+    private Vector getOldVersionDocidListForDataPackage(String dataPackageDocidWithRev)
             tao
             sgarg
-            jones
+        Vector docIdList = new Vector();//return value
         Vector tripleList = null;
         String xml = null;
             sgarg
-            jones
+        // Check the parameter
-            tao
+        if (dataPackageDocidWithRev == null || dataPackageDocidWithRev.equals("")) { return docIdList; }//if
             sgarg
-            jones
+        try {
             //initial a documentImpl object
-            tao
+            DocumentImpl packageDocument = new DocumentImpl(dataPackageDocidWithRev);
-            jones
+            //transfer to documentImpl object to string
             xml = packageDocument.toString();
             sgarg
-            jones
+            //create a tripcollection object
             TripleCollection tripleForPackage = new TripleCollection(
                     new StringReader(xml));
             //get the vetor of triples
             tripleList = tripleForPackage.getCollection();
             sgarg
-            jones
+            for (int i = 0; i < tripleList.size(); i++) {
                 //put subject docid into docIdlist without duplicate
                 if (!docIdList.contains(((Triple) tripleList.elementAt(i))
                         .getSubject())) {
                     //put subject docid into docIdlist
                     docIdList.add(((Triple) tripleList.get(i)).getSubject());
+                }
                 //put object docid into docIdlist without duplicate
                 if (!docIdList.contains(((Triple) tripleList.elementAt(i))
                         .getObject())) {
                     docIdList.add(((Triple) (tripleList.get(i))).getObject());
+                }
             }//for
         }//try
         catch (Exception e) {
-            daigle
+            logMetacat.error("DBQuery.getCurrentDocidListForDataPackage - General error: "
-            sgarg
+                    + e.getMessage());
-            jones
+        }//catch
             sgarg
-            jones
+        // return result
         return docIdList;
     }//getDocidListForPackageInXMLRevisions()
             sgarg
-            jones
+    /**
      * Check if the docId is a data packadge id. If the id is a data packadage
      * id, it should be store in the docId fields in xml_relation table. So we
      * can use a query to get the entries which the docId equals the given
      * value. If the result is null. The docId is not a packadge id. Otherwise,
      * it is.
             tao
-            jones
+     * @param docId, the id need to be checked
      */
     private boolean isDataPackageId(String docId)
             tao
-            jones
+        boolean result = false;
         PreparedStatement pStmt = null;
         ResultSet rs = null;
         String query = "SELECT docId from xml_relation where docId = ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             dbConn = DBConnectionPool
                     .getDBConnection("DBQuery.isDataPackageId");
             serialNumber = dbConn.getCheckOutSerialNumber();
             pStmt = dbConn.prepareStatement(query);
             //bind the value to query
             pStmt.setString(1, docId);
             //execute the query
             pStmt.execute();
             rs = pStmt.getResultSet();
             //process the result
             if (rs.next()) //There are some records for the id in docId fields
+            {
                 result = true;//It is a data packadge id
+            }
             pStmt.close();
         }//try
         catch (SQLException e) {
-            daigle
+            logMetacat.error("DBQuery.isDataPackageId - SQL Error: "
-            sgarg
+                    + e.getMessage());
-            jones
+        } finally {
             try {
                 pStmt.close();
             }//try
             catch (SQLException ee) {
-            daigle
+                logMetacat.error("DBQuery.isDataPackageId - SQL Error in isDataPackageId: "
-            sgarg
+                        + ee.getMessage());
-            jones
+            }//catch
             finally {
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
             }//finally
         }//finally
         return result;
     }//isDataPackageId()
             sgarg
-            leinfelder
+    public String getOperator() {
 		return operator;
+	}
-            jones
+    /**
-            leinfelder
+     * Specifies if and how docid overrides should be included in the general query
      * @param operator null, UNION, or INTERSECT (see QueryGroup)
      */
 	public void setOperator(String operator) {
 		this.operator = operator;
+	}
 	/**
-            jones
+     * Check if the user has the permission to export data package
             tao
-            jones
+     * @param conn, the connection
      * @param docId, the id need to be checked
      * @param user, the name of user
      * @param groups, the user's group
      */
     private boolean hasPermissionToExportPackage(String docId, String user,
             String[] groups) throws Exception
             tao
-            jones
+        //DocumentImpl doc=new DocumentImpl(conn,docId);
         return DocumentImpl.hasReadPermission(user, groups, docId);
+    }
             sgarg
-            jones
+    /**
      * Get the current Rev for a docid in xml_documents table
             tao
-            jones
+     * @param docId, the id need to get version numb If the return value is -5,
      *            means no value in rev field for this docid
      */
     private int getCurrentRevFromXMLDoumentsTable(String docId)
             throws SQLException
+    {
         int rev = -5;
         PreparedStatement pStmt = null;
         ResultSet rs = null;
         String query = "SELECT rev from xml_documents where docId = ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             dbConn = DBConnectionPool
                     .getDBConnection("DBQuery.getCurrentRevFromXMLDocumentsTable");
             serialNumber = dbConn.getCheckOutSerialNumber();
             pStmt = dbConn.prepareStatement(query);
             //bind the value to query
             pStmt.setString(1, docId);
             //execute the query
             pStmt.execute();
             rs = pStmt.getResultSet();
             //process the result
             if (rs.next()) //There are some records for rev
+            {
                 rev = rs.getInt(1);
                 ;//It is the version for given docid
             } else {
                 rev = -5;
+            }
             sgarg
-            tao
+        }//try
-            jones
+        catch (SQLException e) {
-            daigle
+            logMetacat.error("DBQuery.getCurrentRevFromXMLDoumentsTable - SQL Error: "
-            sgarg
+                            + e.getMessage());
-            jones
+            throw e;
-            tao
+        }//catch
-            jones
+        finally {
             try {
                 pStmt.close();
             }//try
             catch (SQLException ee) {
-            sgarg
+                logMetacat.error(
-            daigle
+                        "DBQuery.getCurrentRevFromXMLDoumentsTable - SQL Error: "
-            sgarg
+                                + ee.getMessage());
-            jones
+            }//catch
             finally {
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
             }//finally
         }//finally
         return rev;
     }//getCurrentRevFromXMLDoumentsTable
             sgarg
-            jones
+    /**
      * put a doc into a zip output stream
             tao
-            jones
+     * @param docImpl, docmentImpl object which will be sent to zip output
      *            stream
      * @param zipOut, zip output stream which the docImpl will be put
      * @param packageZipEntry, the zip entry name for whole package
      */
     private void addDocToZipOutputStream(DocumentImpl docImpl,
             ZipOutputStream zipOut, String packageZipEntry)
             throws ClassNotFoundException, IOException, SQLException,
             McdbException, Exception
+    {
         byte[] byteString = null;
         ZipEntry zEntry = null;
             sgarg
-            leinfelder
+        byteString = docImpl.getBytes();
-            jones
+        //use docId as the zip entry's name
         zEntry = new ZipEntry(packageZipEntry + "/metadata/"
                 + docImpl.getDocID());
         zEntry.setSize(byteString.length);
         zipOut.putNextEntry(zEntry);
         zipOut.write(byteString, 0, byteString.length);
         zipOut.closeEntry();
             sgarg
-            jones
+    }//addDocToZipOutputStream()
             tao
-            jones
+    /**
      * Transfer a docid vetor to a documentImpl vector. The documentImpl vetor
      * only inlcudes current version. If a DocumentImple object couldn't find
      * for a docid, then the String of this docid was added to vetor rather
      * than DocumentImple object.
             tao
-            jones
+     * @param docIdList, a vetor hold a docid list for a data package. In
      *            docid, there is not version number in it.
      */
             sgarg
-            jones
+    private Vector getCurrentAllDocumentImpl(Vector docIdList)
             throws McdbException, Exception
             tao
-            jones
+        //Connection dbConn=null;
         Vector documentImplList = new Vector();
         int rev = 0;
             sgarg
-            jones
+        // Check the parameter
         if (docIdList.isEmpty()) { return documentImplList; }//if
             sgarg
-            jones
+        //for every docid in vector
         for (int i = 0; i < docIdList.size(); i++) {
             try {
                 //get newest version for this docId
                 rev = getCurrentRevFromXMLDoumentsTable((String) docIdList
                         .elementAt(i));
             tao
-            jones
+                // There is no record for this docId in xml_documents table
                 if (rev == -5) {
                     // Rather than put DocumentImple object, put a String
                     // Object(docid)
                     // into the documentImplList
                     documentImplList.add((String) docIdList.elementAt(i));
                     // Skip other code
                     continue;
+                }
             sgarg
-            jones
+                String docidPlusVersion = ((String) docIdList.elementAt(i))
-            daigle
+                        + PropertyService.getProperty("document.accNumSeparator") + rev;
             sgarg
-            jones
+                //create new documentImpl object
                 DocumentImpl documentImplObject = new DocumentImpl(
                         docidPlusVersion);
                 //add them to vector
                 documentImplList.add(documentImplObject);
             }//try
             catch (Exception e) {
-            daigle
+                logMetacat.error("DBQuery.getCurrentAllDocumentImpl - General error: "
-            sgarg
+                        + e.getMessage());
-            jones
+                // continue the for loop
                 continue;
+            }
         }//for
         return documentImplList;
+    }
             sgarg
-            jones
+    /**
      * Transfer a docid vetor to a documentImpl vector. If a DocumentImple
      * object couldn't find for a docid, then the String of this docid was
      * added to vetor rather than DocumentImple object.
             tao
-            jones
+     * @param docIdList, a vetor hold a docid list for a data package. In
      *            docid, t here is version number in it.
      */
     private Vector getOldVersionAllDocumentImpl(Vector docIdList)
+    {
         //Connection dbConn=null;
         Vector documentImplList = new Vector();
         String siteCode = null;
         String uniqueId = null;
         int rev = 0;
             sgarg
-            jones
+        // Check the parameter
         if (docIdList.isEmpty()) { return documentImplList; }//if
             sgarg
-            jones
+        //for every docid in vector
         for (int i = 0; i < docIdList.size(); i++) {
             sgarg
-            jones
+            String docidPlusVersion = (String) (docIdList.elementAt(i));
             try {
                 //create new documentImpl object
                 DocumentImpl documentImplObject = new DocumentImpl(
                         docidPlusVersion);
                 //add them to vector
                 documentImplList.add(documentImplObject);
             }//try
             catch (McdbDocNotFoundException notFoundE) {
-            daigle
+                logMetacat.error("DBQuery.getOldVersionAllDocument - Error finding doc "
                 		+ docidPlusVersion + " : " + notFoundE.getMessage());
-            jones
+                // Rather than add a DocumentImple object into vetor, a String
                 // object
                 // - the doicd was added to the vector
                 documentImplList.add(docidPlusVersion);
                 // Continue the for loop
                 continue;
             }//catch
             catch (Exception e) {
-            sgarg
+                logMetacat.error(
-            daigle
+                        "DBQuery.getOldVersionAllDocument - General error: "
-            sgarg
+                                + e.getMessage());
-            jones
+                // Continue the for loop
                 continue;
             }//catch
         }//for
         return documentImplList;
     }//getOldVersionAllDocumentImple
     /**
      * put a data file into a zip output stream
             tao
-            jones
+     * @param docImpl, docmentImpl object which will be sent to zip output
      *            stream
      * @param zipOut, the zip output stream which the docImpl will be put
      * @param packageZipEntry, the zip entry name for whole package
      */
     private void addDataFileToZipOutputStream(DocumentImpl docImpl,
             ZipOutputStream zipOut, String packageZipEntry)
             throws ClassNotFoundException, IOException, SQLException,
             McdbException, Exception
             tao
-            jones
+        byte[] byteString = null;
         ZipEntry zEntry = null;
         // this is data file; add file to zip
-            daigle
+        String filePath = PropertyService.getProperty("application.datafilepath");
-            jones
+        if (!filePath.endsWith("/")) {
             filePath += "/";
+        }
         String fileName = filePath + docImpl.getDocID();
         zEntry = new ZipEntry(packageZipEntry + "/data/" + docImpl.getDocID());
         zipOut.putNextEntry(zEntry);
         FileInputStream fin = null;
         try {
             fin = new FileInputStream(fileName);
             byte[] buf = new byte[4 * 1024]; // 4K buffer
             int b = fin.read(buf);
             while (b != -1) {
                 zipOut.write(buf, 0, b);
                 b = fin.read(buf);
             }//while
             zipOut.closeEntry();
         }//try
         catch (IOException ioe) {
-            daigle
+            logMetacat.error("DBQuery.addDataFileToZipOutputStream - I/O error: "
-            sgarg
+                    + ioe.getMessage());
-            jones
+        }//catch
     }//addDataFileToZipOutputStream()
             sgarg
-            jones
+    /**
      * create a html summary for data package and put it into zip output stream
             tao
-            jones
+     * @param docImplList, the documentImpl ojbects in data package
      * @param zipOut, the zip output stream which the html should be put
      * @param packageZipEntry, the zip entry name for whole package
      */
     private void addHtmlSummaryToZipOutputStream(Vector docImplList,
             ZipOutputStream zipOut, String packageZipEntry) throws Exception
+    {
         StringBuffer htmlDoc = new StringBuffer();
         ZipEntry zEntry = null;
         byte[] byteString = null;
         InputStream source;
         DBTransform xmlToHtml;
             sgarg
-            jones
+        //create a DBTransform ojbect
         xmlToHtml = new DBTransform();
         //head of html
         htmlDoc.append("<html><head></head><body>");
         for (int i = 0; i < docImplList.size(); i++) {
             // If this String object, this means it is missed data file
             if ((((docImplList.elementAt(i)).getClass()).toString())
                     .equals("class java.lang.String")) {
             sgarg
-            jones
+                htmlDoc.append("<a href=\"");
                 String dataFileid = (String) docImplList.elementAt(i);
                 htmlDoc.append("./data/").append(dataFileid).append("\">");
                 htmlDoc.append("Data File: ");
                 htmlDoc.append(dataFileid).append("</a><br>");
                 htmlDoc.append("<br><hr><br>");
             tao
-            jones
+            }//if
             else if ((((DocumentImpl) docImplList.elementAt(i)).getDoctype())
                     .compareTo("BIN") != 0) { //this is an xml file so we can
                                               // transform it.
                 //transform each file individually then concatenate all of the
                 //transformations together.
             tao
-            jones
+                //for metadata xml title
                 htmlDoc.append("<h2>");
                 htmlDoc.append(((DocumentImpl) docImplList.elementAt(i))
                         .getDocID());
                 //htmlDoc.append(".");
                 //htmlDoc.append(((DocumentImpl)docImplList.elementAt(i)).getRev());
                 htmlDoc.append("</h2>");
                 //do the actual transform
                 StringWriter docString = new StringWriter();
                 xmlToHtml.transformXMLDocument(((DocumentImpl) docImplList
                         .elementAt(i)).toString(), "-//NCEAS//eml-generic//EN",
-            daigle
+                        "-//W3C//HTML//EN", "html", docString, null, null);
-            jones
+                htmlDoc.append(docString.toString());
                 htmlDoc.append("<br><br><hr><br><br>");
             }//if
             else { //this is a data file so we should link to it in the html
                 htmlDoc.append("<a href=\"");
                 String dataFileid = ((DocumentImpl) docImplList.elementAt(i))
                         .getDocID();
                 htmlDoc.append("./data/").append(dataFileid).append("\">");
                 htmlDoc.append("Data File: ");
                 htmlDoc.append(dataFileid).append("</a><br>");
                 htmlDoc.append("<br><hr><br>");
             }//else
         }//for
         htmlDoc.append("</body></html>");
-            leinfelder
+        // use standard encoding even though the different docs might have use different encodings,
         // the String objects in java should be correct and able to be encoded as the same Metacat default
         byteString = htmlDoc.toString().getBytes(MetaCatServlet.DEFAULT_ENCODING);
-            jones
+        zEntry = new ZipEntry(packageZipEntry + "/metadata.html");
         zEntry.setSize(byteString.length);
         zipOut.putNextEntry(zEntry);
         zipOut.write(byteString, 0, byteString.length);
         zipOut.closeEntry();
         //dbConn.close();
             tao
-            jones
+    }//addHtmlSummaryToZipOutputStream
             tao
-            jones
+    /**
      * put a data packadge into a zip output stream
             tao
-            tao
+     * @param docId, which the user want to put into zip output stream,it has version
-            jones
+     * @param out, a servletoutput stream which the zip output stream will be
      *            put
      * @param user, the username of the user
      * @param groups, the group of the user
      */
     public ZipOutputStream getZippedPackage(String docIdString,
             ServletOutputStream out, String user, String[] groups,
             String passWord) throws ClassNotFoundException, IOException,
             SQLException, McdbException, NumberFormatException, Exception
             tao
-            jones
+        ZipOutputStream zOut = null;
         String elementDocid = null;
         DocumentImpl docImpls = null;
         //Connection dbConn = null;
         Vector docIdList = new Vector();
         Vector documentImplList = new Vector();
         Vector htmlDocumentImplList = new Vector();
         String packageId = null;
         String rootName = "package";//the package zip entry name
             sgarg
-            jones
+        String docId = null;
         int version = -5;
         // Docid without revision
-            daigle
+        docId = DocumentUtil.getDocIdFromString(docIdString);
-            jones
+        // revision number
-            daigle
+        version = DocumentUtil.getVersionFromString(docIdString);
             sgarg
-            jones
+        //check if the reqused docId is a data package id
         if (!isDataPackageId(docId)) {
             sgarg
-            jones
+            /*
              * Exception e = new Exception("The request the doc id "
              * +docIdString+ " is not a data package id");
              */
             tao
-            jones
+            //CB 1/6/03: if the requested docid is not a datapackage, we just
             // zip
             //up the single document and return the zip file.
             if (!hasPermissionToExportPackage(docId, user, groups)) {
             sgarg
-            jones
+                Exception e = new Exception("User " + user
                         + " does not have permission"
                         + " to export the data package " + docIdString);
                 throw e;
+            }
             sgarg
-            tao
+            docImpls = new DocumentImpl(docIdString);
-            jones
+            //checking if the user has the permission to read the documents
             if (DocumentImpl.hasReadPermission(user, groups, docImpls
                     .getDocID())) {
                 zOut = new ZipOutputStream(out);
                 //if the docImpls is metadata
                 if ((docImpls.getDoctype()).compareTo("BIN") != 0) {
                     //add metadata into zip output stream
                     addDocToZipOutputStream(docImpls, zOut, rootName);
                 }//if
                 else {
                     //it is data file
                     addDataFileToZipOutputStream(docImpls, zOut, rootName);
                     htmlDocumentImplList.add(docImpls);
                 }//else
-            tao
+            }//if
             sgarg
-            jones
+            zOut.finish(); //terminate the zip file
             return zOut;
+        }
         // Check the permission of user
         else if (!hasPermissionToExportPackage(docId, user, groups)) {
             Exception e = new Exception("User " + user
                     + " does not have permission"
                     + " to export the data package " + docIdString);
             throw e;
         } else //it is a packadge id
             tao
-            jones
+            //store the package id
             packageId = docId;
             //get current version in database
             int currentVersion = getCurrentRevFromXMLDoumentsTable(packageId);
             //If it is for current version (-1 means user didn't specify
             // revision)
             if ((version == -1) || version == currentVersion) {
                 //get current version number
                 version = currentVersion;
                 //get package zip entry name
                 //it should be docId.revsion.package
-            daigle
+                rootName = packageId + PropertyService.getProperty("document.accNumSeparator")
                         + version + PropertyService.getProperty("document.accNumSeparator")
-            jones
+                        + "package";
                 //get the whole id list for data packadge
                 docIdList = getCurrentDocidListForDataPackage(packageId);
                 //get the whole documentImple object
                 documentImplList = getCurrentAllDocumentImpl(docIdList);
             sgarg
-            tao
+            }//if
-            jones
+            else if (version > currentVersion || version < -1) {
                 throw new Exception("The user specified docid: " + docId + "."
                         + version + " doesn't exist");
             }//else if
             else //for an old version
             tao
             jones
                 rootName = docIdString
-            daigle
+                        + PropertyService.getProperty("document.accNumSeparator") + "package";
-            jones
+                //get the whole id list for data packadge
                 docIdList = getOldVersionDocidListForDataPackage(docIdString);
                 //get the whole documentImple object
                 documentImplList = getOldVersionAllDocumentImpl(docIdList);
-            tao
+            }//else
             tao
-            jones
+            // Make sure documentImplist is not empty
             if (documentImplList.isEmpty()) { throw new Exception(
                     "Couldn't find component for data package: " + packageId); }//if
             sgarg
-            jones
+            zOut = new ZipOutputStream(out);
             //put every element into zip output stream
             for (int i = 0; i < documentImplList.size(); i++) {
                 // if the object in the vetor is String, this means we couldn't
                 // find
                 // the document locally, we need find it remote
                 if ((((documentImplList.elementAt(i)).getClass()).toString())
                         .equals("class java.lang.String")) {
                     // Get String object from vetor
                     String documentId = (String) documentImplList.elementAt(i);
-            daigle
+                    logMetacat.info("DBQuery.getZippedPackage - docid: " + documentId);
-            jones
+                    // Get doicd without revision
-            daigle
+                    String docidWithoutRevision =
                     	DocumentUtil.getDocIdFromString(documentId);
-            daigle
+                    logMetacat.info("DBQuery.getZippedPackage - docidWithoutRevsion: "
-            sgarg
+                            + docidWithoutRevision);
-            jones
+                    // Get revision
-            daigle
+                    String revision =
                     	DocumentUtil.getRevisionStringFromString(documentId);
-            daigle
+                    logMetacat.info("DBQuery.getZippedPackage - revision from docIdentifier: "
-            sgarg
+                            + revision);
-            jones
+                    // Zip entry string
                     String zipEntryPath = rootName + "/data/";
                     // Create a RemoteDocument object
                     RemoteDocument remoteDoc = new RemoteDocument(
                             docidWithoutRevision, revision, user, passWord,
                             zipEntryPath);
                     // Here we only read data file from remote metacat
                     String docType = remoteDoc.getDocType();
                     if (docType != null) {
                         if (docType.equals("BIN")) {
                             // Put remote document to zip output
                             remoteDoc.readDocumentFromRemoteServerByZip(zOut);
                             // Add String object to htmlDocumentImplList
                             String elementInHtmlList = remoteDoc
                                     .getDocIdWithoutRevsion()
-            daigle
+                                    + PropertyService.getProperty("document.accNumSeparator")
-            jones
+                                    + remoteDoc.getRevision();
                             htmlDocumentImplList.add(elementInHtmlList);
                         }//if
                     }//if
             tao
-            jones
+                }//if
                 else {
                     //create a docmentImpls object (represent xml doc) base on
                     // the docId
                     docImpls = (DocumentImpl) documentImplList.elementAt(i);
                     //checking if the user has the permission to read the
                     // documents
                     if (DocumentImpl.hasReadPermission(user, groups, docImpls
                             .getDocID())) {
                         //if the docImpls is metadata
                         if ((docImpls.getDoctype()).compareTo("BIN") != 0) {
                             //add metadata into zip output stream
                             addDocToZipOutputStream(docImpls, zOut, rootName);
                             //add the documentImpl into the vetor which will
                             // be used in html
                             htmlDocumentImplList.add(docImpls);
             sgarg
-            jones
+                        }//if
                         else {
                             //it is data file
                             addDataFileToZipOutputStream(docImpls, zOut,
                                     rootName);
                             htmlDocumentImplList.add(docImpls);
                         }//else
                     }//if
                 }//else
             }//for
             sgarg
-            jones
+            //add html summary file
             addHtmlSummaryToZipOutputStream(htmlDocumentImplList, zOut,
                     rootName);
             zOut.finish(); //terminate the zip file
             //dbConn.close();
             return zOut;
         }//else
     }//getZippedPackage()
             sgarg
-            jones
+    private class ReturnFieldValue
             tao
             sgarg
-            jones
+        private String docid = null; //return field value for this docid
             sgarg
-            jones
+        private String fieldValue = null;
             sgarg
-            jones
+        private String xmlFieldValue = null; //return field value in xml
                                              // format
-            leinfelder
+        private String fieldType = null; //ATTRIBUTE, TEXT...
             jones
         public void setDocid(String myDocid)
+        {
             docid = myDocid;
+        }
         public String getDocid()
+        {
             return docid;
+        }
         public void setFieldValue(String myValue)
+        {
             fieldValue = myValue;
+        }
         public String getFieldValue()
+        {
             return fieldValue;
+        }
         public void setXMLFieldValue(String xml)
+        {
             xmlFieldValue = xml;
+        }
         public String getXMLFieldValue()
+        {
             return xmlFieldValue;
+        }
             leinfelder
         public void setFieldType(String myType)
+        {
             fieldType = myType;
+        }
             jones
-            leinfelder
+        public String getFieldType()
+        {
             return fieldType;
+        }
             tao
             berkley
     /**
      * a class to store one result document consisting of a docid and a document
      */
     private class ResultDocument
+    {
       public String docid;
       public String document;
       public ResultDocument(String docid, String document)
+      {
         this.docid = docid;
         this.document = document;
+      }
+    }
     /**
      * a private class to handle a set of resultDocuments
      */
     private class ResultDocumentSet
+    {
       private Vector docids;
       private Vector documents;
       public ResultDocumentSet()
+      {
         docids = new Vector();
         documents = new Vector();
+      }
       /**
        * adds a result document to the set
        */
       public void addResultDocument(ResultDocument rd)
+      {
         if(rd.docid == null)
-            tao
+          return;
-            berkley
+        if(rd.document == null)
           rd.document = "";
             tao
-            tao
+           docids.addElement(rd.docid);
            documents.addElement(rd.document);
             tao
             berkley
       /**
        * gets an iterator of docids
        */
       public Iterator getDocids()
+      {
         return docids.iterator();
+      }
       /**
        * gets an iterator of documents
        */
       public Iterator getDocuments()
+      {
         return documents.iterator();
+      }
       /**
        * returns the size of the set
        */
       public int size()
+      {
         return docids.size();
+      }
       /**
        * tests to see if this set contains the given docid
        */
-            tao
+      private boolean containsDocid(String docid)
             berkley
         for(int i=0; i<docids.size(); i++)
+        {
           String docid0 = (String)docids.elementAt(i);
           if(docid0.trim().equals(docid.trim()))
+          {
             return true;
+          }
+        }
         return false;
+      }
       /**
        * removes the element with the given docid
        */
       public String remove(String docid)
+      {
         for(int i=0; i<docids.size(); i++)
+        {
           String docid0 = (String)docids.elementAt(i);
           if(docid0.trim().equals(docid.trim()))
+          {
             String returnDoc = (String)documents.elementAt(i);
             documents.remove(i);
             docids.remove(i);
             return returnDoc;
+          }
+        }
         return null;
+      }
       /**
        * add a result document
        */
       public void put(ResultDocument rd)
+      {
         addResultDocument(rd);
+      }
       /**
        * add a result document by components
        */
       public void put(String docid, String document)
+      {
         addResultDocument(new ResultDocument(docid, document));
+      }
       /**
        * get the document part of the result document by docid
        */
       public Object get(String docid)
+      {
         for(int i=0; i<docids.size(); i++)
+        {
           String docid0 = (String)docids.elementAt(i);
           if(docid0.trim().equals(docid.trim()))
+          {
             return documents.elementAt(i);
+          }
+        }
         return null;
+      }
       /**
        * get the document part of the result document by an object
        */
       public Object get(Object o)
+      {
         return get((String)o);
+      }
       /**
        * get an entire result document by index number
        */
       public ResultDocument get(int index)
+      {
         return new ResultDocument((String)docids.elementAt(index),
           (String)documents.elementAt(index));
+      }
       /**
        * return a string representation of this object
        */
       public String toString()
+      {
         String s = "";
         for(int i=0; i<docids.size(); i++)
+        {
           s += (String)docids.elementAt(i) + "\n";
+        }
         return s;
+      }
-            tao
+      /*
        * Set a new document value for a given docid
        */
       public void set(String docid, String document)
+      {
     	   for(int i=0; i<docids.size(); i++)
+           {
              String docid0 = (String)docids.elementAt(i);
              if(docid0.trim().equals(docid.trim()))
+             {
                  documents.set(i, document);
+             }
+           }
+      }
             berkley
             jones

Project

General

Profile

Metacat