/src/edu/ucsb/nceas/metacat/QuerySpecification.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/QuerySpecification.java @ 453

-            jones
+/**
-            jones
+ *  '$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
-            jones
+ *    Release: @release@
             jones
-            jones
+ *   '$Author$'
  *     '$Date$'
  * '$Revision$'
-            jones
+ */
 package edu.ucsb.nceas.metacat;
 import java.io.*;
 import java.util.Stack;
-            jones
+import java.util.Vector;
-            jones
+import java.util.Enumeration;
             jones
-            jones
+import org.xml.sax.Attributes;
-            jones
+import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
-            jones
+import org.xml.sax.XMLReader;
 import org.xml.sax.helpers.XMLReaderFactory;
 import org.xml.sax.helpers.DefaultHandler;
             jones
-            berkley
+/**
-            jones
+ * A Class that represents a structured query, and can be
  * constructed from an XML serialization conforming to @see pathquery.dtd.
  * The printSQL() method can be used to print a SQL serialization of the query.
-            jones
+ */
-            jones
+public class QuerySpecification extends DefaultHandler {
             jones
-            berkley
+  private boolean containsExtendedSQL=false;
-            jones
+  // Query data structures
   private String meta_file_id;
   private String querytitle;
-            jones
+  private Vector doctypeList;
-            berkley
+  private Vector returnFieldList;
-            jones
+  private QueryGroup query = null;
   private Stack elementStack;
   private Stack queryStack;
-            jones
+  private String currentValue;
   private String currentPathexpr;
-            jones
+  private String parserName = null;
             jones
-            jones
+  /**
    * construct an instance of the QuerySpecification class
+   *
-            jones
+   * @param queryspec the XML representation of the query (should conform
    *                  to pathquery.dtd) as a Reader
    * @param parserName the fully qualified name of a Java Class implementing
-            jones
+   *                  the org.xml.sax.XMLReader interface
-            jones
+   */
-            jones
+  public QuerySpecification( Reader queryspec, String parserName )
          throws IOException {
-            jones
+    super();
             berkley
-            jones
+    // Initialize the class variables
     doctypeList = new Vector();
-            jones
+    elementStack = new Stack();
     queryStack   = new Stack();
-            berkley
+    returnFieldList = new Vector();
-            jones
+    this.parserName = parserName;
             jones
     // Initialize the parser and read the queryspec
-            jones
+    XMLReader parser = initializeParser();
-            jones
+    if (parser == null) {
       System.err.println("SAX parser not instantiated properly.");
+    }
-            jones
+    try {
       parser.parse(new InputSource(queryspec));
     } catch (SAXException e) {
-            jones
+      System.err.println("error parsing data");
       System.err.println(e.getMessage());
             jones
+  }
   /**
    * construct an instance of the QuerySpecification class
+   *
-            jones
+   * @param queryspec the XML representation of the query (should conform
    *                  to pathquery.dtd) as a String
    * @param parserName the fully qualified name of a Java Class implementing
    *                  the org.xml.sax.Parser interface
-            jones
+   */
-            jones
+  public QuerySpecification( String queryspec, String parserName )
          throws IOException {
     this(new StringReader(queryspec), parserName);
             jones
   /** Main routine for testing */
   static public void main(String[] args) {
      if (args.length < 1) {
        System.err.println("Wrong number of arguments!!!");
        System.err.println("USAGE: java QuerySpecification <xmlfile>");
        return;
      } else {
        String xmlfile  = args[0];
        try {
-            jones
+         MetaCatUtil util = new MetaCatUtil();
-            jones
+         FileReader xml = new FileReader(new File(xmlfile));
-            jones
+         QuerySpecification qspec =
                  new QuerySpecification(xml, util.getOption("saxparser"));
-            jones
+         System.out.println(qspec.printSQL());
             jones
-            jones
+       } catch (IOException e) {
          System.err.println(e.getMessage());
+       }
+     }
+  }
             berkley
   /**
    * Returns true if the parsed query contains and extended xml query
    * (i.e. there is at least one &lt;returnfield&gt; in the pathquery document)
    */
   public boolean containsExtendedSQL()
+  {
     if(containsExtendedSQL)
+    {
       return true;
+    }
     else
+    {
       return false;
+    }
+  }
   /**
    * Accessor method to return a vector of the extended return fields as
    * defined in the &lt;returnfield&gt; tag in the pathquery dtd.
    */
   public Vector getReturnFieldList()
+  {
     return this.returnFieldList;
+  }
             jones
-            jones
+  /**
    * Set up the SAX parser for reading the XML serialized query
    */
-            jones
+  private XMLReader initializeParser() {
     XMLReader parser = null;
             jones
-            jones
+    // Set up the SAX document handlers for parsing
     try {
       // Get an instance of the parser
-            jones
+      parser = XMLReaderFactory.createXMLReader(parserName);
             jones
-            jones
+      // Set the ContentHandler to this instance
       parser.setContentHandler(this);
             jones
-            jones
+      // Set the error Handler to this instance
-            jones
+      parser.setErrorHandler(this);
             jones
     } catch (Exception e) {
        System.err.println(e.toString());
+    }
     return parser;
+  }
-            jones
+  /**
    * callback method used by the SAX Parser when the start tag of an
    * element is detected. Used in this context to parse and store
    * the query information in class variables.
    */
-            jones
+  public void startElement (String uri, String localName,
                             String qName, Attributes atts)
-            jones
+         throws SAXException {
-            jones
+    BasicNode currentNode = new BasicNode(localName);
-            jones
+    // add attributes to BasicNode here
     if (atts != null) {
       int len = atts.getLength();
       for (int i = 0; i < len; i++) {
-            jones
+        currentNode.setAttribute(atts.getLocalName(i), atts.getValue(i));
             jones
+    }
-            jones
+    elementStack.push(currentNode);
-            jones
+    if (currentNode.getTagName().equals("querygroup")) {
-            jones
+      QueryGroup currentGroup = new QueryGroup(
-            jones
+                                currentNode.getAttribute("operator"));
-            jones
+      if (query == null) {
         query = currentGroup;
-            jones
+      } else {
         QueryGroup parentGroup = (QueryGroup)queryStack.peek();
         parentGroup.addChild(currentGroup);
             jones
-            jones
+      queryStack.push(currentGroup);
             jones
             jones
-            jones
+  /**
    * callback method used by the SAX Parser when the end tag of an
    * element is detected. Used in this context to parse and store
    * the query information in class variables.
    */
-            jones
+  public void endElement (String uri, String localName,
                           String qName) throws SAXException {
-            jones
+    BasicNode leaving = (BasicNode)elementStack.pop();
-            jones
+    if (leaving.getTagName().equals("queryterm")) {
       boolean isCaseSensitive = (new Boolean(
               leaving.getAttribute("casesensitive"))).booleanValue();
       QueryTerm currentTerm = null;
       if (currentPathexpr == null) {
         currentTerm = new QueryTerm(isCaseSensitive,
                       leaving.getAttribute("searchmode"),currentValue);
       } else {
         currentTerm = new QueryTerm(isCaseSensitive,
                       leaving.getAttribute("searchmode"),currentValue,
                       currentPathexpr);
+      }
       QueryGroup currentGroup = (QueryGroup)queryStack.peek();
       currentGroup.addChild(currentTerm);
       currentValue = null;
       currentPathexpr = null;
     } else if (leaving.getTagName().equals("querygroup")) {
       QueryGroup leavingGroup = (QueryGroup)queryStack.pop();
             jones
             jones
             jones
-            jones
+  /**
    * callback method used by the SAX Parser when the text sequences of an
    * xml stream are detected. Used in this context to parse and store
    * the query information in class variables.
    */
-            jones
+  public void characters(char ch[], int start, int length) {
     String inputString = new String(ch, start, length);
     BasicNode currentNode = (BasicNode)elementStack.peek();
     String currentTag = currentNode.getTagName();
     if (currentTag.equals("meta_file_id")) {
       meta_file_id = inputString;
     } else if (currentTag.equals("querytitle")) {
       querytitle = inputString;
-            jones
+    } else if (currentTag.equals("value")) {
       currentValue = inputString;
     } else if (currentTag.equals("pathexpr")) {
       currentPathexpr = inputString;
-            jones
+    } else if (currentTag.equals("returndoctype")) {
       doctypeList.add(inputString);
-            berkley
+    } else if (currentTag.equals("returnfield")) {
       returnFieldList.add(inputString);
       containsExtendedSQL = true;
             jones
+  }
             jones
   /**
    * create a SQL serialization of the query that this instance represents
    */
   public String printSQL() {
-            jones
+    StringBuffer self = new StringBuffer();
-            berkley
+    self.append("SELECT docid,docname,doctype,doctitle,");
     self.append("date_created, date_updated ");
-            jones
+    self.append("FROM xml_documents WHERE docid IN (");
             jones
-            jones
+    // This determines the documents that meet the query conditions
-            jones
+    self.append(query.printSQL());
     self.append(") ");
             berkley
-            jones
+    // Add SQL to filter for doctypes requested in the query
     if (!doctypeList.isEmpty()) {
       boolean firstdoctype = true;
       self.append(" AND (");
       Enumeration en = doctypeList.elements();
       while (en.hasMoreElements()) {
         String currentDoctype = (String)en.nextElement();
         if (firstdoctype) {
-            berkley
+           firstdoctype = false;
            self.append(" doctype = '" + currentDoctype + "'");
-            jones
+        } else {
           self.append(" OR doctype = '" + currentDoctype + "'");
+        }
+      }
       self.append(") ");
+    }
             berkley
-            jones
+    return self.toString();
+  }
             berkley
   /**
    * This method prints sql based upon the &lt;returnfield&gt; tag in the
    * pathquery document.  This allows for customization of the
    * returned fields
    */
   public String printExtendedSQL()
+  {
     StringBuffer self = new StringBuffer();
-            berkley
+    self.append("select xml_nodes.docid, xml_index.path, xml_nodes.nodedata ");
     self.append("from xml_index, xml_nodes where xml_index.nodeid=");
     self.append("xml_nodes.parentnodeid and (xml_index.path like '");
-            berkley
+    boolean firstfield = true;
     //put the returnfields into the query
     //the for loop allows for multiple fields
     for(int i=0; i<returnFieldList.size(); i++)
+    {
       if(firstfield)
+      {
         firstfield = false;
-            berkley
+        self.append((String)returnFieldList.elementAt(i));
-            berkley
+        self.append("' ");
+      }
       else
+      {
-            berkley
+        self.append("or xml_index.path like '");
-            berkley
+        self.append((String)returnFieldList.elementAt(i));
-            berkley
+        self.append("' ");
+      }
+    }
-            berkley
+    self.append(") AND xml_nodes.docid in (");
-            berkley
+    self.append(query.printSQL());
     self.append(")");
-            berkley
+    self.append(" AND xml_nodes.nodetype = 'TEXT'");
             berkley
-            berkley
+    //System.out.println(self.toString());
-            berkley
+    return self.toString();
+  }
             berkley
-            jones
+  /**
             berkley
    */
   public static String printPackageSQL()
+  {
     StringBuffer self = new StringBuffer();
     self.append("select z.nodedata, x.nodedata, y.nodedata from ");
     self.append("(select nodeid, parentnodeid from xml_index where path like ");
     self.append("'package/relation/subject') s, (select nodeid, parentnodeid ");
     self.append("from xml_index where path like ");
     self.append("'package/relation/relationship') rel, ");
     self.append("(select nodeid, parentnodeid from xml_index where path like ");
     self.append("'package/relation/object') o, ");
     self.append("xml_nodes x, xml_nodes y, xml_nodes z ");
     self.append("where s.parentnodeid = rel.parentnodeid ");
     self.append("and rel.parentnodeid = o.parentnodeid ");
     self.append("and x.parentnodeid in rel.nodeid ");
     self.append("and y.parentnodeid in o.nodeid ");
     self.append("and z.parentnodeid in s.nodeid ");
     //self.append("and z.nodedata like '%");
     //self.append(docid);
     //self.append("%'");
     return self.toString();
+  }
   /**
-            jones
+   * create a String description of the query that this instance represents.
    * This should become a way to get the XML serialization of the query.
    */
-            jones
+  public String toString() {
     return "meta_file_id=" + meta_file_id + "\n" +
            "querytitle=" + querytitle + "\n" + query;
+  }
-            jones
+  /** a utility class that represents a group of terms in a query */
   private class QueryGroup {
-            jones
+    private String operator = null;  // indicates how query terms are combined
     private Vector children = null;  // the list of query terms and groups
             jones
-            jones
+    /**
      * construct a new QueryGroup
+     *
-            jones
+     * @param operator the boolean conector used to connect query terms
-            jones
+     *                    in this query group
      */
-            jones
+    public QueryGroup(String operator) {
       this.operator = operator;
-            jones
+      children = new Vector();
+    }
-            jones
+    /**
      * Add a child QueryGroup to this QueryGroup
+     *
      * @param qgroup the query group to be added to the list of terms
      */
-            jones
+    public void addChild(QueryGroup qgroup) {
       children.add((Object)qgroup);
+    }
-            jones
+    /**
      * Add a child QueryTerm to this QueryGroup
+     *
      * @param qterm the query term to be added to the list of terms
      */
-            jones
+    public void addChild(QueryTerm qterm) {
       children.add((Object)qterm);
+    }
-            jones
+    /**
      * Retrieve an Enumeration of query terms for this QueryGroup
      */
-            jones
+    public Enumeration getChildren() {
       return children.elements();
+    }
             jones
-            jones
+    /**
      * create a SQL serialization of the query that this instance represents
      */
     public String printSQL() {
-            jones
+      StringBuffer self = new StringBuffer();
       boolean first = true;
       self.append("(");
       Enumeration en= getChildren();
       while (en.hasMoreElements()) {
         Object qobject = en.nextElement();
         if (first) {
           first = false;
         } else {
-            jones
+          self.append(" " + operator + " ");
             jones
         if (qobject instanceof QueryGroup) {
           QueryGroup qg = (QueryGroup)qobject;
-            jones
+          self.append(qg.printSQL());
-            jones
+        } else if (qobject instanceof QueryTerm) {
           QueryTerm qt = (QueryTerm)qobject;
-            jones
+          self.append(qt.printSQL());
-            jones
+        } else {
           System.err.println("qobject wrong type: fatal error");
+        }
+      }
       self.append(") \n");
       return self.toString();
+    }
-            jones
+    /**
      * create a String description of the query that this instance represents.
      * This should become a way to get the XML serialization of the query.
      */
-            jones
+    public String toString() {
       StringBuffer self = new StringBuffer();
-            jones
+      self.append("  (Query group operator=" + operator + "\n");
-            jones
+      Enumeration en= getChildren();
       while (en.hasMoreElements()) {
         Object qobject = en.nextElement();
         self.append(qobject);
+      }
       self.append("  )\n");
       return self.toString();
+    }
             jones
   /** 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;
-            jones
+    /**
      * 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
      */
-            jones
+    public QueryTerm(boolean casesensitive, String searchmode,
                      String value) {
       this.casesensitive = casesensitive;
       this.searchmode = searchmode;
       this.value = value;
+    }
-            jones
+    /**
      * 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
      */
-            jones
+    public QueryTerm(boolean casesensitive, String searchmode,
                      String value, String pathexpr) {
       this(casesensitive, searchmode, value);
       this.pathexpr = pathexpr;
+    }
-            jones
+    /** determine if the QueryTerm is case sensitive */
-            jones
+    public boolean isCaseSensitive() {
       return casesensitive;
+    }
-            jones
+    /** get the searchmode parameter */
-            jones
+    public String getSearchMode() {
       return searchmode;
+    }
-            jones
+    /** get the Value parameter */
-            jones
+    public String getValue() {
       return value;
+    }
-            jones
+    /** get the path expression parameter */
-            jones
+    public String getPathExpression() {
       return pathexpr;
+    }
             jones
-            jones
+    /**
      * create a SQL serialization of the query that this instance represents
      */
     public String printSQL() {
-            jones
+      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;
       if (searchmode.equals("starts-with")) {
         searchvalue = casevalue + "%";
       } else if (searchmode.equals("ends-with")) {
         searchvalue = "%" + casevalue;
       } else if (searchmode.equals("contains")) {
         searchvalue = "%" + casevalue + "%";
       } else {
         searchvalue = casevalue;
+      }
-            jones
+      self.append("SELECT DISTINCT docid FROM xml_nodes WHERE \n");
             jones
       if (pathexpr != null) {
         self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");
         self.append("AND parentnodeid IN ");
         self.append("(SELECT nodeid FROM xml_index WHERE path LIKE " +
                     "'" +  pathexpr + "') " );
       } else {
         self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");
+      }
       return self.toString();
+    }
-            jones
+    /**
      * create a String description of the query that this instance represents.
      * This should become a way to get the XML serialization of the query.
      */
-            jones
+    public String toString() {
       StringBuffer self = new StringBuffer();
       self.append("    Query Term iscasesensitive=" + casesensitive + "\n");
       self.append("               searchmode=" + searchmode + "\n");
       self.append("               value=" + value + "\n");
       if (pathexpr != null) {
         self.append("               pathexpr=" + pathexpr + "\n");
+      }
       return self.toString();
+    }
             jones
             jones
             jones
 /**
  * '$Log$
-            berkley
+ * 'Revision 1.14  2000/08/31 21:20:39  berkley
  * 'changed xslf for new returnfield scheme.  the returnfields are now returned as <param name="<returnfield>"> tags.
  * 'hThe sql for the returnfield query was redone to fix a previous problem with slow queries
  * '
-            berkley
+ * 'Revision 1.13  2000/08/23 22:55:38  berkley
  * 'changed the field names to be case-sensitive in the returnfields
  * '
-            berkley
+ * 'Revision 1.12  2000/08/23 17:29:05  berkley
  * 'added support for the returnfield parameter
  * '-QuerySpecification now sets a flag (containsExtendedSQL) when there are returnfield items in the pathquery document.
  * 'the accessor method containsExtendedSQL() can be called by other classes to check for extended return parameters
  * '-getReturnFields returns a Vector of the names of each specified return field.
  * '-printExtendedSQL returns a string of the extra SQL statements required for the query.
  * '
  * '-a calling class should first check containsExtendedSQL to make sure that there are extra fields being returned, then call printExtendedSQL to
  * 'insert the extra SQL into the query.  (Note that this is how DBQuery implements this.)
  * '
-            berkley
+ * 'Revision 1.11  2000/08/14 20:53:34  jones
  * 'Added "release" keyword to all metacat source files so that the release
  * 'number will be evident in software distributions.
  * '
-            jones
+ * 'Revision 1.10  2000/06/26 10:35:05  jones
  * 'Merged in substantial changes to DBWriter and associated classes and to
  * 'the MetaCatServlet in order to accomodate the new UPDATE and DELETE
  * 'functions.  The command line tools and the parameters for the
  * 'servlet have changed substantially.
  * '
-            jones
+ * 'Revision 1.9.2.3  2000/06/25 23:38:17  jones
  * 'Added RCSfile keyword
  * '
  * 'Revision 1.9.2.2  2000/06/25 23:34:18  jones
  * 'Changed documentation formatting, added log entries at bottom of source files
  * ''
  */

Project

General

Profile

Metacat