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

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

-            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
  * 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
-            jones
+ */
 package edu.ucsb.nceas.metacat;
-            berkley
+import edu.ucsb.nceas.dbadapter.*;
-            jones
+import java.io.*;
-            tao
+import java.util.Hashtable;
-            jones
+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
-            jones
+  /** flag determining whether extended query terms are present */
-            berkley
+  private boolean containsExtendedSQL=false;
-            jones
+  /** Identifier for this query document */
-            jones
+  private String meta_file_id;
-            jones
+  /** Title of this query */
   private String queryTitle;
   /** List of document types to be returned using package back tracing */
-            jones
+  private Vector returnDocList;
-            jones
+  /** List of document types to be searched */
-            jones
+  private Vector filterDocList;
-            jones
+  /** List of fields to be returned in result set */
-            berkley
+  private Vector returnFieldList;
-            jones
+  /** List of users owning documents to be searched */
-            jones
+  private Vector ownerList;
-            jones
+  /** List of sites/scopes used to constrain search */
-            jones
+  private Vector siteList;
-            jones
+  /** The root query group that contains the recursive query constraints */
-            jones
+  private QueryGroup query = null;
             tao
-            jones
+  // Query data structures used temporarily during XML parsing
-            jones
+  private Stack elementStack;
   private Stack queryStack;
-            jones
+  private String currentValue;
   private String currentPathexpr;
-            jones
+  private String parserName = null;
-            jones
+  private String accNumberSeparator = null;
-            berkley
+  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;
             tao
-            tao
+  private int countPercentageSearchItem = 0;
   private boolean percentageSearch = false;
-            tao
+  private String userName = null;
   private static final String PUBLIC = "public";
   private String [] group = null;
             jones
-            tao
+  public static final String ATTRIBUTESYMBOL = "@";
-            tao
+  private boolean hasAttributeReturnField = false;
   private Hashtable attributeReturnList = new Hashtable();
   private int countAttributeReturnField = 0;
