Metacat

/**

 *      Name: QuerySpecification.java

 *   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

 *

 *   Version: '$Id: QuerySpecification.java 185 2000-06-22 02:20:17Z jones $'

 */

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.util.Stack;

import java.util.Vector;

import java.util.Enumeration;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

import org.xml.sax.helpers.DefaultHandler;

/** 

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

 */

public class QuerySpecification extends DefaultHandler {

  /** Default parser name. */

  private static final String

      DEFAULT_PARSER = "org.apache.xerces.parsers.SAXParser";

      //DEFAULT_PARSER = "oracle.xml.parser.v2.SAXParser";

  // Query data structures

  private String meta_file_id;

  private String querytitle;

  private Vector doctypeList;

  private QueryGroup query = null;

  private Stack elementStack;

  private Stack queryStack;

  private String currentValue;

  private String currentPathexpr;

  private String parserName = null;

  /**

   * construct an instance of the QuerySpecification class 

   *

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

   *                  the org.xml.sax.XMLReader interface

   */

  public QuerySpecification( Reader queryspec, String parserName ) 

         throws IOException {

    super();

    // Initialize the class variables

    doctypeList = new Vector();

    elementStack = new Stack();

    queryStack   = new Stack();

    this.parserName = parserName;

    // Initialize the parser and read the queryspec

    XMLReader parser = initializeParser();

    if (parser == null) {

      System.err.println("SAX parser not instantiated properly.");

    }

    try {

      parser.parse(new InputSource(queryspec));

    } catch (SAXException e) {

      System.err.println("error parsing data");

      System.err.println(e.getMessage());

    }

  }

  /**

   * construct an instance of the QuerySpecification class 

   *

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

   */

  public QuerySpecification( String queryspec, String parserName ) 

         throws IOException {

    this(new StringReader(queryspec), parserName);

  }

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

         FileReader xml = new FileReader(new File(xmlfile));

         QuerySpecification qspec = new QuerySpecification(xml, DEFAULT_PARSER);

         System.out.println(qspec.printSQL());

         // Also test the XML formatting function of DBQuery

/*

         System.out.println(DBQuery.createQuery("mysearchvalue", "mydoctype"));

         StringReader xml2 = new StringReader(

                      DBQuery.createQuery("mysearchvalue", "mydoctype"));

         QuerySpecification qspec2 = 

                      new QuerySpecification(xml2, DEFAULT_PARSER);

         System.out.println(qspec2.printSQL());

*/

       } catch (IOException e) {

         System.err.println(e.getMessage());

       }

     }

  }

  /**

   * Set up the SAX parser for reading the XML serialized query

   */

  private XMLReader initializeParser() {

    XMLReader parser = null;

    // Set up the SAX document handlers for parsing

    try {

      // Get an instance of the parser

      parser = XMLReaderFactory.createXMLReader(parserName);

      // Set the ContentHandler to this instance

      parser.setContentHandler(this);

      // Set the error Handler to this instance

      parser.setErrorHandler(this);

    } catch (Exception e) {

       System.err.println(e.toString());

    }

    return parser;

  }

  /**

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

   */

  public void startElement (String uri, String localName, 

                            String qName, Attributes atts) 

         throws SAXException {

    BasicNode currentNode = new BasicNode(localName);

    // add attributes to BasicNode here

    if (atts != null) {

      int len = atts.getLength();

      for (int i = 0; i < len; i++) {

        currentNode.setAttribute(atts.getLocalName(i), atts.getValue(i));

      }

    }

    elementStack.push(currentNode); 

    if (currentNode.getTagName().equals("querygroup")) {

      QueryGroup currentGroup = new QueryGroup(

                                currentNode.getAttribute("operator"));

      if (query == null) {

        query = currentGroup;

      } else {

        QueryGroup parentGroup = (QueryGroup)queryStack.peek();

        parentGroup.addChild(currentGroup);

      }

      queryStack.push(currentGroup);

    }

  }

  /**

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

   */

  public void endElement (String uri, String localName,

                          String qName) throws SAXException {

    BasicNode leaving = (BasicNode)elementStack.pop(); 

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

    }

  }

  /**

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

   */

  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;

    } else if (currentTag.equals("value")) {

      currentValue = inputString;

    } else if (currentTag.equals("pathexpr")) {

      currentPathexpr = inputString;

    } else if (currentTag.equals("returndoctype")) {

      doctypeList.add(inputString);

    }

  }

  /**

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

   */

  public String printSQL() {

    StringBuffer self = new StringBuffer();

    // This determines the returned results

    self.append("SELECT docid,docname,doctype,doctitle ");

    self.append("FROM xml_documents WHERE docid IN (");

    // This determines the documents that meet the query conditions

    self.append(query.printSQL());

    self.append(") ");

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

          firstdoctype = false;

          self.append(" doctype = '" + currentDoctype + "'"); 

        } else {

          self.append(" OR doctype = '" + currentDoctype + "'"); 

        }

      }

      self.append(") ");

    }

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

    return "meta_file_id=" + meta_file_id + "\n" + 

           "querytitle=" + querytitle + "\n" + query;

  }

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

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

        } else if (qobject instanceof QueryTerm) {

          QueryTerm qt = (QueryTerm)qobject;

          self.append(qt.printSQL());

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

    /**

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

      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;

      }

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

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

    }

    /**

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

    }

  }

}