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

 *    Release: @release@

 *

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

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

    /** 

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

    }

    /** 

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

    }

    /**

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

    }

    /**

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

      boolean first = true;

      self.append("(");

      Enumeration en= getChildren();

      while (en.hasMoreElements()) {

        Object qobject = en.nextElement();

        if (first) {

          first = false;

        } else {

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

        }

        if (qobject instanceof QueryGroup) {

          QueryGroup qg = (QueryGroup)qobject;

          self.append(qg.printSQL(useXMLIndex));

          // count percerntage number

          int count = qg.getPercentageSymbolCount();

          countPercentageSearchItem = countPercentageSearchItem + count;

        } else if (qobject instanceof QueryTerm) {

           QueryTerm qt = (QueryTerm)qobject;

           self.append(qt.printSQL(useXMLIndex));

           // count percerntage number

           int count = qt.getPercentageSymbolCount();

           countPercentageSearchItem = countPercentageSearchItem + count;

        } else {

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

        }

      }

      self.append(") \n");

      return self.toString();

    }

    /**

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

    }

  }

/**

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

 *    Release: @release@

 *

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

/** a utility class that represents a single term in a query */

public class QueryTerm {

    private boolean casesensitive = false;

    private String searchmode = null;

    private String value = null;

    private String pathexpr = null;

    private boolean percentageSymbol = false;

    private int countPercentageSearchItem = 0;

    /**

     * Construct a new instance of a query term for a free text search

     * (using the value only)

     *

     * @param casesensitive flag indicating whether case is used to match

     * @param searchmode determines what kind of substring match is performed

     *        (one of starts-with|ends-with|contains|matches-exactly)

     * @param value the text value to match

     */

    public QueryTerm(boolean casesensitive, String searchmode, 

                     String value) {

      this.casesensitive = casesensitive;

      this.searchmode = searchmode;

      this.value = value;

    }

    /**

     * Construct a new instance of a query term for a structured search

     * (matching the value only for those nodes in the pathexpr)

     *

     * @param casesensitive flag indicating whether case is used to match

     * @param searchmode determines what kind of substring match is performed

     *        (one of starts-with|ends-with|contains|matches-exactly)

     * @param value the text value to match

     * @param pathexpr the hierarchical path to the nodes to be searched

     */

    public QueryTerm(boolean casesensitive, String searchmode, 

                     String value, String pathexpr) {

      this(casesensitive, searchmode, value);

      this.pathexpr = pathexpr;

    }

    /** determine if the QueryTerm is case sensitive */

    public boolean isCaseSensitive() {

      return casesensitive;

    }

    /** get the searchmode parameter */

    public String getSearchMode() {

      return searchmode;

    }

    /** get the Value parameter */

    public String getValue() {

      return value;

    }

    /** get the path expression parameter */

    public String getPathExpression() {

      return pathexpr;

    }

    /** get the percentage count for one query term*/

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

      // Uppercase the search string if case match is not important

      String casevalue = null;

      String nodedataterm = null;

      if (casesensitive) {

        nodedataterm = "nodedata";

        casevalue = value;

      } else {

        nodedataterm = "UPPER(nodedata)";

        casevalue = value.toUpperCase();

      }

      // Add appropriate wildcards to search string

      //String searchvalue = null;

      String searchexpr = null;

