/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 1832

Added by Jing Tao almost 21 years ago

Revied the class.

       private String accNumberSeparator = null;
       private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;
       private int countPercentageSearchItem = 0;
       private boolean percentageSearch = false;
       private String userName = null;
-...
+      {
         return query;
+      }
       /**
        * set the querygroup
        */
       public void setQueryGroup(QueryGroup group)
+      {
         query = group;
+      }
       /**
        * Set up the SAX parser for reading the XML serialized query
-...
         // if there is only one percentage search item, this query is a percentage
         // search query
         if (countPercentageSearchItem ==1)
         MetaCatUtil.debugMessage("percentage number: " +
                                              query.getPercentageSymbolCount(), 35);
         if (query.getPercentageSymbolCount() ==1 )
+        {
           MetaCatUtil.debugMessage("it is a percentage search", 30);
           percentageSearch =true;
+        }
-...
           return attributeName;
+      }
       /** a utility class that represents a group of terms in a query */
       private class QueryGroup {
         private String operator = null;  // indicates how query terms are combined
         private Vector children = null;  // the list of query terms and groups
         /**
          * 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();
+        }
         /**
          * 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));
             } else if (qobject instanceof QueryTerm) {
               QueryTerm qt = (QueryTerm)qobject;
               self.append(qt.printSQL(useXMLIndex));
             } 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();
+        }
+      }
       /** a utility class that represents a single term in a query */
       private class QueryTerm {
         private boolean casesensitive = false;
         private String searchmode = null;
         private String value = null;
         private String pathexpr = null;
         private boolean percentageSymbol = false;
         /**
          * 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;
+        }
         /**
          * 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 = getAttributeName(pathexpr);
                 self.append("AND nodetype LIKE 'ATTRIBUTE' AND nodename LIKE '"+
                             attributeName + "' ");
                 self.append("AND parentnodeid IN ");
                 pathexpr = 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 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(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);
+        }
+      }
+    }

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 1832

Added by Jing Tao almost 21 years ago