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

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

-            jones
+/**
-            jones
+ *  '$RCSfile$'
-            tao
+ *    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
-            jones
+ *             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;
-            jones
+import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.Enumeration;
-            tao
+import java.util.Hashtable;
-            jones
+import java.util.Stack;
-            jones
+import java.util.Vector;
             jones
-            jones
+import edu.ucsb.nceas.dbadapter.AbstractDatabase;
-            sgarg
+import org.apache.log4j.Logger;
-            jones
+import org.xml.sax.Attributes;
-            jones
+import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
-            jones
+import org.xml.sax.XMLReader;
-            jones
+import org.xml.sax.helpers.DefaultHandler;
-            jones
+import org.xml.sax.helpers.XMLReaderFactory;
-            sgarg
+import java.util.Iterator;
             jones
-            berkley
+/**
-            jones
+ * A Class that represents a structured query, and can be constructed from an
  * XML serialization conforming to
             tao
-            jones
+ * @see pathquery.dtd. The printSQL() method can be used to print a SQL
  *      serialization of the query.
-            jones
+ */
-            jones
+public class QuerySpecification extends DefaultHandler
+{
             tao
-            jones
+    /** flag determining whether extended query terms are present */
     private boolean containsExtendedSQL = false;
             jones
-            jones
+    /** Identifier for this query document */
     private String meta_file_id;
             jones
-            jones
+    /** Title of this query */
     private String queryTitle;
     /** List of document types to be returned using package back tracing */
     private Vector returnDocList;
     /** List of document types to be searched */
     private Vector filterDocList;
     /** List of fields to be returned in result set */
     private Vector returnFieldList;
     /** List of users owning documents to be searched */
     private Vector ownerList;
     /** The root query group that contains the recursive query constraints */
     private QueryGroup query = null;
     // Query data structures used temporarily during XML parsing
     private Stack elementStack;
     private Stack queryStack;
     private String currentValue;
     private String currentPathexpr;
     private String parserName = null;
     private String accNumberSeparator = null;
     private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;
     private boolean percentageSearch = false;
     private String userName = null;
     private static final String PUBLIC = "public";
     private String[] group = null;
     public static final String ATTRIBUTESYMBOL = "@";
     private boolean hasAttributeReturnField = false;
     private Hashtable attributeReturnList = new Hashtable();
     private int countAttributeReturnField = 0;
-            tao
+    private StringBuffer textBuffer = new StringBuffer();
-            sgarg
+    private static Logger logMetacat = Logger.getLogger(QuerySpecification.class);
-            jones
+    /**
      * construct an instance of the QuerySpecification class
             tao
-            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 the
      *            org.xml.sax.XMLReader interface
      */
     public QuerySpecification(Reader queryspec, String parserName,
             String accNumberSeparator) throws IOException
+    {
         super();
         // Initialize the class variables
         returnDocList = new Vector();
         filterDocList = new Vector();
         elementStack = new Stack();
         queryStack = new Stack();
         returnFieldList = new Vector();
         ownerList = new Vector();
         this.parserName = parserName;
         this.accNumberSeparator = accNumberSeparator;
         // 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 in "
                     + "QuerySpecification.QuerySpecification");
             System.err.println(e.getMessage());
+        }
             jones
             jones
     /**
      * construct an instance of the QuerySpecification class
             tao
-            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
      */
     public QuerySpecification(String queryspec, String parserName,
             String accNumberSeparator) throws IOException
