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

import java.io.*;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

import java.util.Enumeration;

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.

     * 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

     */

    public String printSQL(boolean useXMLIndex) {

      StringBuffer self = new StringBuffer();

    	  queryString.append(pathIndexQueryString);

    	  {

    		  first = false;

    	  }

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

      {

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

        		first = false;

        	} else {

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

        	}

   		  	queryString.append(queryGroupSQL);

   		  	// count percerntage number

   		  	int count = qg.getPercentageSymbolCount();

   		  	countPercentageSearchItem = countPercentageSearchItem + count;

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

      {

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

        			+ termQueryString);

               } else {

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

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

                   }

               }

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

    	Vector pathVector = new Vector();

    	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(" (UPPER(nodedata) LIKE '%");

		        	if (value != null)

		        	{

		        	    sqlBuff.append(value.toUpperCase());

		        	}

		        	else

		        	{

		        		sqlBuff.append(value);

		        	}

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

		    		//gets every path in query term object

		    		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;

		    					sqlBuff.append("'");

		    					sqlBuff.append(path);

		    					sqlBuff.append("'");

		    				}

		    				else

		    				{

		    					sqlBuff.append(",'");

		    					sqlBuff.append(path);

		    					sqlBuff.append("'");

		    				}

		    				index++;

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

		                    {

		    				  countPercentageSearchItem++;

		                    }

	    			     }

	    		    }

	    		    sqlBuff.append("))");

	    	    }

	    	}

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

	    				 sqlBuff.append(term.printSQL(true));

	    				 sqlBuff.append(")");

	    				 index++;

	    			}

    			}

    		}

    	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 )

    				MetaCatUtil.pathsForIndexing.contains(newTerm.getPathExpression()))

	    			{

	    				Vector newSameValueVector = new Vector();

	    				newSameValueVector.add(term);

	    				newSameValueVector.addElement(newTerm);

	    				queryTermsWithSameValue.add(newSameValueVector);

	    			}

	    		}

	    		// no same search value was found in queryTerms.

	    		// then we need search queryTermsWithSameValue

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

	    		{

	    			Vector sameValueVec = (Vector)queryTermsWithSameValue.elementAt(i);

	    			// we only compare the first query term

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

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

	    			{

	    				return;

	    			}

	    		}

	    		// save it into queryTermsInPathIndex vector

	    		queryTermsInPathIndex.add(newTerm);

	    		return;

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

    	}

    }