Metacat

################################################################################

# set the log level to WARN and the log should be printed to stdout. 

#log4j.threshold=FATAL, ERROR, WARN, INFO

    <servlet-class>edu.ucsb.nceas.metacat.spatial.SldFactory</servlet-class>

  </servlet>

      <servlet-name>gwt</servlet-name>

      <servlet-class>org.kepler.web.service.KeplerServiceServlet</servlet-class>

      <init-param>

        <param-value>true</param-value>

      </init-param>

      <load-on-startup>2</load-on-startup>

    <servlet>

    <load-on-startup>100</load-on-startup>

  </servlet>

        <servlet-name>gwt</servlet-name>

        <url-pattern>/gwt</url-pattern>

    <servlet-mapping>

        <servlet-name>metacat</servlet-name>

        </script>

        <div class="body">

          <!-- This tests to see if there are returned documents,

              if there are not then don't show the query results -->

  <input name="qformat" value="kepler" type="hidden">

  <input name="enableediting" value="false" type="hidden">

  <input name="operator" value="UNION" type="hidden">

  <input name="returnfield" value="entity/@name" type="hidden">

  <input name="returnfield" value="entity/property[@name='karId']/@value" type="hidden">

  <input name="returnfield" value="entity/property[@name='documentation']/property[@name='author']/configure" type="hidden">

      </menu>

  <p>&nbsp;</p>

  <li>

  <br />

    <menu>

    Browse all existing data sets by title.  This operation can slow as the

# End of Harvester properties

######## Spatial section              #########################################

# Comma-seperated list of schemas containing spatial bounding boxes

# name corresponds to the docname stored in xml_documents table

      else

      {

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

        PrintWriter nonout = null;

        StringBuffer xml = createResultDocument(xmlquery, qspec, nonout, user,

                                                groups, useXMLIndex, pagesize, 

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

        {

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

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

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

    //send out a new query

    if (out != null)

                                      int pagesize, int pagestart, String sessionid)

                                      throws Exception

    {

      String query = null;

      int count = 0;

      int index = 0;

      rs = pstmt.executeQuery();

      double queryExecuteTime = System.currentTimeMillis() / 1000;

                    + (queryExecuteTime - startTime));

      boolean tableHasRows = rs.next();

      int currentIndex = 0;

      while (tableHasRows)

      {

        logMetacat.warn("############getting result: " + currentIndex);

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

             && !qspec.isPercentageSearch())

         {

           logMetacat.warn("Back tracing now...");

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

           StringBuffer btBuf = new StringBuffer();

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

            npstmt.execute();

            ResultSet btrs = npstmt.getResultSet();

            boolean hasBtRows = btrs.next();

            while (hasBtRows)

            {

               //there was a backtrackable document found

                if (docid_org == null)

                {

                   logMetacat.info("Docid_org was null.");

                }

                docid = docid_org.trim();

                docname = xmldoc.getDocname();

                doctype = xmldoc.getDoctype();

                createDate = xmldoc.getCreateDate();

                // Store the document id and the root node id

                docListResult.addResultDocument(

                  new ResultDocument(docid, (String) document.toString()));

                currentIndex++;

                logMetacat.warn("$$$$$$$real result: " + docid);

                count++;

              }//while

              npstmt.close();

              btrs.close();

        }

        else if (returndocVec.size() == 0 || returndocVec.contains(doctype))

        {

     rs.close();

     pstmt.close();

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

     if (docListResult.size() != 0)

     {

       handleSubsetResult(qspec,resultsetBuffer, out, docListResult,

                              user, groups,dbconn, useXMLIndex);

     }

     return resultsetBuffer;

    }//findReturnDoclist

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

     if(usage_count > count){

         enterRecords = true;

     }

     if(returnfield_id < 0){

         logMetacat.warn("Error in getting returnfield id from"

                                  + "xml_returnfield table");

     logMetacat.info("size of partOfDoclist before"

                             + " docidsInQueryresultTable(): "

                             + partOfDoclist.size());

     Hashtable queryresultDocList = docidsInQueryresultTable(returnfield_id,

                                                        partOfDoclist, dbconn);

     while (_keys.hasMoreElements()){

         partOfDoclist.remove((String)_keys.nextElement());

     }

     // backup the keys-elements in partOfDoclist to check later

     // if the doc entry is indexed yet

     Hashtable partOfDoclistBackup = new Hashtable();

     //add return fields for the documents in partOfDoclist

     partOfDoclist = addReturnfield(partOfDoclist, qspec, user, groups,

                                        dbconn, useXMLIndex);

     //add relationship part part docid list for the documents in partOfDocList

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

     Iterator keys = partOfDoclist.getDocids();

     String key = null;

     String element = null;

             pstmt.execute();

             pstmt.close();

         }

         // A string with element

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

         //send single element to output

         if (out != null)

         {

         }

         resultset.append(xmlElement);

     }//while

     Enumeration keysE = queryresultDocList.keys();

     while (keysE.hasMoreElements())

     {

            tableHasRows = rs.next();

          }*/

           logMetacat.info( "Time for execute access extended query: "

           String extendedQuery =

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

               rs = pstmt.getResultSet();

               double extendedQueryEnd = System.currentTimeMillis() / 1000;

               logMetacat.info(

                   + (extendedQueryEnd - extendedQueryStart));

               tableHasRows = rs.next();

               while (tableHasRows) {

               } //while

               double docListResultEnd = System.currentTimeMillis() / 1000;

               logMetacat.warn(

                   + (docListResultEnd - extendedQueryEnd));

           }

    StringBuffer document = null;

    double startRelation = System.currentTimeMillis() / 1000;

    Iterator docidkeys = docListResult.getDocids();

    while (docidkeys.hasNext())

    {

      //String connstring =

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

      String connstring = "%docid=";

      pstmt = dbconn.prepareStatement(QuerySpecification

                      .printRelationSQL(docidkey));

      pstmt.execute();

      pstmt.close();

    }//while

    double endRelation = System.currentTimeMillis() / 1000;

                             + (endRelation - startRelation));

    return docListResult;