Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents a structured query, and can be

 *             constructed from an XML serialization conforming to

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

 *             a SQL serialization of the query.

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author: tao $'

 *     '$Date: 2007-04-11 17:41:54 -0700 (Wed, 11 Apr 2007) $'

 * '$Revision: 3226 $'

 *

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

import org.apache.log4j.Logger;

 /** a utility class that represents a group of terms in a query */

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;

    private Vector queryTermsWithSameValue = null;//this two dimension vectors.

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

    private Vector queryTerms = null;//this vector only holds query terms without same search value.

    private Vector queryGroupsChildren = null;

    private static Logger logMetacat = Logger.getLogger(QueryGroup.class);

    /**

     * construct a new QueryGroup

     *

     * @param operator the boolean conector used to connect query terms

     *                    in this query group

     */

    public QueryGroup(String operator) {

      this.operator = operator;

      children = new Vector();

      queryTermsWithSameValue = new Vector();

      queryTerms = new Vector();

      queryGroupsChildren = new Vector();

    }

    /**

     * Add a child QueryGroup to this QueryGroup

     *

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

     */

    public void addChild(QueryGroup qgroup) {

      //children.add((Object)qgroup);

      queryGroupsChildren.add(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) {

      // children.add((Object)qterm);

      handleNewQueryTerms(qterm);

    }

    /**

     * Retrieve an Enumeration of query terms for this QueryGroup

     */

    public Enumeration getChildren() {

      return children.elements();

    }

    public int getPercentageSymbolCount()

    {

      return countPercentageSearchItem;

    }

    /**

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

     */

    public String printSQL(boolean useXMLIndex) {

      StringBuffer self = new StringBuffer();

      StringBuffer queryString = new StringBuffer();

      boolean first = true;

      Enumeration en= getChildren();

      while (en.hasMoreElements()) {

        Object qobject = en.nextElement();

        if (qobject instanceof QueryGroup) {

            QueryGroup qg = (QueryGroup)qobject;

        	String queryGroupSQL = qg.printSQL(useXMLIndex);

        	logMetacat.info("In QueryGroup.printSQL.. found a QueryGroup: " 

        			+ queryGroupSQL);

        	if (first) {

        		first = false;

        	} else {

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

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

        		}

        	}

   		  	queryString.append(queryGroupSQL);

   		  	// count percerntage number

   		  	int count = qg.getPercentageSymbolCount();

   		  	countPercentageSearchItem = countPercentageSearchItem + count;

        } else if (qobject instanceof QueryTerm) {

           QueryTerm qt = (QueryTerm)qobject;

           String termQueryString = qt.printSQL(useXMLIndex);

       	   logMetacat.info("In QueryGroup.printSQL.. found a QueryGroup: " 

        			+ termQueryString);

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

        	   if (first) {

                   first = false;

               } else {

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

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

                   }

               }

               queryString.append(termQueryString);

           }

           // count percerntage number

           int count = qt.getPercentageSymbolCount();

           countPercentageSearchItem = countPercentageSearchItem + count;

        } else {

          System.err.println("qobject wrong type: fatal error");

        }

      }

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

          self.append("(");

          self.append(queryString.toString());

          self.append(")");

      }

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

			+ self.toString());

      return self.toString();

    }

    /*

     * If every query term in a queryGroup share a search value, we should

     * use a new query to replace the original query term query in order to

     * improve performance

     */

    private String printSQLStringWithSameSearchValue()

    {

    	String sql ="";

    	String value ="";

    	StringBuffer sqlBuff = new StringBuffer();

    	Vector pathVector = new Vector();

    	int index =0;

    	if (queryTermsWithSameValue != null)

    	{

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

        	value = term1.getValue();

        	boolean first = true;

			sqlBuff.append("SELECT DISTINCT docid FROM xml_path_index WHERE UPPER(nodedata) LIKE '%");

			sqlBuff.append(value);

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

    		//gets every path in query term object

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

    		{

    			QueryTerm term = (QueryTerm)queryTermsWithSameValue.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++;

    			}

    		}

    		sqlBuff.append(")");

    	}

    	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)

    	{

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

    		{

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

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

    			{

    				// find a target which has same search value

    				Vector newSameValueVector = new Vector();

    				newSameValueVector.add(term);

    				newSameValueVector.addElement(newTerm);

    				queryTermsWithSameValue.add(newSameValueVector);

    				queryTerms.remove(i);

    				return;

    			}

    		}

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

    			{

    				sameValueVec.add(newTerm);

    				return;

    			}

    		}

    		// both queryTerms and queryTermsWithSameValue don't have the search value,

    		// add this newTerm to queryTerms

    		queryTerms.add(newTerm);

    	}

    }

  }