+    {
         this(new StringReader(queryspec), parserName, accNumberSeparator);
             jones
-            jones
+    /**
      * construct an instance of the QuerySpecification class which don't need
      * to parser a xml document
             tao
-            jones
+     * @param accNumberSeparator
      *            the separator between doc version
      */
     public QuerySpecification(String accNumberSeparator) throws IOException
             tao
-            jones
+        // Initialize the class variables
         returnDocList = new Vector();
         filterDocList = new Vector();
         elementStack = new Stack();
         queryStack = new Stack();
         returnFieldList = new Vector();
         ownerList = new Vector();
         this.accNumberSeparator = accNumberSeparator;
             tao
             jones
     /**
      * Method to set user name
             tao
-            jones
+     * @param myName
      *            the user name
      */
     public void setUserName(String myName)
             tao
-            jones
+        //to lower case
         if (myName != null) {
             this.userName = myName.toLowerCase();
         } else {
             this.userName = myName;
+        }
             tao
             jones
     /**
      * Method to set user group
             tao
-            jones
+     * @param myGroup
      *            the user group
      */
     public void setGroup(String[] myGroup)
             tao
-            jones
+        this.group = myGroup;
             tao
             jones
     /**
      * Method to indicate this query is a percentage search
      */
     public boolean isPercentageSearch()
             tao
-            jones
+        return percentageSearch;
             tao
             jones
     /*
      * Method to get owner query. If it is owner it has all permission
      */
     private String createOwerQuery()
             tao
-            jones
+        String ownerQuery = null;
         ownerQuery = "SELECT docid FROM xml_documents WHERE ";
         if (userName != null && !userName.equals("")) {
             ownerQuery = ownerQuery + "lower(user_owner) ='" + userName + "'";
+        }
             jones
-            sgarg
+        logMetacat.info("OwnerQuery: " + ownerQuery);
-            jones
+        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()
             tao
-            jones
+        String allowQuery = null;
         String allowString = constructAllowString();
         allowQuery = "SELECT docid from xml_access WHERE( " + allowString;
         allowQuery = allowQuery + ") AND subtreeid IS NULL";
-            sgarg
+        logMetacat.info("allow query is: " + allowQuery);
-            jones
+        return allowQuery;
             tao
             jones
     /* Method to construct a allow rule string */
     private String constructAllowString()
             tao
-            jones
+        String allowQuery = "";
         // add allow rule for user name
         if (userName != null && !userName.equals("")) {
             allowQuery = allowQuery + "(lower(principal_name) = '" + userName
                     + "' AND perm_type = 'allow'"
                     + " AND (permission='4' OR permission='7'))";
+        }
         // add allow rule for public
         allowQuery = allowQuery + "OR (lower(principal_name) = '" + PUBLIC
                 + "' AND perm_type = 'allow'"
                 + " AND (permission='4' OR permission='7'))";
         // 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("")) {
                     groupUint = groupUint.toLowerCase();
                     allowQuery = allowQuery + " OR (lower(principal_name) = '"
                             + groupUint + "' AND perm_type = 'allow'"
                             + " AND (permission='4' OR permission='7'))";
                 }//if
             }//for
-            tao
+        }//if
-            sgarg
+        logMetacat.info("allow string is: " + allowQuery);
-            jones
+        return allowQuery;
+    }
             jones
-            jones
+    /*
      * 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;
         String denyString = constructDenyString();
         denyQuery = "SELECT docid from xml_access WHERE( " + denyString;
         denyQuery = denyQuery + ") AND subtreeid IS NULL ";
-            sgarg
+        logMetacat.info("denyquery is: " + denyQuery);
-            jones
+        return denyQuery;
             jones
             jones
             jones
-            jones
+    /* Construct deny string */
     private String constructDenyString()
             berkley
-            jones
+        String denyQuery = "";
         // add deny rule for user name
         if (userName != null && !userName.equals("")) {
             denyQuery = denyQuery + "(lower(principal_name) = '" + userName
                     + "' AND perm_type = 'deny' "
                     + "AND perm_order ='allowFirst'"
                     + " AND (permission='4' OR permission='7'))";
+        }
         // add deny rule for public
         denyQuery = denyQuery + "OR (lower(principal_name) = '" + PUBLIC
                 + "' AND perm_type = 'deny' " + "AND perm_order ='allowFirst'"
                 + " AND (permission='4' OR permission='7'))";
         // 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("")) {
                     groupUint = groupUint.toLowerCase();
                     denyQuery = denyQuery + " OR (lower(principal_name) = '"
                             + groupUint + "' AND perm_type = 'deny' "
                             + "AND perm_order ='allowFirst'"
                             + " AND (permission='4' OR permission='7'))";
                 }//if
             }//for
         }//if
         return denyQuery;
             berkley
             jones
     /**
      * 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
             tao
-            jones
+     */
     public String getAccessQuery()
             berkley
-            jones
+        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 + ")))";
-            sgarg
+        logMetacat.warn("accessquery is: " + accessQuery);
-            jones
+        return accessQuery;
             berkley
             jones
-            jones
+    /**
      * 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;
+        }
+    }
             jones
-            jones
+    /**
      * A method to get if the query has an attribute return field
      */
-            cjones
+    public boolean containsAttributeReturnField()
             jones
         return hasAttributeReturnField;
+    }
             jones
