Metacat

 *    Release: 1.4.0

import java.io.PrintWriter;

import javax.servlet.http.HttpServletResponse;

     *

                //nodelist = queryobj.findDocuments(xml, null, null, useXMLIndex);

     *

     *

    public DBQuery(String parserName)

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

  }

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

      // get query and qformat

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

      xmlquery = transformQuery(xmlquery);

      MetaCatUtil.debugMessage("xmlquery: " + xmlquery, 30);

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

      MetaCatUtil.debugMessage("qformat: " + qformat, 30);

      if (qformat != null && qformat.equals(MetaCatServlet.XMLFORMAT))

      {

        //xml format

        response.setContentType("text/xml");

        createResultDocument(xmlquery, out, user, groups, useXMLIndex);

      }//if

      else

      {

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

        response.setContentType("text/html");

        PrintWriter nonout = null;

        StringBuffer xml =

              createResultDocument(xmlquery, nonout, user, groups, useXMLIndex);

        //transfer the xml to html

        try

        {

         DBTransform trans = new DBTransform();

         response.setContentType("text/html");

         trans.transformXMLDocument(xml.toString(), "-//NCEAS//resultset//EN",

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

                                 sessionid);

        }

        catch(Exception e)

        {

         MetaCatUtil.debugMessage("Error in MetaCatServlet.transformResultset:"

                                +e.getMessage(), 30);

         }

      }//else

  /*

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

   */

  private StringBuffer createResultDocument(String xmlquery, PrintWriter out,

                                            String user, String[] groups,

                                            boolean useXMLIndex)

  {

    DBConnection dbconn = null;

    int serialNumber = -1;

    StringBuffer resultset = new StringBuffer();

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

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

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

    // sent query part out

    if (out != null)

      out.println(resultset.toString());

    try

    {

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

      QuerySpecification qspec = new QuerySpecification(xmlquery,

                   parserName, MetaCatUtil.getOption("accNumSeparator"));

      //checkout the dbconnection

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

      serialNumber = dbconn.getCheckOutSerialNumber();

      //print out the search result

      // search the doc list

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

                                    dbconn, useXMLIndex);

    }//try

    catch (IOException ioe)

       MetaCatUtil.debugMessage("IO error in DBQuery.findDocuments:", 30);

       MetaCatUtil.debugMessage(ioe.getMessage(), 30);

    }

    catch (SQLException e)

    {

      MetaCatUtil.debugMessage("SQL Error in DBQuery.findDocuments: "

                   + e.getMessage(), 30);

    }

    catch (Exception ee)

    {

      MetaCatUtil.debugMessage("Exception in DBQuery.findDocuments: "

                   + ee.getMessage(), 30);

    }

    finally

    {

       DBConnectionPool.returnDBConnection(dbconn, serialNumber);

    }//finally

    String closeRestultset = "</resultset>";

    resultset.append(closeRestultset);

    if (out != null)

    {

      out.println(closeRestultset);

    }

    return resultset;

  }//createResultDocuments

    /*

     * Find the doc list which match the query

     */

    private StringBuffer findResultDoclist(QuerySpecification qspec,

                                      StringBuffer resultsetBuffer,

                                      PrintWriter out,

                                      String user, String[]groups,

                                      DBConnection dbconn, boolean useXMLIndex )

                                      throws Exception

    {

      int offset = 800;

      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;

      String query = qspec.printSQL(useXMLIndex);

      String ownerQuery = getOwnerQuery(user);

      MetaCatUtil.debugMessage("query: " + query, 30);

      //MetaCatUtil.debugMessage("query: "+ownerQuery, 30);

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

        query = query + accessQuery;

        MetaCatUtil.debugMessage(" final query: " + query, 30);

      }

      double startTime = System.currentTimeMillis() / 1000;

      pstmt = dbconn.prepareStatement(query);

      // Execute the SQL query using the JDBC connection

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      double queryExecuteTime = System.currentTimeMillis() / 1000;

      MetaCatUtil.debugMessage("Time for execute query: "

      boolean tableHasRows = rs.next();

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

        // if there are returndocs to match, backtracking can be performed

        // otherwise, just return the document that was hit

        Vector returndocVec = qspec.getReturnDocList();

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

                        && !qspec.isPercentageSearch())

        {

           MetaCatUtil.debugMessage("Back tracing now...", 20);

           String sep = MetaCatUtil.getOption("accNumSeparator");

           StringBuffer btBuf = new StringBuffer();

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

           //build the doctype list for the backtracking sql statement

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

            PreparedStatement npstmt = dbconn.prepareStatement(btBuf.toString());

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

               MetaCatUtil.debugMessage("Getting document for docid: "

                                         + packageDocid, 40);

                try

                {

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

                    xmldoc = new DocumentImpl(packageDocid, false);

                    if (xmldoc == null)

                    {

                       MetaCatUtil.debugMessage("Document was null for: "

                                                + packageDocid, 50);

                }

                catch (Exception e)

                {

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

                                       + "DBQuery.findDocuments: "

                                       + e.getMessage());

                }

                String docid_org = xmldoc.getDocID();

                if (docid_org == null)

                {

                   MetaCatUtil.debugMessage("Docid_org was null.", 40);

                   continue;

                }

                docid = docid_org.trim();

                docname = xmldoc.getDocname();

                doctype = xmldoc.getDoctype();

                createDate = xmldoc.getCreateDate();

                updateDate = xmldoc.getUpdateDate();

                rev = xmldoc.getRev();

                document = new StringBuffer();

                String completeDocid = docid

                completeDocid += rev;

                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)

                {

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

                }

                if (updateDate != null)

                {

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

                }

                // Store the document id and the root node id

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

                count++;

                index++;

                // Get the next package document linked to our hit

                hasBtRows = btrs.next();

              }//while

              npstmt.close();

              btrs.close();

        }

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

        {

           document = new StringBuffer();

           String completeDocid = docid

           completeDocid += rev;

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

           if (docname != null)

           {

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

            }

            if (doctype != null)

            {

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

            }

            if (createDate != null)

            {

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

             }

             if (updateDate != null)

             {

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

             }

              // Store the document id and the root node id

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

              count++;

              index++;

        }//else

        // when doclist reached the offset number, send out doc list and empty

        // the hash table

        if (count == offset)

        {

          //reset count

          count = 0;

          handleSubsetResult(qspec,resultsetBuffer, out, docListResult,

                              user, groups,dbconn, useXMLIndex);

          // reset docListResult

          docListResult = new Hashtable();

        }

       // Advance to the next record in the cursor

       tableHasRows = rs.next();

     }//while

     rs.close();

     pstmt.close();

     //if docListResult is not empty, it need to be sent.

     if (!docListResult.isEmpty())

     {

       handleSubsetResult(qspec,resultsetBuffer, out, docListResult,

                              user, groups,dbconn, useXMLIndex);

     }

     double docListTime = System.currentTimeMillis() / 1000;

     MetaCatUtil.debugMessage("prepare docid list time: "

     MetaCatUtil.debugMessage("total docid is ===== "+index, 30);

     return resultsetBuffer;

    }//findReturnDoclist

    /*

     * Send completed search hashtable(part of reulst)to output stream

     * and buffer into a buffer stream

     */

    private StringBuffer handleSubsetResult(QuerySpecification qspec,

                                           StringBuffer resultset,

                                           PrintWriter out, Hashtable partOfDoclist,

                                           String user, String[]groups,

                                       DBConnection dbconn, boolean useXMLIndex)

                                       throws Exception

   {

     int index =0;

     //add return field

     partOfDoclist = addRetrunfield(partOfDoclist, qspec, user, groups,

                                        dbconn, useXMLIndex );

     //add relationship part part docid list

     partOfDoclist = addRelationship(partOfDoclist, qspec, dbconn, useXMLIndex);

     // send the completed search item to output and store it in a buffer

     String key = null;

     String element = null;

     Enumeration keys = partOfDoclist.keys();

     while (keys.hasMoreElements())

     {

           key = (String) keys.nextElement();

           element = (String)partOfDoclist.get(key);

           // A string with element

           String xmlElement = "  <document>" + element + "</document>";

           //send single element to output

           if (out != null)

           {

             out.println(xmlElement);

             index++;

           }

           else

           {

             index++;

           }

           resultset.append(xmlElement);

      }//while

      MetaCatUtil.debugMessage("total package number is ======= = "+ index, 20);

      return resultset;

   }

    /*

     * A method to add return field to return doclist hash table

     */

    private Hashtable addRetrunfield(Hashtable docListResult,

                                      QuerySpecification qspec,

                                      String user, String[]groups,

                                      DBConnection dbconn, boolean useXMLIndex )

                                      throws Exception

    {

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String docid = null;

      String fieldname = null;

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

        Enumeration keylist = docListResult.keys();

        StringBuffer doclist = new StringBuffer();

        Vector parentidList = new Vector();

        Hashtable returnFieldValue = new Hashtable();

        while (keylist.hasMoreElements())

        {

          doclist.append("'");

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

          doclist.append("',");

        }

        if (doclist.length() > 0)

        {

          Hashtable controlPairs = new Hashtable();

          double extendedQueryStart = System.currentTimeMillis() / 1000;

          doclist.deleteCharAt(doclist.length() - 1); //remove the last comma

          // check if user has permission to see the return field data

          String accessControlSQL =

                 qspec.printAccessControlSQLForReturnField(doclist.toString());

          pstmt = dbconn.prepareStatement(accessControlSQL);

          //increase dbconnection usage count

          dbconn.increaseUsageCount(1);

          pstmt.execute();

          rs = pstmt.getResultSet();

          boolean tableHasRows = rs.next();

          while (tableHasRows)

          {

            long startNodeId = rs.getLong(1);

            long endNodeId = rs.getLong(2);

            controlPairs.put(new Long(startNodeId), new Long(endNodeId));

            tableHasRows = rs.next();

          }

           double extendedAccessQueryEnd = System.currentTimeMillis() / 1000;

           MetaCatUtil.debugMessage( "Time for execute access extended query: "

                          + (extendedAccessQueryEnd - extendedQueryStart),30);

           String extendedQuery =

               qspec.printExtendedSQL(doclist.toString(), controlPairs, useXMLIndex);

           MetaCatUtil.debugMessage("Extended query: " + extendedQuery, 30);

           pstmt = dbconn.prepareStatement(extendedQuery);

           //increase dbconnection usage count

           dbconn.increaseUsageCount(1);

           pstmt.execute();

           rs = pstmt.getResultSet();

           double extendedQueryEnd = System.currentTimeMillis() / 1000;

           MetaCatUtil.debugMessage("Time for execute extended query: "

                           + (extendedQueryEnd - extendedQueryStart), 30);

           tableHasRows = rs.next();

           while (tableHasRows)

           {

               ReturnFieldValue returnValue = new ReturnFieldValue();

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

               fieldname = rs.getString(2);

               fielddata = rs.getString(3);

               fielddata = MetaCatUtil.normalize(fielddata);

               String parentId = rs.getString(4);

               StringBuffer value = new StringBuffer();

               if (!containsKey(parentidList, parentId))

               {

                  // don't need to merger nodedata

                  value.append("<param name=\"");

                  value.append(fieldname);

                  value.append("\">");

                  value.append(fielddata);

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

                  //set returnvalue

                  returnValue.setDocid(docid);

                  returnValue.setFieldValue(fielddata);

                  returnValue.setXMLFieldValue(value.toString());

                  // Store it in hastable

                  putInArray(parentidList, parentId, returnValue);

                }

                else

                {

                  // need to merge nodedata if they have same parent id and

                  // node type is text

                  fielddata = (String) ((ReturnFieldValue) getArrayValue(

                  value.append("<param name=\"");

                  value.append(fieldname);

                  value.append("\">");

                  value.append(fielddata);

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

                  returnValue.setDocid(docid);

                  returnValue.setFieldValue(fielddata);

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

            // put the merger node data info into doclistReult

            Enumeration xmlFieldValue = (getElements(parentidList)).elements();

            while (xmlFieldValue.hasMoreElements())

            {

              ReturnFieldValue object =

                  (ReturnFieldValue) xmlFieldValue.nextElement();

              docid = object.getDocid();

              if (docListResult.containsKey(docid))

              {

                 String removedelement = (String) docListResult.remove(docid);

                 docListResult.

                         put(docid, removedelement+ object.getXMLFieldValue());

              }

              else

              {

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

               }

             }//while

             double docListResultEnd = System.currentTimeMillis() / 1000;

             MetaCatUtil.debugMessage("Time for prepare doclistresult after"

                                       + " execute extended query: "

                                       + (docListResultEnd - extendedQueryEnd),

                                      30);

              // get attribures return

              docListResult = getAttributeValueForReturn(qspec,

       }//if doclist lenght is great than zero

     }//if has extended query

      return docListResult;

    }//addReturnfield

    /*

    * A method to add relationship to return doclist hash table

    */

   private Hashtable addRelationship(Hashtable docListResult,

                                     QuerySpecification qspec,

                                     DBConnection dbconn, boolean useXMLIndex )

                                     throws Exception

  {

    PreparedStatement pstmt = null;

    ResultSet rs = null;

    StringBuffer document = null;

    double startRelation = System.currentTimeMillis() / 1000;

    Enumeration docidkeys = docListResult.keys();

    while (docidkeys.hasMoreElements())

    {

      //String connstring =

      // "metacat://"+util.getOption("server")+"?docid=";

      String connstring = "%docid=";

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

      pstmt = dbconn.prepareStatement(QuerySpecification

                      .printRelationSQL(docidkey));

      pstmt.execute();

      rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      while (tableHasRows)

      {

        String sub = rs.getString(1);

        String rel = rs.getString(2);

        String obj = rs.getString(3);

        String subDT = rs.getString(4);

        String objDT = rs.getString(5);

        document = new StringBuffer();

        document.append("<triple>");

        document.append("<subject>").append(MetaCatUtil.normalize(sub));

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

        if (subDT != null)

        {

          document.append("<subjectdoctype>").append(subDT);

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

        }

        document.append("<relationship>").append(MetaCatUtil.normalize(rel));

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

        document.append("<object>").append(MetaCatUtil.normalize(obj));

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

        if (objDT != null)

        {

          document.append("<objectdoctype>").append(objDT);

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

        }

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

        String removedelement = (String) docListResult.remove(docidkey);

        docListResult.put(docidkey, removedelement+ document.toString());

        tableHasRows = rs.next();

      }//while

      rs.close();

      pstmt.close();

    }//while

    double endRelation = System.currentTimeMillis() / 1000;

    MetaCatUtil.debugMessage("Time for adding relation to docListResult: "

                             + (endRelation - startRelation), 30);

    return docListResult;

  }//addRelation

  /**

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

     }

   }

     *

                                + searchmode + "\">" + "<value>" +

                                + "</value><pathexpr>" +

     *

     *

     *

     *

     *

     *

     *

     *

     *

     *

     *

     *

     *