Metacat

/**

 *  '$RCSfile$'

 *             constructed from an XML serialization conforming to

 *             pathquery.dtd. The printSQL() method can be used to print

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author$'

 *     '$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

 */

package edu.ucsb.nceas.metacat;

import edu.ucsb.nceas.metacat.util.SystemUtil;

public  class QueryGroup {

    private String operator = null;  // indicates how query terms are combined

    private Vector children = null;  // the list of query terms and groups

    private int countPercentageSearchItem = 0;

                                                  //will hold query terms which has same search value.

                                                                                 // and search path is in path index.

    public static String INTERSECT = "INTERSECT";

     * construct a new QueryGroup

     */

    public QueryGroup(String operator) {

      this.operator = operator;

      children = new Vector();

     *

     * @param qgroup the query group to be added to the list of terms

     */

    public void addChild(QueryGroup qgroup) {

    /**

     * Add a child QueryTerm to this QueryGroup

     *

     * @param qterm the query term to be added to the list of terms

     */

    public void addChild(QueryTerm qterm) {

     */

    }

    {

      return countPercentageSearchItem;

    }

     * create a SQL serialization of the query that this instance represents

     */

    	  List<Object> groupValues = new ArrayList<Object>();

    	  String pathIndexQueryString = printSQLStringInPathIndex(groupValues);

    	  parameterValues.addAll(groupValues);

    	  {

    		  first = false;

    	  }

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

      {

    	  List<Object> childrenValues = new ArrayList<Object>();

    	  // get the group

    	  QueryGroup qg = (QueryGroup) queryGroupsChildren.elementAt(i);

    	  String queryGroupSQL = qg.printSQL(useXMLIndex, childrenValues);

    	  logMetacat.info("In QueryGroup.printSQL.. found a QueryGroup: " + queryGroupSQL);

        		first = false;

        	} else {

        		if(!queryString.toString().equals("") && queryGroupSQL != null &&!queryGroupSQL.equals("")){

        	}

   		  	parameterValues.addAll(childrenValues);

   		  	countPercentageSearchItem = countPercentageSearchItem + count;

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

      {

    	  List<Object> termValues = new ArrayList<Object>();

    	  // get the term

    	  QueryTerm qt = (QueryTerm)queryTerms.elementAt(i);

    	  String termQueryString = qt.printSQL(useXMLIndex, termValues);

    	  logMetacat.info("In QueryGroup.printSQL.. found a QueryGroup: " + termQueryString);

           if (!(qt.getSearchMode().equals("contains") && qt.getValue().equals("%"))){

               } else {

                   if(!queryString.toString().equals("")){

                       queryString.append(" " + operator + " ");

                   }

               }

               parameterValues.addAll(termValues);

           int count = qt.getPercentageSymbolCount();

           countPercentageSearchItem = countPercentageSearchItem + count;

      if(!queryString.toString().equals("")){

          self.append("(");

          self.append(queryString.toString());

          self.append(")");

      }

      logMetacat.info("In QueryGroup.printSQL.. final query returned is: "

			+ self.toString());

    }

     * is in xml_path_index, we should use a new query to replace the original query term query in order to

     * improve performance. Also if even the term doesn't share any value with other term

     * we still use "OR" to replace UNION action (we only handle union operator in the query group).

     *

    	String sql ="";

    	String value ="";

    	StringBuffer sqlBuff = new StringBuffer();

    	int index =0;

    		sqlBuff.append("SELECT DISTINCT docid FROM xml_path_index WHERE ");

    		if (!queryTermsWithSameValue.isEmpty())

	    		for (int j=0; j<queryTermsWithSameValue.size(); j++)

		    		QueryTerm term1 = (QueryTerm)queryTermVector.elementAt(0);

		        	value = term1.getValue();

		        	boolean first = true;

		        	if (firstVector)

		        	{

					  firstVector = false;

		        	}

		        	else

		        	{

		        		sqlBuff.append(" "+"OR"+" ");

		        	}

					sqlBuff.append(" (");

			        List<Object> searchValues = new ArrayList<Object>();

		        	// add the SQL

					parameterValues.addAll(searchValues);

					sqlBuff.append("AND path IN ( ");

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

		    		{

		    			QueryTerm term = (QueryTerm)queryTermVector.elementAt(i);

		    			value = term.getValue();

		    			String path = term.getPathExpression();

		    			if (path != null && !path.equals(""))

		    			{

		    				if (first)

		    				{

		    					first = false;

		    					parameterValues.add(path);

		    				else

		    				{

		    					parameterValues.add(path);

		    				index++;

		     				if (value != null && (value.equals("%") || value.equals("%%%")))

		                    {

		    				  countPercentageSearchItem++;

		                    }

	    			     }

	    		    }

	    	    }

	    	}

    		if (!queryTermsInPathIndex.isEmpty())

    		{

    			for (int j=0; j<queryTermsInPathIndex.size(); j++)

    			{

    				QueryTerm term = (QueryTerm)queryTermsInPathIndex.elementAt(j);

    				if (term != null)

    				{

	    				term.setInUnionGroup(true);

		    			 if (index > 0)

		    			 {

		    				 sqlBuff.append(" "+"OR"+" ");

		    			 }

		    			 sqlBuff.append("(");

		    			 List<Object> termParameterValues = new ArrayList<Object>();

		    			 String termSQL = term.printSQL(true, termParameterValues);

	    				 sqlBuff.append(termSQL);

	    				 parameterValues.addAll(termParameterValues);

	    			}

    			}

    		}

    	if (index >0)

    	{

    		sql = sqlBuff.toString();

    	}

    	return sql;

    }

    /**

     * create a String description of the query that this instance represents.

     * This should become a way to get the XML serialization of the query.

     */

    public String toString() {

      StringBuffer self = new StringBuffer();

      self.append("  (Query group operator=" + operator + "\n");

      Enumeration en= getChildren();

      while (en.hasMoreElements()) {

        Object qobject = en.nextElement();

        self.append(qobject);

      }

      self.append("  )\n");

      return self.toString();

    }

    /*

     * When a new QueryTerm come, first we need to compare it to

     * the queryTerm vector, which contains queryTerm that doesn't

     * have same search value to any other queryTerm. Here is algorithm.

     * 1) If new QueryTerm find a QueryTerm in queryTerms which has same search value,

     *    them create a new vector which contain both QueryTerms and add the new vector

     *    to two-dimention vector queryTermsWithSameValue, and remove the QueryTerm which

     *    was in queryTerm.

     * 2) If new QueryTerm couldn't find a QueryTerm in queryTerms which has same search value,

     *    then search queryTermsWithSameValue, to see if this vector already has the search value.

     *    2.1) if has the search value, add the new QueryTerm to the queryTermsWithSameValue.

     *    2.2) if hasn't, add the new QueryTerm to queryTerms vector.

     */

    private void handleNewQueryTerms(QueryTerm newTerm)

    {

    	if (newTerm != null )

    			if (operator != null

						&& operator.equalsIgnoreCase(UNION)

						&& SystemUtil.getPathsForIndexing().contains(

								newTerm.getPathExpression())) {

					// System.out.println("in only union branch in handle new

					// query term");

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

						QueryTerm term = (QueryTerm) queryTermsInPathIndex.elementAt(i);

						if (term != null && term.hasSameSearchValue(newTerm)) {

							// System.out.println("1Move a query term and add a

							// new query term into search value in handle new

							// query term");

							// find a target which has same search value

							newSameValueVector.addElement(newTerm);

							queryTermsWithSameValue.add(newSameValueVector);

							queryTermsInPathIndex.remove(i);

							return;

						}

					}

					// no same search value was found in queryTerms.

					// then we need search queryTermsWithSameValue

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

						QueryTerm term = (QueryTerm) sameValueVec.elementAt(0);

						if (term != null && term.hasSameSearchValue(newTerm)) {

							// System.out.println("2add a new query term into

							// search value in handle new query term");

							sameValueVec.add(newTerm);

							return;

						}

					}

					// nothing found, but the search path is still in

					// xml_path_index,

					// save it into queryTermsInPathIndex vector

					queryTermsInPathIndex.add(newTerm);

					return;

				}

			}

    		// add this newTerm to queryTerms since we couldn't find it in xml_path_index

    	}

    }