-            jones
+    /**
      * Accessor method to return the identifier of this Query
      */
     public String getIdentifier()
+    {
         return meta_file_id;
+    }
             jones
-            jones
+    /**
      * method to set the identifier of this query
      */
     public void setIdentifier(String id)
+    {
         this.meta_file_id = id;
+    }
             jones
-            jones
+    /**
      * Accessor method to return the title of this Query
      */
     public String getQueryTitle()
+    {
         return queryTitle;
+    }
             jones
-            jones
+    /**
      * method to set the title of this query
      */
     public void setQueryTitle(String title)
+    {
         this.queryTitle = title;
+    }
             jones
-            jones
+    /**
      * 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;
+    }
             jones
-            jones
+    /**
      * method to set the list of return docs of this query
      */
     public void setReturnDocList(Vector returnDocList)
+    {
         this.returnDocList = returnDocList;
+    }
             jones
-            jones
+    /**
      * 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;
+    }
             jones
-            jones
+    /**
      * method to set the list of filter docs of this query
      */
     public void setFilterDocList(Vector filterDocList)
+    {
         this.filterDocList = filterDocList;
+    }
             jones
-            jones
+    /**
      * 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
+    /**
      * method to set the list of fields to be returned by this query
      */
     public void setReturnFieldList(Vector returnFieldList)
+    {
         this.returnFieldList = returnFieldList;
+    }
             jones
-            jones
+    /**
      * 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;
+    }
             jones
-            jones
+    /**
      * method to set the list of owners used to constrain this query
      */
     public void setOwnerList(Vector ownerList)
+    {
         this.ownerList = ownerList;
             jones
-            jones
+    /**
      * get the QueryGroup used to express query constraints
      */
     public QueryGroup getQueryGroup()
+    {
         return query;
             jones
             jones
-            jones
+    /**
      * set the querygroup
      */
     public void setQueryGroup(QueryGroup group)
+    {
         query = group;
             jones
-            jones
+    /**
      * set if this query sepcification has extendQuery(has return doc type or
      * not)
      */
     public void setContainsExtenedSQL(boolean hasExtenedQuery)
+    {
         containsExtendedSQL = hasExtenedQuery;
+    }
             jones
-            jones
+    /**
      * 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("Error in QuerySpcecification.initializeParser "
                     + e.toString());
+        }
         return parser;
             tao
             jones
-            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.
      */
     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));
+            }
+        }
             jones
-            jones
+        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);
+        }
+    }
             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.
      */
     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();
