Metacat

database.maximumConnectionAge=120000

database.maximumConnectionTime=60000

database.maximumUsageNumber=100

database.numberOfIndexingThreads=5

database.indexingTimerTaskTime=604800000

database.indexingInitialDelay=3600000

database.queryresultCacheSize=500

#turn on or off the query result cache

database.queryCacheOn=true

######## Datamanager section              #######################################

datamanager.adapter=PostgresAdapter

datamanager.implementation=edu.ucsb.nceas.metacat.dataquery.PostgresDatabaseConnectionPool

    	// since the query will be too long to be handled, so we divided the 

    	// docids vector into couple vectors.

    	int size = (new Integer(PropertyService.getProperty("database.appResultsetSize"))).intValue();

    	Vector subset = new Vector();

    	if (docids != null && docids.size() > size)

    	{

    {

      int pagesize = 0;

      int pagestart = 0;

      if(params.containsKey("pagesize") && params.containsKey("pagestart"))

      {

      try {

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

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

      }

      catch (Exception ee)

      {

                  +"params hashtable in DBQuery.findDocuments: "

                  + ee.getMessage()); 

      }

         }

         catch (Exception ee)

         {

                                    + ee.getMessage());

         }

      }

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

          MetacatUtil.writeDebugToFile("---------------------------------------------------------------------------------------------------------------Transfrom xml to html  "

        }

        catch(Exception e)

        {

                                +e.getMessage());

         }

        StringBuffer resultContent = new StringBuffer();

        if (docidOverride == null || docidOverride.size() == 0)

        {

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

                    dbconn, useXMLIndex, pagesize, pagestart, 

                    sessionid, givenDocids);

        }

        else

        {

        	// since docid can be too long to be handled. We divide it into several parts

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

        	{

        		givenDocids = (Vector)docidOverride.elementAt(i);

        		StringBuffer subset = findResultDoclist(qspec, out, user, groups,

                        dbconn, useXMLIndex, pagesize, pagestart, 

      } //try

      catch (IOException ioe)

      {

      }

      catch (SQLException e)

      {

      }

      catch (Exception ee)

      {

                                 + ee.getMessage());

        ee.printStackTrace();

      }

      int rev = 0;

      double startTime = 0;

      int offset = 1;

      ResultSet rs = null;

      if ( givenDocids == null || givenDocids.size() == 0 ) {

          query = qspec.printSQL(useXMLIndex);

      } else {

          StringBuffer queryBuffer = new StringBuffer( "SELECT docid,docname,doctype,date_created, date_updated, rev " );

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

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

      } 

      String ownerQuery = getOwnerQuery(user);

      //logMetacat.debug("query: " + query);

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

        }

      }

      String selectionAndExtendedQuery = null;

      // we only get cache for public

      if (user != null && user.equalsIgnoreCase("public") 

      {

    	  selectionAndExtendedQuery = query +qspec.getReturnDocList()+qspec.getReturnFieldList();

   	      String cachedResult = getResultXMLFromCache(selectionAndExtendedQuery);

   	      //System.out.println("==========the string from cache is "+cachedResult);

   	      if (cachedResult != null)

   	      {

   	    	 if (out != null)

   	         {

   	             out.println(cachedResult);

      rs = pstmt.executeQuery();

      double queryExecuteTime = System.currentTimeMillis() / 1000;

                    + (queryExecuteTime - startTime));

      MetacatUtil.writeDebugToFile("\n\n\n\n\n\nExecute selection query  "

              + (queryExecuteTime - startTime));

      int currentIndex = 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);

         Vector returndocVec = qspec.getReturnDocList();

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

        {

           document = new StringBuffer();

           String completeDocid = docid

           docListResult.addResultDocument(

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

           currentIndex++;

           count++;

        }//else

          docListResult = new ResultDocumentSet();

        }

       if(currentIndex >= ((pagesize * pagestart) + pagesize))

       {

         ResultDocumentSet pagedResultsHash = new ResultDocumentSet();

     rs.close();

     pstmt.close();

     MetacatUtil.writeDebugToFile("---------------------------------------------------------------------------------------------------------------Total selection: "

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

     if (docListResult.size() != 0)

     {

                                       DBConnection dbconn, boolean useXMLIndex)

                                       throws Exception

   {

     // check if there is a record in xml_returnfield

     // and get the returnfield_id and usage count

     int usage_count = getXmlReturnfieldsTableId(qspec, dbconn);

     }

     if(returnfield_id < 0){

                                  + "xml_returnfield table");

         enterRecords = false;

     }

     // get the hashtable containing the docids that already in the

     // xml_queryresult table

                             + " docidsInQueryresultTable(): "

                             + partOfDoclist.size());

     Hashtable queryresultDocList = docidsInQueryresultTable(returnfield_id,

                                                        partOfDoclist, dbconn);

     while (_keys.hasMoreElements()){

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

     }

     MetacatUtil.writeDebugToFile("-----------------------------------------Get fields from xml_queryresult(Part1 in return fields) " +

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

     // if the doc entry is indexed yet

     Hashtable partOfDoclistBackup = new Hashtable();

         partOfDoclistBackup.put(key, partOfDoclist.get(key));

     }

                             + " docidsInQueryresultTable(): "

                             + partOfDoclist.size());

     //add return fields for the documents in partOfDoclist

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

                                        dbconn, useXMLIndex);

     MetacatUtil.writeDebugToFile("-----------------------------------------Get fields from extened query(Part2 in return fields) "

     MetacatUtil.writeDebugToDelimiteredFile(" "

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

             }

             catch(Exception e)

             {

             }

             finally

             {

         resultset.append(xmlElement);

     }//while

     MetacatUtil.writeDebugToFile("-----------------------------------------Insert new record to xml_queryresult(Part4 in return fields) "

     Enumeration keysE = queryresultDocList.keys();

     while (keysE.hasMoreElements())

         }

         resultset.append(xmlElement);

     }//while

     return resultset;

 }

             String query = "select docid, queryresult_string from "

                          + "xml_queryresult where returnfield_id = " +

                          returnfield_id +" and docid in ("+ doclist + ")";

                                      + query);

             try {

                     if(element != null){

                         returnValue.put(key, element);

                     } else {

                         + "DBQuery.docidsInQueryresultTable)");

                     }

                     tableHasRows = rs.next();

                 rs.close();

                 pstmt.close();

             } catch (Exception e){

              }

         }

         return returnValue;

       // query for finding the id from xml_returnfield

       String query = "SELECT returnfield_id, usage_count FROM xml_returnfield "

            + "WHERE returnfield_string LIKE ?";

       try {

           // prepare and run the query

               // increase the usage count

               query = "UPDATE xml_returnfield SET usage_count ='" + count

                   + "' WHERE returnfield_id ='"+ id +"'";

               pstmt = dbconn.prepareStatement(query);

               dbconn.increaseUsageCount(1);

               // insert a new record

               query = "INSERT INTO xml_returnfield (returnfield_string, usage_count)"

                   + "VALUES (?, '1')";

               pstmt = dbconn.prepareStatement(query);

               pstmt.setString(1, returnfield);

               dbconn.increaseUsageCount(1);

               // get the id of the new record

               query = "SELECT returnfield_id FROM xml_returnfield "

                   + "WHERE returnfield_string LIKE ?";

               pstmt = dbconn.prepareStatement(query);

               pstmt.setString(1, returnfield);

           }

       } catch (Exception e){

                                     + "DBQuery.getXmlReturnfieldsTableId: "

                                     + e.getMessage());

           id = -1;

           String extendedQuery =

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

           if(extendedQuery != null){

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

                         new ResultDocument(docid, object.getXMLFieldValue()));

                   }

               } //while

           }

	   {

          try

          {

		     resultSet = (String)queryResultCache.get(query);

          }

            pStmt.close();

        }//try

        catch (SQLException e) {

                    + e.getMessage());

        }//catch

        finally {

                pStmt.close();

            }//try

            catch (SQLException ee) {

                                + ee.getMessage());

            }//catch

            finally {

            }//for

        }//try

        catch (Exception e) {

                    + e.getMessage());

        }//catch

            pStmt.close();

        }//try

        catch (SQLException e) {

                    + e.getMessage());

        } finally {

            try {

                pStmt.close();

            }//try

            catch (SQLException ee) {

                        + ee.getMessage());

            }//catch

            finally {

        }//try

        catch (SQLException e) {

                            + e.getMessage());

            throw e;

        }//catch

            }//try

            catch (SQLException ee) {

                logMetacat.error(

                                + ee.getMessage());

            }//catch

            finally {

                documentImplList.add(documentImplObject);

            }//try

            catch (Exception e) {

                        + e.getMessage());

                // continue the for loop

                continue;

                documentImplList.add(documentImplObject);

            }//try

            catch (McdbDocNotFoundException notFoundE) {

                // Rather than add a DocumentImple object into vetor, a String

                // object

                // - the doicd was added to the vector

            }//catch

            catch (Exception e) {

                logMetacat.error(

                                + e.getMessage());

                // Continue the for loop

                continue;

            zipOut.closeEntry();

        }//try

        catch (IOException ioe) {

                    + ioe.getMessage());

        }//catch

    }//addDataFileToZipOutputStream()

                        .equals("class java.lang.String")) {

                    // Get String object from vetor

                    String documentId = (String) documentImplList.elementAt(i);

                    // Get doicd without revision

                    String docidWithoutRevision = 

                    	DocumentUtil.getDocIdFromString(documentId);

                            + docidWithoutRevision);

                    // Get revision

                    String revision = 

                    	DocumentUtil.getRevisionStringFromString(documentId);

                            + revision);

                    // Zip entry string

                    String zipEntryPath = rootName + "/data/";