Metacat

/**

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

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *     '$Date$'

 * '$Revision$'

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringWriter;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.zip.ZipOutputStream;

import javax.xml.parsers.DocumentBuilderFactory;

import org.xml.sax.InputSource;

import org.w3c.dom.ls.*;

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

 * 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

{

    private String parserName = null;

    private final boolean METACAT_SPATIAL = true;

     * the main routine used to test the DBQuery utility.

     * <p>

     * Usage: java DBQuery <xmlfile>

     */

    static public void main(String[] args)

    {

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

            System.err.println("USAGE: java DBQuery [-t] [-index] <xmlfile>");

            return;

        } else {

            try {

                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];

                double startTime = System.currentTimeMillis();

                MetaCatUtil util = new MetaCatUtil();

                //Connection dbconn = util.openDBConnection();

                Hashtable nodelist = null;

                StringBuffer result = new StringBuffer();

                String document = null;

                String docid = null;

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

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

                    Enumeration doclist = nodelist.keys();

                    while (doclist.hasMoreElements()) {

                        docid = (String) doclist.nextElement();

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

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

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

                    }

                }

                // 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");

                    FileWriter fw = new FileWriter(f);

                    BufferedWriter out = new BufferedWriter(fw);

                    out.write(result.toString());

                    out.flush();

                    out.close();

                    fw.close();

                }

                System.err.println("Error in DBQuery.main");

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

                e.printStackTrace(System.err);

            }

        }

    }

     * construct an instance of the DBQuery class

     * Generally, one would call the findDocuments() routine after creating an

     * instance to specify the search query

     * </p>

     *            the org.xml.sax.XMLReader interface

     */

        this.parserName = parserName;

     *

     * 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

     */

    public DBQuery(Vector docids)

    {

        this.docidOverride = docids;

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

        this.parserName = parserName;

    }

  /**

   * 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,

                                       PrintWriter out, Hashtable params,

                                       String user, String[] groups,

                                       String sessionid)

  {

    boolean useXMLIndex = (new Boolean(MetaCatUtil.getOption("usexmlindex")))

               .booleanValue();

    findDocuments(response, out, params, user, groups, sessionid, useXMLIndex);

  }

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

                                         PrintWriter out, Hashtable params,

                                         String user, String[] groups,

                                         String sessionid, boolean useXMLIndex)

      int pagestart = 0;

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

        }

      }

      String xmlquery = ((String[])params.get("query"))[0];

      QuerySpecification qspec = null;

      if ( xmlquery != null)

      {

         xmlquery = transformQuery(xmlquery);

         try

         {

           qspec = new QuerySpecification(xmlquery,

                                          parserName,

                                          MetaCatUtil.getOption("accNumSeparator"));

         }

         catch (Exception ee)

         {

      }

      {

        //xml format

        response.setContentType("text/xml");

          pagesize, pagestart, sessionid);

      else

      {

        //knb format, in this case we will get whole result and sent it out

        response.setContentType("text/html");

        PrintWriter nonout = null;

                                                pagestart, sessionid);

        try

        {

         DBTransform trans = new DBTransform();

         response.setContentType("text/html");

         if(MetaCatUtil.isModerator(user, groups)){

        	 params.put("isModerator", new String[] {"true"});

         }

                                 "-//W3C//HTML//EN", qformat, out, params,

                                 sessionid);

        }

        catch(Exception e)

        {

                                +e.getMessage());

      }//else

  /**

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

   * just those required by the paging params.

   */

  private StringBuffer getPagedResult(MetacatResultSet mrs, int pagestart,

    int pagesize)

  {

    logMetacat.warn(mrs.toString());

    if(pagesize == 0)

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

      return new StringBuffer(mrs.toString());

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

  }

   * Transforms a hashtable of documents to an xml or html result and sent

   * add the QuerySpecification as parameter is for ecogrid. But it is duplicate

   * to xmlquery String

                                            QuerySpecification qspec,

                                            PrintWriter out,

                                            int pagestart, String sessionid)

    DBConnection dbconn = null;

    int serialNumber = -1;

    StringBuffer resultset = new StringBuffer();

    //try to get the cached version first

    Hashtable sessionHash = MetaCatServlet.getSessionHash();

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

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

    if(cachedQuerySpec != null &&

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

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

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

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

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

      //results, return those instead of rerunning the query

      if(mrs != null)

      { //print and return the cached buffer

        StringBuffer pagedResultBuffer = getPagedResult(mrs, pagestart,

          pagesize);

        if(out != null)

        {

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

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

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

          out.println(pagedResultBuffer.toString());

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

        }

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

        returnString += "<resultset>\n";

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

        returnString += pagedResultBuffer.toString();

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

        return new StringBuffer(returnString);

      }

    }

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

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

    resultset.append("  <query>" + xmlquery + "</query>");

      {

        dbconn = DBConnectionPool.getDBConnection("DBQuery.findDocuments");

        serialNumber = dbconn.getCheckOutSerialNumber();

        // search the doc list

        resultset = findResultDoclist(qspec, resultset, out, user, groups,

                                      sessionid);

      catch (IOException ioe)

      {

        logMetacat.error(ioe.getMessage());

      catch (SQLException e)

      {

                                 + e.getMessage());

      catch (Exception ee)

      {

                                 + ee.getMessage());

      finally

      {

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      } //finally

    }//if

    resultset.append(closeRestultset);

    if (out != null)

    {

      out.println(closeRestultset);

    }

    try

    {

      //cache the query result and the query

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

      sess.setAttribute("query", qspec);

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

      sess.setAttribute("results", mrs);

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

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

      returnString += "<resultset>\n";

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

      returnString += pagedResultBuffer.toString();

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

      return new StringBuffer(returnString);

    }

    catch(Exception e)

    {

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

    }

  }//createResultDocuments

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

   * be cached in a reasonable way

   */

  private MetacatResultSet processAndCacheResults(String resultset, HttpSession sess)

    throws Exception

  {

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

    InputSource inputsource = new InputSource(sreader);

    logMetacat.warn("processing DOM");

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

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

    MetacatResultSet mrs = new MetacatResultSet(doc);

    return mrs;

  }

     * Find the doc list which match the query

     */

    private StringBuffer findResultDoclist(QuerySpecification qspec,

                                      StringBuffer resultsetBuffer,

                                      PrintWriter out,

                                      String user, String[]groups,

                                      int pagesize, int pagestart, String sessionid)

    {

      int count = 0;

      int index = 0;

      Hashtable docListResult = new Hashtable();

      PreparedStatement pstmt = null;

      String docid = null;

      String docname = null;

      String doctype = null;

      String createDate = null;

      String updateDate = null;

      StringBuffer document = null;

      int rev = 0;

      double startTime = 0;

      int offset = 1;

      offset = 1;

      if (out == null)

      {

        // for html page, we put everything into one page

            (new Integer(MetaCatUtil.getOption("web_resultsetsize"))).intValue();

      else

      {

          offset =

       * 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

       */

      if ( this.docidOverride.size() == 0 ) {

          query = qspec.printSQL(useXMLIndex);

      } else {

          queryBuffer.append( " FROM xml_documents WHERE docid IN (" );

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

              queryBuffer.append("'");

              queryBuffer.append( (String)docidOverride.elementAt(i) );

              queryBuffer.append("',");

          }

          query = queryBuffer.toString();

      }

      logMetacat.info("\n\n\n owner query: "+ownerQuery);

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

            query = query + accessQuery;

        } else {

            query = query + accessQuery.substring(4, accessQuery.length());

        }

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

      //if they are not 0

      while (tableHasRows)

      {

        docid = rs.getString(1).trim();

        docname = rs.getString(2);

        doctype = rs.getString(3);

        createDate = rs.getString(4);

        updateDate = rs.getString(5);

        rev = rs.getInt(6);

        // otherwise, just return the document that was hit

        Vector returndocVec = qspec.getReturnDocList();

           StringBuffer btBuf = new StringBuffer();

           btBuf.append("select docid from xml_relation where ");

           btBuf.append("packagetype in (");

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

           {

             btBuf.append("'").append((String) returndocVec.get(i)).append("'");

             if (i != (returndocVec.size() - 1))

             {

                btBuf.append(", ");

              }

            }

            btBuf.append(") ");

            btBuf.append("and (subject like '");

            btBuf.append(docid).append("'");

            btBuf.append("or object like '");

            btBuf.append(docid).append("')");

            //should incease usage count

            dbconn.increaseUsageCount(1);

            npstmt.execute();

            ResultSet btrs = npstmt.getResultSet();

            boolean hasBtRows = btrs.next();

            while (hasBtRows)

            {

               //there was a backtrackable document found

               DocumentImpl xmldoc = null;

               String packageDocid = btrs.getString(1);

                                         + packageDocid);

                {

                    //  THIS CONSTRUCTOR BUILDS THE WHOLE XML doc not

                    // needed here

                    // xmldoc = new DocumentImpl(dbconn, packageDocid);

                    //  thus use the following to get the doc info only

                    //  xmldoc = new DocumentImpl(dbconn);

                    DBUtil.getLatestRevisionInDocumentTable(packageDocid);

                    xmldoc = new DocumentImpl(accNumber, false);

                    {

                                                + packageDocid);

                catch (Exception e)

                {

                    System.out.println("Error getting document in "

                                       + "DBQuery.findDocuments: "

                                       + e.getMessage());

                }

                if (docid_org == null)

                {

                docid = docid_org.trim();

                docname = xmldoc.getDocname();

                doctype = xmldoc.getDoctype();

                createDate = xmldoc.getCreateDate();

                updateDate = xmldoc.getUpdateDate();

                rev = xmldoc.getRev();

                document = new StringBuffer();

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

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

                if (docname != null)

                {

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

                }

                if (doctype != null)

                {

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

                }

                if (createDate != null)