-            tao
+        } else if (leaving.getTagName().equals("meta_file_id")) {
               meta_file_id = textBuffer.toString().trim();
         } else if (leaving.getTagName().equals("querytitle")) {
               queryTitle = textBuffer.toString().trim();
         } else if (leaving.getTagName().equals("value")) {
               currentValue = textBuffer.toString().trim();
         } else if (leaving.getTagName().equals("pathexpr")) {
               currentPathexpr = textBuffer.toString().trim();
         } else if (leaving.getTagName().equals("returndoctype")) {
               returnDocList.add(textBuffer.toString().trim());
         } else if (leaving.getTagName().equals("filterdoctype")) {
               filterDocList.add(textBuffer.toString().trim());
         } else if (leaving.getTagName().equals("returnfield")) {
               handleReturnField(textBuffer.toString().trim());
         } else if (leaving.getTagName().equals("filterdoctype")) {
               filterDocList.add(textBuffer.toString().trim());
         } else if (leaving.getTagName().equals("owner")) {
               ownerList.add(textBuffer.toString().trim());
             jones
             tao
         //rest textBuffer
         textBuffer = null;
         textBuffer = new StringBuffer();
             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.
      */
     public void characters(char ch[], int start, int length)
+    {
-            tao
+      // buffer all text nodes for same element. This is for text was splited
       // into different nodes
       textBuffer.append(new String(ch, start, length));
             jones
+    }
     /**
      * Method to transfer string to return field
      */
     public void handleReturnField(String inputString)
+    {
         // make sure if return fields has an attribute or not
         if (inputString.indexOf(ATTRIBUTESYMBOL) == -1) {
             // no attribute value will be returned
-            sgarg
+            logMetacat.info("QuerySpecification.handleReturnField(): " );
             logMetacat.info("  there are no attributes in the XPATH statement" );
-            jones
+            returnFieldList.add(inputString);
             containsExtendedSQL = true;
-            jones
+        } else {
             sgarg
-            cjones
+          if ( inputString.startsWith(ATTRIBUTESYMBOL) ) {
             sgarg
-            cjones
+            // case where the return field is solely an attribute
-            sgarg
+            logMetacat.info("QuerySpecification.handleReturnField(): " );
             logMetacat.info("  there are *only* attributes in the XPATH statement" );
-            cjones
+            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;
-            cjones
+            containsExtendedSQL = true;
           } else {
-            jones
+            // has a attribute return field
             // divied the return filed into two parts, one is path and the
             // other is attribue name
-            sgarg
+            logMetacat.info("QuerySpecification.handleReturnField: " );
             logMetacat.info("  there are both attributes and elements" );
             logMetacat.info("  in the XPATH statement" );
-            jones
+            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;
             cjones
             jones
+    }
-            jones
+    /**
      * create a SQL serialization of the query that this instance represents
      */
     public String printSQL(boolean useXMLIndex)
+    {
         StringBuffer self = new StringBuffer();
-            sgarg
+        StringBuffer queryString = new StringBuffer();
             jones
-            sgarg
+        queryString.append("SELECT docid,docname,doctype,");
         queryString.append("date_created, date_updated, rev ");
         queryString.append("FROM xml_documents WHERE");
             jones
-            sgarg
+        // Get the query from the QueryGroup and check
         // if no query has been returned
         String queryFromQueryGroup = query.printSQL(useXMLIndex);
-            sgarg
+        logMetacat.info("Query from query in QuerySpec.printSQL: "
         		+ queryFromQueryGroup);
-            sgarg
+        if(!queryFromQueryGroup.trim().equals("")){
-            sgarg
+            self.append(" docid IN (");
-            sgarg
+            self.append(queryFromQueryGroup);
-            sgarg
+            self.append(") ");
+        }
             jones
         // Add SQL to filter for doctypes requested in the query
         // 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()) {
             boolean firstdoctype = true;
-            sgarg
+            boolean emptyString = true;
             if(!self.toString().equals("")){
                 self.append(" AND (");
                 emptyString = false;
+            }
-            jones
+            Enumeration en = filterDocList.elements();
             while (en.hasMoreElements()) {
                 String currentDoctype = (String) en.nextElement();
                 if (firstdoctype) {
                     firstdoctype = false;
                     self.append(" doctype = '" + currentDoctype + "'");
                 } else {
                     self.append(" OR doctype = '" + currentDoctype + "'");
+                }
+            }
             sgarg
             if(!emptyString){
                 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;
-            sgarg
+            boolean emptyString = true;
             if(!self.toString().equals("")){
                 self.append(" AND (");
                 emptyString = false;
+            }
-            jones
+            Enumeration en = ownerList.elements();
             while (en.hasMoreElements()) {
                 String current = (String) en.nextElement();
                 if (current != null) {
                     current = current.toLowerCase();
+                }
                 if (first) {
                     first = false;
                     self.append(" lower(user_owner) = '" + current + "'");
                 } else {
                     self.append(" OR lower(user_owner) = '" + current + "'");
+                }
+            }
             sgarg
             if(!emptyString){
                 self.append(") ");
+            }
             jones
         // if there is only one percentage search item, this query is a
         // percentage
         // search query
-            sgarg
+        logMetacat.info("percentage number: "
                 + query.getPercentageSymbolCount());
-            jones
+        if (query.getPercentageSymbolCount() == 1) {
-            sgarg
+            logMetacat.info("It is a percentage search");
-            jones
+            percentageSearch = true;
+        }
-            sgarg
+        queryString.append(self.toString());
         return queryString.toString();
             jones
             jones
     /**
      * This sql command will selecet startnodeid and endnodeid that user can
      * NOT access
      */
     public String printAccessControlSQLForReturnField(String doclist)
             tao
-            jones
+        StringBuffer sql = new StringBuffer();
         String allowString = constructAllowString();
         String denyString = constructDenyString();
         sql.append("SELECT distinct startnodeid, endnodeid from xml_access ");
         sql.append("WHERE docid in (");
         sql.append(doclist);
         sql.append(") AND startnodeid IS NOT NULL AND ");
         sql.append("(");
         sql.append("(");
-            jones
+        sql
                 .append("startnodeid NOT IN (SELECT startnodeid from xml_access, xml_documents ");
-            jones
+        sql.append(" WHERE xml_access.docid = xml_documents.docid");
         sql.append(" AND lower(xml_documents.user_owner) ='");
         sql.append(userName);
         sql.append("' AND xml_access.startnodeid IS NOT NULL)");
         sql.append(")");
         sql.append(" AND ");
         sql.append("(");
-            jones
+        sql
                 .append("(startnodeid NOT IN (SELECT startnodeid from xml_access where( ");
-            jones
+        sql.append(allowString);
         sql.append(") AND (startnodeid IS NOT NULL))");
         sql.append(")");
-            jones
+        sql
                 .append(" OR (startnodeid IN (SELECT startnodeid from xml_access where( ");
-            jones
+        sql.append(denyString);
         sql.append(") AND (startnodeid IS NOT NULL))");
         sql.append(")");
         sql.append(")");
         sql.append(")");
-            sgarg
+        logMetacat.info("accessControlSQLForReturnField: "
                 + sql.toString());
-            jones
+        return sql.toString();
             tao
             jones
     /**
      * This method prints sql based upon the &lt;returnfield&gt; tag in the
-            jones
+     * pathquery document. This allows for customization of the returned fields.
-            tao
+     * If the boolean useXMLIndex paramter is false, it uses a recursive query on
      * xml_nodes to find the fields to be included by their path expression, and
-            jones
+     * avoids the use of the xml_index table.
             tao
-            jones
+     * @param doclist the list of document ids to search
-            tao
+     * @param unaccessableNodePair the node pairs (start id and end id) which
-            jones
+     *            this user should not access
-            tao
+     * @param useXMLIndex a boolean flag indicating whether to search using
-            jones
+     *            xml_index
-            jones
+     */
     public String printExtendedSQL(String doclist,
             Hashtable unaccessableNodePair, boolean useXMLIndex)
+    {
         if (useXMLIndex) {
             return printExtendedSQL(doclist, unaccessableNodePair);
         } else {
             StringBuffer self = new StringBuffer();
             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;
                 } else {
-            tao
+                    self.append(" UNION ");
             jones
                 String path  = (String) returnFieldList.elementAt(i);
                 self.append("select xml_nodes.docid, ");
-            jones
+                self.append("'"+ path  + "' as path, xml_nodes.nodedata, ");
-            jones
+                self.append("xml_nodes.parentnodeid ");
                 self.append("from xml_nodes, xml_documents ");
                 self.append("where parentnodeid IN ");
                 self.append(QueryTerm.useNestedStatements(path));
             tao
-            jones
+                self.append(" AND xml_nodes.docid in (");
                 self.append(doclist);
-            jones
+                self.append(") AND xml_nodes.nodetype = 'TEXT'");
-            jones
+                self.append(" AND xml_nodes.rootnodeid = xml_documents.rootnodeid");
             tao
-            jones
+                addAccessRestrictionSQL(unaccessableNodePair, self);
             jones
             return self.toString();
+        }
+    }
             tao
-            jones
+    /**
      * This method prints sql based upon the &lt;returnfield&gt; tag in the
      * pathquery document. This allows for customization of the returned fields.
      * It uses the xml_index table and so assumes that this table has been
      * built.
             tao
-            jones
+     * @param doclist the list of document ids to search
-            tao
+     * @param unaccessableNodePair the node pairs (start id and end id)
-            jones
+     *            which this user should not access
-            jones
+     */
-            tao
+    public String printExtendedSQL(String doclist,
-            jones
+            Hashtable unaccessableNodePair)
             berkley
-            sgarg
+        logMetacat.info("querySpecification.printExtendedSQL called\n");
-            jones
+        StringBuffer self = new StringBuffer();
             cjones
-            sgarg
+        boolean usePathIndex = true;
             sgarg
-            sgarg
+        // test if the are elements in the return fields
         if ( returnFieldList.size() == 0 ) {
             return null;
+        }
             jones
-            sgarg
+        for (int i = 0; i < returnFieldList.size(); i++) {
             if(!MetaCatUtil.pathsForIndexing.contains
                (returnFieldList.elementAt(i))){
                 usePathIndex = false;
                 break;
+            }
+        }
             jones
-            sgarg
+        if(usePathIndex){
             self.append("select docid, path, nodedata, parentnodeid ");
             self.append("from xml_path_index where (path like '");
             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;
                     self.append( (String) returnFieldList.elementAt(i));
                     self.append("' ");
+                }
                 else {
                     self.append("or path like '");
                     self.append( (String) returnFieldList.elementAt(i));
                     self.append("' ");
+                }
+            }
             self.append(") AND docid in (");
             self.append(doclist);
             self.append(")");
         } else {
             self.append("select xml_nodes.docid, xml_index.path, xml_nodes.nodedata,  ");
             self.append("xml_nodes.parentnodeid ");
             self.append("from xml_index, xml_nodes where xml_index.nodeid=");
             self.append("xml_nodes.parentnodeid and (xml_index.path like '");
             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;
                     self.append((String) returnFieldList.elementAt(i));
                     self.append("' ");
                 } else {
                     self.append("or xml_index.path like '");
                     self.append((String) returnFieldList.elementAt(i));
                     self.append("' ");
+                }
+            }
             self.append(") AND xml_nodes.docid in (");
             self.append(doclist);
             self.append(") AND xml_nodes.nodetype = 'TEXT'");
+        }
         addAccessRestrictionSQL(unaccessableNodePair, self);
         return self.toString();
             jones
             sgarg
-            jones
+    /**
-            sgarg
+     * Method to return a String generated after sorting the returnFieldList
      * Vector
      */
     public String getSortedReturnFieldString(){
         String returnFields = "";
         // Create a temporary vector and copy returnFieldList into it
         Vector tempVector = new Vector();
             sgarg
-            sgarg
+        Iterator it = returnFieldList.iterator();
         while(it.hasNext()){
             tempVector.add(it.next());
+        }
-            sgarg
+        Enumeration attEnum = attributeReturnList.elements();
         while(attEnum.hasMoreElements()){
             Iterator tempIt = ((Vector)attEnum.nextElement()).iterator();
 	    String rfield = "";
             if(tempIt.hasNext()){
 		String element = (String)tempIt.next();
-            sgarg
+		if(element != null) {
 		    rfield +=element;
             sgarg
+	    }
             if(tempIt.hasNext()){
 		String attribute = (String)tempIt.next();
-            sgarg
+		if(attribute != null) {
   		    rfield = rfield + "@" + attribute;
             sgarg
+	    }
             tempVector.add(rfield);
+        }
-            sgarg
+        // Sort the temporary vector
         java.util.Collections.sort(tempVector);
         // Generate the string and return it
         it = tempVector.iterator();
         while(it.hasNext()){
             returnFields = returnFields + it.next() + "|";
+        }
         return returnFields;
+    }
     /**
-            jones
+     * Create the SQl necessary to restrict access to allowed nodes.  This is
      * accomplished by restricting the nodes that are returned to include
      * only those whose IDs fall outside of a set of start/stop pairs of
      * nodeid values.  These pairs are passed in as a hash, with the key
      * containing the start nodeid and the value containing the end nodeid.
      * Any nodes between these start and end nodeid values will be excluded
      * from the results.
             tao
-            jones
+     * @param unaccessableNodePair hash of start/end nodeid pairs to restrict
-            tao
+     * @param self a stringbuffer to which the genrated SQL is appended
-            jones
+     */
-            tao
+    private void addAccessRestrictionSQL(Hashtable unaccessableNodePair,
-            jones
+            StringBuffer self)
+    {
-            jones
+        // add control part for extended query
         Enumeration en = unaccessableNodePair.keys();
         while (en.hasMoreElements()) {
             // Get control pairs in object
             Long startNodeIdObject = (Long) en.nextElement();
             Long endNodeIdObject = (Long) unaccessableNodePair
                     .get(startNodeIdObject);
             // change it to long
             long startNodeId = startNodeIdObject.longValue();
             long endNodeId = endNodeIdObject.longValue();
             // add into query
-            jones
+            self.append(" AND ( xml_nodes.nodeid < ");
-            jones
+            self.append(startNodeId);
             self.append(" OR xml_nodes.nodeid > ");
             self.append(endNodeId);
             self.append(")");
+        }
             berkley
             jones
-            jones
+    /**
-            jones
+     * This method prints sql that finds the values of attributes in the xml
      * documents based upon the whether the returnfield tag in the pathquery
-            tao
+     * document has an attribute symbol (@). This allows for customization of
-            jones
+     * the returned fields.
             tao
-            jones
+     * @param doclist the list of document ids to search
-            tao
+     * @param useXMLIndex a boolean flag indicating whether to search using
-            jones
+     *            xml_index
-            jones
+     */
-            jones
+    public String printAttributeQuery(String doclist, boolean useXMLIndex)
+    {
         if (useXMLIndex) {
             return printAttributeQuery(doclist);
         } else {
             StringBuffer self = new StringBuffer();
             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;
                 } else {
-            tao
+                    self.append(" UNION ");
             jones
                 self.append("select xml_nodes.docid, '");
                 self.append(returnPath);
                 self.append("' as path, xml_nodes.nodedata, xml_nodes.nodename ");
                 self.append("from xml_nodes, xml_documents ");
                 self.append("where parentnodeid IN ");
                 self.append(QueryTerm.useNestedStatements(returnPath));
                 self.append(" AND xml_nodes.nodename like '");
                 self.append(attributeName);
                 self.append("' AND xml_nodes.docid in (");
                 self.append(doclist);
                 self.append(") AND xml_nodes.nodetype = 'ATTRIBUTE'");
-            jones
+                self.append(" AND xml_nodes.rootnodeid = xml_documents.rootnodeid");
             jones
             tao
-            sgarg
+            logMetacat.warn("Attribute query: " + self.toString());
             jones
-            tao
+            return self.toString();
             jones
+    }
     /**
      * This method prints sql that finds the values of attributes in the xml
      * documents based upon the whether the returnfield tag in the pathquery
-            tao
+     * document has an attribute symbol (@). This allows for customization of
-            jones
+     * the returned fields.
             tao
-            jones
+     * @param doclist the list of document ids to search
      */
-            jones
+    public String printAttributeQuery(String doclist)
             tao
-            jones
+        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;
-            sgarg
+                self.append("( ");
                 if(returnPath != null){
                     self.append("xml_index.path like '");
                     self.append(returnPath);
                     self.append("' AND ");
-            cjones
+                }else {
-            sgarg
+                  logMetacat.info("QuerySpecification.printAttributeQuery: "
                    + "returnPath is: " + returnPath);
             sgarg
                 self.append("xml_nodes.nodename like '");
-            jones
+                self.append(attributeName);
                 self.append("') ");
             } else {
-            sgarg
+                self.append(" or (");
                 if(returnPath != null){
                     self.append("xml_index.path like '");
                     self.append(returnPath);
                     self.append("' AND ");
-            cjones
+                }else {
-            sgarg
+                  logMetacat.info("QuerySpecification.printAttributeQuery: "
                    + "returnPath is null: " + returnPath);
             sgarg
                 self.append("xml_nodes.nodename like '");
-            jones
+                self.append(attributeName);
                 self.append("') ");
+            }
+        }
         self.append(") AND xml_nodes.docid in (");
         self.append(doclist);
-            jones
+        self.append(") AND xml_nodes.nodetype = 'ATTRIBUTE'");
-            sgarg
+        logMetacat.warn("Attribute query: " + self.toString());
             jones
         return self.toString();
             tao
             berkley
-            jones
+    public static String printRelationSQL(String docid)
             tao
-            jones
+        StringBuffer self = new StringBuffer();
         self.append("select subject, relationship, object, subdoctype, ");
         self.append("objdoctype from xml_relation ");
         self.append("where docid like '").append(docid).append("'");
         return self.toString();
             tao
             jones
-            jones
+    public static String printGetDocByDoctypeSQL(String docid)
+    {
         StringBuffer self = new StringBuffer();
             berkley
-            jones
+        self.append("SELECT docid,docname,doctype,");
         self.append("date_created, date_updated ");
         self.append("FROM xml_documents WHERE docid IN (");
         self.append(docid).append(")");
         return self.toString();
+    }
             jones
-            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.
      */
     public String toString()
+    {
         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
+    /** A method to get rid of attribute part in path expression */
-            jones
+    public static String newPathExpressionWithOutAttribute(String pathExpression)
+    {
         if (pathExpression == null) { return null; }
         int index = pathExpression.lastIndexOf(ATTRIBUTESYMBOL);
         String newExpression = null;
-            cjones
+        if (index != 0) {
-            jones
+            newExpression = pathExpression.substring(0, index - 1);
+        }
-            sgarg
+        logMetacat.info("The path expression without attributes: "
                 + newExpression);
-            jones
+        return newExpression;
+    }
-            jones
+    /** A method to get attribute name from path */
-            jones
+    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);
+        }
-            sgarg
+        logMetacat.info("The attirbute name from path: "
                 + attributeName);
-            jones
+        return attributeName;
+    }
             jones

Project

General

Profile

Metacat