      if (searchmode.equals("starts-with")) {

        //searchvalue = casevalue + "%";

        searchexpr = nodedataterm + " LIKE '" + casevalue + "%' ";

      } else if (searchmode.equals("ends-with")) {

        //searchvalue = "%" + casevalue;

        searchexpr = nodedataterm + " LIKE '%" + casevalue + "' ";

      } else if (searchmode.equals("contains")) {

        //searchvalue = "%" + casevalue + "%";

        if (!casevalue.equals("%"))

        {

          searchexpr = nodedataterm + " LIKE '%" + casevalue + "%' ";

        }

        else

        {

          searchexpr = nodedataterm + " LIKE '" + casevalue + "' ";

          // find percentage symbol

          percentageSymbol = true;

        }

      } else if (searchmode.equals("equals")) {

        //searchvalue = casevalue;

        searchexpr = nodedataterm + " = '" + casevalue + "' ";

      } else if (searchmode.equals("isnot-equal")) {

        //searchvalue = casevalue;

        searchexpr = nodedataterm + " != '" + casevalue + "' ";

      } else { 

        //searchvalue = casevalue;

        String oper = null;

        if (searchmode.equals("greater-than")) {

          oper = ">";

        } else if (searchmode.equals("greater-than-equals")) {

          oper = ">=";

        } else if (searchmode.equals("less-than")) {

          oper = "<";

        } else if (searchmode.equals("less-than-equals")) {

          oper = "<=";

        } else {

          System.out.println("NOT expected case. NOT recognized operator: " +

                             searchmode);

          return null;

        }

        try {

          // it is number; numeric comparison

          // but we need to make sure there is no string in node data

          String getRidOfString = " AND UPPER(nodedata) = LOWER(nodedata)" +

                                  " AND LTRIM(nodedata) != ' ' " +

                                  " AND nodedata IS NOT NULL ";

          searchexpr = nodedataterm + " " + oper + " " +

                       new Double(casevalue) + " "+getRidOfString;          

        } catch (NumberFormatException nfe) {

          // these are characters; character comparison

          searchexpr = nodedataterm + " " + oper + " '" + casevalue + "' ";

        }

      }

      self.append("SELECT DISTINCT docid FROM xml_nodes WHERE \n");

      //self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");

      self.append(searchexpr);

      if (pathexpr != null) 

      {

        // use XML Index

        if ( useXMLIndex ) 

        {

          if (!hasAttributeInPath(pathexpr))

          {

            // without attributes in path

            self.append("AND parentnodeid IN ");

          }

          else

          {

            // has a attribute in path

            String attributeName = QuerySpecification.getAttributeName(pathexpr);

            self.append("AND nodetype LIKE 'ATTRIBUTE' AND nodename LIKE '"+

                        attributeName + "' ");

            self.append("AND parentnodeid IN ");

            pathexpr = 

                 QuerySpecification.newPathExpressionWithOutAttribute(pathexpr);

          } 

          self.append("(SELECT nodeid FROM xml_index WHERE path LIKE " + 

                      "'" +  pathexpr + "') " );

        } 

        else 

        {

          // without using XML Index; using nested statements instead

          self.append("AND parentnodeid IN ");

          self.append(useNestedStatements(pathexpr));

        }

      }

      else if ((value.trim()).equals("%"))

      {

        //if pathexpr is null and search value is %, is a percentageSearchItem

        // the count number will be increase one

        countPercentageSearchItem++;

       }

      return self.toString();

    }

    /* A method to judge if a path have attribute */

    private boolean hasAttributeInPath(String path)

    {

      if (path.indexOf(QuerySpecification.ATTRIBUTESYMBOL)!=-1)

      {

        return true;

      }

      else

      {

        return false;

      }

    }

    /* 

     * Constraint the query with @pathexp without using the XML Index,

     * but nested SQL statements instead. The query migth be slower.

     */

    private String useNestedStatements(String pathexpr)

    {

      StringBuffer nestedStmts = new StringBuffer();

      Vector nodes = new Vector();

      String path = pathexpr;

      int inx = 0;

      do {

        inx = path.lastIndexOf("/");

        nodes.addElement(path.substring(inx+1));

        path = path.substring(0, Math.abs(inx));

      } while ( inx > 0 );

      // nested statements

      int i = 0;

      for (i = 0; i < nodes.size()-1; i++) {

        nestedStmts.append("(SELECT nodeid FROM xml_nodes" + 

                           " WHERE nodename LIKE '" +

                             (String)nodes.elementAt(i) + "'" +

                           " AND parentnodeid IN ");

      }

      // for the last statement: it is without " AND parentnodeid IN "

      nestedStmts.append("(SELECT nodeid FROM xml_nodes" + 

                         " WHERE nodename LIKE '" +

                         (String)nodes.elementAt(i) + "'" );

      // node.size() number of closing brackets

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

        nestedStmts.append(")");

      }

      return nestedStmts.toString();

    }

    /**

     * 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() {

      return this.printSQL(true);

    }

  }