-            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,
          String accNumberSeparator ) throws IOException {
-            jones
+    super();
             berkley
-            jones
+    // Initialize the class variables
-            jones
+    returnDocList = new Vector();
     filterDocList = new Vector();
-            jones
+    elementStack = new Stack();
     queryStack   = new Stack();
-            berkley
+    returnFieldList = new Vector();
-            jones
+    ownerList = new Vector();
     siteList = new Vector();
-            jones
+    this.parserName = parserName;
-            jones
+    this.accNumberSeparator = accNumberSeparator;
             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) {
-            berkley
+      System.err.println("error parsing data in " +
                          "QuerySpecification.QuerySpecification");
-            jones
+      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,
          String accNumberSeparator) throws IOException {
     this(new StringReader(queryspec), parserName, accNumberSeparator);
             jones
             tao
   /**
    * Method to set user name
+   *
    * @param myName  the user name
    */
   public void setUserName(String myName)
+  {
     this.userName = myName;
+  }
   /**
    * Method to set user group
+   *
    * @param myGroup  the user group
    */
   public void setGroup(String [] myGroup)
+  {
     this.group = myGroup;
+  }
-            tao
+  /**
    * Method to indicate this query is a percentage search
    */
   public boolean isPercentageSearch()
+  {
     return percentageSearch;
+  }
-            tao
+  /*
    * Method to get owner query. If it is owner it has all permission
    */
   private String createOwerQuery()
+  {
     String ownerQuery = null;
     ownerQuery = "SELECT docid FROM xml_documents WHERE user_owner ='" +
                   PUBLIC + "'";
     if (userName != null && !userName.equals(""))
+    {
       ownerQuery = ownerQuery + " OR user_owner ='"+ userName +"'";
+    }
     if (group != null)
+    {
       for (int i = 0; i< group.length; i++)
+      {
         String groupUint = group[i];
         if (groupUint != null && !groupUint.equals(""))
+        {
           ownerQuery = ownerQuery +" OR user_owner = '" + groupUint + "'";
         }//if
       }//for
+    }
     MetaCatUtil.debugMessage("OwnerQuery: "+ownerQuery, 30);
     return ownerQuery;
+  }
   /*
    * Method to create query for xml_access, this part is to get docid list which
    * have a allow rule for a given user
    */
   private String createAllowRuleQuery()
+  {
     String allowQuery = null;
     allowQuery ="SELECT docid from xml_access WHERE ";
     // add allow rule for user name
     if (userName != null && !userName.equals(""))
+    {
       allowQuery = allowQuery +"(principal_name = '" + userName
-            tao
+                              +"' AND perm_type = 'allow'"
                               +" AND (permission='4' OR permission='7'))";
             tao
     // add allow rule for public
     allowQuery = allowQuery +"OR (principal_name = '" + PUBLIC
-            tao
+                              +"' AND perm_type = 'allow'"
                               +" AND (permission='4' OR permission='7'))";
             tao
     // add allow rule for group
     if (group != null)
+    {
       for (int i = 0; i< group.length; i++)
+      {
         String groupUint = group[i];
         if (groupUint != null && !groupUint.equals(""))
+        {
           allowQuery = allowQuery +" OR (principal_name = '" + groupUint
-            tao
+                              +"' AND perm_type = 'allow'"
                               +" AND (permission='4' OR permission='7'))";
-            tao
+        }//if
       }//for
     }//if
     MetaCatUtil.debugMessage("allow query is: "+ allowQuery, 30);
     return allowQuery;
+  }
             jones
-            tao
+   /*
    * Method to create query for xml_access, this part is to get docid list which
    * have a deny rule and perm_order is allowFirst for a given user. This means
    * the user will be denied to read
    */
   private String createDenyRuleQuery()
+  {
     String denyQuery = null;
     denyQuery ="SELECT docid from xml_access WHERE ";
     // add deny rule for user name
     if (userName != null && !userName.equals(""))
+    {
       denyQuery = denyQuery +"(principal_name = '" + userName
                               +"' AND perm_type = 'deny' "
-            tao
+                              +"AND perm_order ='allowFirst'"
                               +" AND (permission='4' OR permission='7'))";
             tao
     // add deny rule for public
     denyQuery = denyQuery +"OR (principal_name = '" + PUBLIC
                                +"' AND perm_type = 'deny' "
-            tao
+                               +"AND perm_order ='allowFirst'"
                                +" AND (permission='4' OR permission='7'))";
             tao
     // add allow rule for group
     if (group != null)
+    {
       for (int i = 0; i< group.length; i++)
+      {
         String groupUint = group[i];
         if (groupUint != null && !groupUint.equals(""))
+        {
           denyQuery = denyQuery +" OR (principal_name = '" + groupUint
                                 +"' AND perm_type = 'deny' "
-            tao
+                                +"AND perm_order ='allowFirst'"
                                 +" AND (permission='4' OR permission='7'))";
-            tao
+        }//if
       }//for
     }//if
     MetaCatUtil.debugMessage("denyquery is: "+ denyQuery, 30);
     return denyQuery;
+  }
   /**
    * Method to append a access control query to SQL. So in DBQuery class, we can
    * get docid from both user specified query and access control query. We don't
    * need to checking permission after we get the doclist. It will be good to
    * performance
+   *
    */
   public String getAccessQuery()
+  {
     String accessQuery = null;
     String onwer = createOwerQuery();
     String allow = createAllowRuleQuery();
     String deny = createDenyRuleQuery();
     accessQuery = " AND (docid IN("+ onwer + ")";
     accessQuery = accessQuery + " OR (docid IN (" + allow + ")"
                  + " AND docid NOT IN ("+ deny + ")))";
     MetaCatUtil.debugMessage("accessquery is: "+ accessQuery, 30);
     return accessQuery;
+  }
-            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 {
-            jones
+       int i = 0;
        boolean useXMLIndex = true;
        if ( args[i].equals( "-noindex" ) ) {
          useXMLIndex = false;
          i++;
+       }
        String xmlfile  = args[i];
-            jones
+       try {
-            jones
+         MetaCatUtil util = new MetaCatUtil();
-            jones
+         FileReader xml = new FileReader(new File(xmlfile));
-            jones
+         QuerySpecification qspec =
-            jones
+                 new QuerySpecification(xml, util.getOption("saxparser"),
                                         util.getOption("accNumberSeparator"));
-            bojilova
+         System.out.println(qspec.printSQL(useXMLIndex));
             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;
+    }
+  }
   /**
-            tao
+   * A method to get if the query has an attribute return field
    */
   public boolean containAttributeReturnField()
+  {
     return hasAttributeReturnField;
+  }
   /**
-            jones
+   * Accessor method to return the identifier of this Query
    */
   public String getIdentifier()
+  {
     return meta_file_id;
+  }
   /**
    * method to set the identifier of this query
    */
   public void setIdentifier(String id) {
     this.meta_file_id = id;
+  }
   /**
    * Accessor method to return the title of this Query
    */
   public String getQueryTitle()
+  {
     return queryTitle;
+  }
   /**
    * method to set the title of this query
    */
   public void setQueryTitle(String title)
+  {
     this.queryTitle = title;
+  }
   /**
    * Accessor method to return a vector of the return document types as
    * defined in the &lt;returndoctype&gt; tag in the pathquery dtd.
    */
   public Vector getReturnDocList()
+  {
     return this.returnDocList;
+  }
   /**
    * method to set the list of return docs of this query
    */
   public void setReturnDocList(Vector returnDocList)
+  {
     this.returnDocList = returnDocList;
+  }
   /**
    * Accessor method to return a vector of the filter doc types as
    * defined in the &lt;filterdoctype&gt; tag in the pathquery dtd.
    */
   public Vector getFilterDocList()
+  {
     return this.filterDocList;
+  }
   /**
    * method to set the list of filter docs of this query
    */
   public void setFilterDocList(Vector filterDocList)
+  {
     this.filterDocList = filterDocList;
+  }
   /**
-            berkley
+   * 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
+  /**
-            jones
+   * method to set the list of fields to be returned by this query
    */
   public void setReturnFieldList(Vector returnFieldList)
+  {
     this.returnFieldList = returnFieldList;
+  }
   /**
    * Accessor method to return a vector of the owner fields as
    * defined in the &lt;owner&gt; tag in the pathquery dtd.
    */
   public Vector getOwnerList()
+  {
     return this.ownerList;
+  }
   /**
    * method to set the list of owners used to constrain this query
    */
   public void setOwnerList(Vector ownerList)
+  {
     this.ownerList = ownerList;
+  }
   /**
    * Accessor method to return a vector of the site fields as
    * defined in the &lt;site&gt; tag in the pathquery dtd.
    */
   public Vector getSiteList()
+  {
     return this.siteList;
+  }
   /**
    * method to set the list of sites used to constrain this query
    */
   public void setSiteList(Vector siteList)
+  {
     this.siteList = siteList;
+  }
   /**
    * get the QueryGroup used to express query constraints
    */
   public QueryGroup getQueryGroup()
+  {
     return query;
+  }
   /**
-            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) {
-            berkley
+       System.err.println("Error in QuerySpcecification.initializeParser " +
                            e.toString());
             jones
     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;
-            jones
+    } 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")) {
-            jones
+      returnDocList.add(inputString);
-            jones
+    } else if (currentTag.equals("filterdoctype")) {
       filterDocList.add(inputString);
-            berkley
+    } else if (currentTag.equals("returnfield")) {
-            tao
+      // make sure if return fields has an attribute or not
       if (inputString.indexOf(ATTRIBUTESYMBOL) ==-1)
+      {
         // no attribute value will be returned
         returnFieldList.add(inputString);
         containsExtendedSQL = true;
+      }
       else
+      {
         // has a attribute return field
         // divied the return filed into two parts, one is path and the
         // other is attribue name
         String returnPath = newPathExpressionWithOutAttribute(inputString);
         String attributeName = getAttributeName(inputString);
         Vector pathInfo = new Vector();
         // the vector has the information about return path and attributename
         pathInfo.addElement(returnPath);
         pathInfo.addElement(attributeName);
         // put the vector into a hash table. The reseaon why don't put
         // return path or attributename as a key is because they are not unique
         attributeReturnList.put
                             (new Integer(countAttributeReturnField), pathInfo);
         countAttributeReturnField++;
         hasAttributeReturnField = true;
         containsExtendedSQL = true;
+      }
-            jones
+    } else if (currentTag.equals("filterdoctype")) {
       filterDocList.add(inputString);
-            jones
+    } else if (currentTag.equals("owner")) {
       ownerList.add(inputString);
     } else if (currentTag.equals("site")) {
       siteList.add(inputString);
             jones
+  }
-            jones
+  /**
    * create a SQL serialization of the query that this instance represents
    */
-            bojilova
+  public String printSQL(boolean useXMLIndex) {
             tao
-            jones
+    StringBuffer self = new StringBuffer();
-            bojilova
+    self.append("SELECT docid,docname,doctype,");
-            berkley
+    self.append("date_created, date_updated, rev ");
-            jones
+    self.append("FROM xml_documents WHERE docid IN (");
             jones
-            jones
+    // This determines the documents that meet the query conditions
-            bojilova
+    self.append(query.printSQL(useXMLIndex));
             jones
     self.append(") ");
             berkley
-            jones
+    // Add SQL to filter for doctypes requested in the query
-            jones
+    // This is an implicit OR for the list of doctypes. Only doctypes in this
     // list will be searched if the tag is present
     if (!filterDocList.isEmpty()) {
-            jones
+      boolean firstdoctype = true;
       self.append(" AND (");
-            jones
+      Enumeration en = filterDocList.elements();
-            jones
+      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(") ");
+    }
             jones
-            jones
+    // Add SQL to filter for owners requested in the query
     // This is an implicit OR for the list of owners
     if (!ownerList.isEmpty()) {
       boolean first = true;
       self.append(" AND (");
       Enumeration en = ownerList.elements();
       while (en.hasMoreElements()) {
         String current = (String)en.nextElement();
         if (first) {
            first = false;
            self.append(" user_owner = '" + current + "'");
         } else {
           self.append(" OR user_owner = '" + current + "'");
+        }
+      }
       self.append(") ");
+    }
     // Add SQL to filter for sites requested in the query
     // This is an implicit OR for the list of sites
     if (!siteList.isEmpty()) {
       boolean first = true;
       self.append(" AND (");
       Enumeration en = siteList.elements();
       while (en.hasMoreElements()) {
         String current = (String)en.nextElement();
         if (first) {
            first = false;
            self.append(" SUBSTR(docid, 1, INSTR(docid, '" +
                accNumberSeparator + "')-1) = '" + current + "'");
         } else {
           self.append(" OR SUBSTR(docid, 1, INSTR(docid, '" +
                accNumberSeparator + "')-1) = '" + current + "'");
+        }
+      }
       self.append(") ");
+    }
             tao
     // if there is only one percentage search item, this query is a percentage
     // search query
     if (countPercentageSearchItem ==1)
+    {
       percentageSearch =true;
+    }
-            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
-            berkley
+   * @param doclist the list of document ids to search by
-            berkley
+   */
-            berkley
+  public String printExtendedSQL(String doclist)
             berkley
     StringBuffer self = new StringBuffer();
-            tao
+    self.append("select xml_nodes.docid, xml_index.path, xml_nodes.nodedata, ");
     self.append("xml_nodes.parentnodeid ");
-            berkley
+    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(doclist);
-            berkley
+    self.append(")");
-            berkley
+    self.append(" AND xml_nodes.nodetype = 'TEXT'");
             berkley
             tao
-            berkley
+    return self.toString();
+  }
             berkley
-            tao
+  /**
    * This method prints sql based upon the returnfield tag in the
    * pathquery document has an attribute.  This allows for customization of the
    * returned fields
    * @param doclist the list of document ids to search by
    */
   public String printAttributeQuery(String doclist)
+  {
     StringBuffer self = new StringBuffer();
     self.append("select xml_nodes.docid, xml_index.path, ");
     self.append("xml_nodes.nodedata, xml_nodes.nodename ");
     self.append("from xml_index, xml_nodes where xml_index.nodeid=");
     self.append("xml_nodes.parentnodeid and (");
     boolean firstfield = true;
     //put the returnfields attributes into the query
     //the for loop allows for multiple fields and attributes
     Enumeration returnAttributes = attributeReturnList.elements();
     while (returnAttributes.hasMoreElements())
+    {
       Vector currentVector = (Vector)returnAttributes.nextElement();
       String returnPath = (String)currentVector.elementAt(0);
       String attributeName = (String)currentVector.elementAt(1);
       if(firstfield)
+      {
         firstfield = false;
         self.append("( xml_index.path like '");
         self.append(returnPath);
         self.append("' AND xml_nodes.nodename like '");
         self.append(attributeName);
         self.append("') ");
+      }
       else
+      {
         self.append(" or ( xml_index.path like '");
         self.append(returnPath);
         self.append("' AND xml_nodes.nodename like '");
         self.append(attributeName);
         self.append("') ");
+      }
+    }
     self.append(") AND xml_nodes.docid in (");
     //self.append(query.printSQL());
     self.append(doclist);
     self.append(")");
     self.append(" AND xml_nodes.nodetype = 'ATTRIBUTE'");
     MetaCatUtil.debugMessage("Attribute query: "+self.toString(), 30);
     return self.toString();
+  }
-            berkley
+  public static String printRelationSQL(String docid)
+  {
     StringBuffer self = new StringBuffer();
-            berkley
+    self.append("select subject, relationship, object, subdoctype, ");
     self.append("objdoctype from xml_relation ");
-            jones
+    self.append("where docid like '").append(docid).append("'");
-            berkley
+    return self.toString();
+  }
             berkley
-            jones
+  /**
-            berkley
+   * Prints sql that returns all relations in the database.
-            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 ");
-            jones
+    self.append("'triple/subject') s, (select nodeid, parentnodeid ");
-            berkley
+    self.append("from xml_index where path like ");
-            jones
+    self.append("'triple/relationship') rel, ");
-            berkley
+    self.append("(select nodeid, parentnodeid from xml_index where path like ");
-            jones
+    self.append("'triple/object') o, ");
-            berkley
+    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 ");
-            berkley
+    self.append("and x.parentnodeid in (rel.nodeid) ");
     self.append("and y.parentnodeid in (o.nodeid) ");
     self.append("and z.parentnodeid in (s.nodeid) ");
-            berkley
+    //self.append("and z.nodedata like '%");
     //self.append(docid);
     //self.append("%'");
     return self.toString();
+  }
   /**
-            berkley
+   * Prints sql that returns all relations in the database that were input
    * under a specific docid
    * @param docid the docid to search for.
    */
   public static String printPackageSQL(String docid)
+  {
     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 ");
-            jones
+    self.append("'triple/subject') s, (select nodeid, parentnodeid ");
-            berkley
+    self.append("from xml_index where path like ");
-            jones
+    self.append("'triple/relationship') rel, ");
-            berkley
+    self.append("(select nodeid, parentnodeid from xml_index where path like ");
-            jones
+    self.append("'triple/object') o, ");
-            berkley
+    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 ");
-            berkley
+    self.append("and x.parentnodeid in (rel.nodeid) ");
     self.append("and y.parentnodeid in (o.nodeid) ");
     self.append("and z.parentnodeid in (s.nodeid) ");
-            berkley
+    self.append("and z.docid like '").append(docid).append("'");
     return self.toString();
+  }
   /**
    * Returns all of the relations that has a certain docid in the subject
    * or the object.
+   *
    * @param docid the docid to search for
    */
   public static String printPackageSQL(String subDocidURL, String objDocidURL)
+  {
     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 ");
-            jones
+    self.append("'triple/subject') s, (select nodeid, parentnodeid ");
-            berkley
+    self.append("from xml_index where path like ");
-            jones
+    self.append("'triple/relationship') rel, ");
-            berkley
+    self.append("(select nodeid, parentnodeid from xml_index where path like ");
-            jones
+    self.append("'triple/object') o, ");
-            berkley
+    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 ");
-            berkley
+    self.append("and x.parentnodeid in (rel.nodeid) ");
     self.append("and y.parentnodeid in (o.nodeid) ");
     self.append("and z.parentnodeid in (s.nodeid) ");
-            berkley
+    self.append("and (z.nodedata like '");
     self.append(subDocidURL);
     self.append("' or y.nodedata like '");
     self.append(objDocidURL);
     self.append("')");
     return self.toString();
+  }
   public static String printGetDocByDoctypeSQL(String docid)
+  {
     StringBuffer self = new StringBuffer();
-            bojilova
+    self.append("SELECT docid,docname,doctype,");
-            berkley
+    self.append("date_created, date_updated ");
     self.append("FROM xml_documents WHERE docid IN (");
     self.append(docid).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() {
-            bojilova
+    return "meta_file_id=" + meta_file_id + "\n" + query;
 //DOCTITLE attr cleared from the db
 //    return "meta_file_id=" + meta_file_id + "\n" +
 //           "querytitle=" + querytitle + "\n" + query;
             jones
             tao
   /* A method to get rid of attribute part in path expression*/
   public static String newPathExpressionWithOutAttribute(String pathExpression)
+  {
       if (pathExpression == null)
+      {
         return null;
+      }
       int index = pathExpression.lastIndexOf(ATTRIBUTESYMBOL);
       String newExpression = null;
       if (index != 1)
+      {
         newExpression=pathExpression.substring(0, index-1);
+      }
       MetaCatUtil.debugMessage("The path expression without attributes: )" +
                                newExpression, 30);
       return newExpression;
+  }
   /* A method to get attribute name from path */
   public static String getAttributeName(String path)
+  {
       if (path == null)
+      {
         return null;
+      }
       int index = path.lastIndexOf(ATTRIBUTESYMBOL);
       int size = path.length();
       String attributeName = null;
        if (index != 1)
+      {
         attributeName = path.substring(index+1, size);
+      }
       MetaCatUtil.debugMessage("The attirbute name from path: )" +
                                attributeName, 30);
       return attributeName;
+  }
             jones
-            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
      */
-            bojilova
+    public String printSQL(boolean useXMLIndex) {
-            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;
-            bojilova
+          self.append(qg.printSQL(useXMLIndex));
-            jones
+        } else if (qobject instanceof QueryTerm) {
           QueryTerm qt = (QueryTerm)qobject;
-            bojilova
+          self.append(qt.printSQL(useXMLIndex));
-            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;
-            tao
+    private boolean percentageSymbol = false;
             jones
-            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
      */
-            bojilova
+    public String printSQL(boolean useXMLIndex) {
-            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
-            bojilova
+      //String searchvalue = null;
       String searchexpr = null;
-            jones
+      if (searchmode.equals("starts-with")) {
-            bojilova
+        //searchvalue = casevalue + "%";
         searchexpr = nodedataterm + " LIKE '" + casevalue + "%' ";
-            jones
+      } else if (searchmode.equals("ends-with")) {
-            bojilova
+        //searchvalue = "%" + casevalue;
         searchexpr = nodedataterm + " LIKE '%" + casevalue + "' ";
-            jones
+      } else if (searchmode.equals("contains")) {
-            bojilova
+        //searchvalue = "%" + casevalue + "%";
-            tao
+        if (!casevalue.equals("%"))
+        {
           searchexpr = nodedataterm + " LIKE '%" + casevalue + "%' ";
+        }
         else
+        {
           searchexpr = nodedataterm + " LIKE '" + casevalue + "' ";
-            tao
+          // find percentage symbol
           percentageSymbol = true;
             tao
-            bojilova
+      } 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
-            tao
+          // 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 ";
-            bojilova
+          searchexpr = nodedataterm + " " + oper + " " +
-            tao
+                       new Double(casevalue) + " "+getRidOfString;
-            bojilova
+        } catch (NumberFormatException nfe) {
           // these are characters; character comparison
           searchexpr = nodedataterm + " " + oper + " '" + casevalue + "' ";
+        }
             jones
-            jones
+      self.append("SELECT DISTINCT docid FROM xml_nodes WHERE \n");
-            bojilova
+      //self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");
       self.append(searchexpr);
             jones
-            tao
+      if (pathexpr != null)
+      {
-            bojilova
+        // use XML Index
-            tao
+        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);
+          }
-            bojilova
+          self.append("(SELECT nodeid FROM xml_index WHERE path LIKE " +
                       "'" +  pathexpr + "') " );
             tao
         else
+        {
           // without using XML Index; using nested statements instead
           self.append("AND parentnodeid IN ");
-            bojilova
+          self.append(useNestedStatements(pathexpr));
+        }
             jones
-            tao
+      else
+      {
         //if pathexpr is null and search value is %, is a percentageSearchItem
         // the count number will be increase one
         countPercentageSearchItem++;
+       }
             jones
       return self.toString();
+    }
             tao
     /* A method to judge if a path have attribute */
     private boolean hasAttributeInPath(String path)
+    {
       if (path.indexOf(ATTRIBUTESYMBOL)!=-1)
+      {
         return true;
+      }
       else
+      {
         return false;
+      }
+    }
             tao
             tao
-            bojilova
+    /*
      * 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("/");
             tao
-            bojilova
+        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(")");
+      }
             tao
-            bojilova
+      return nestedStmts.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.
      */
-            bojilova
+    public String toString() {
             jones
-            bojilova
+      return this.printSQL(true);
             jones
             jones
             jones

Project

General

Profile

Metacat