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

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

-            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
-            tao
+  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
   /**
-            tao
+   * construct an instance of the QuerySpecification class which don't need
    * to parser a xml document
    * @param accNumberSeparator  the separator between doc version
    */
   public QuerySpecification(String accNumberSeparator ) throws IOException
+  {
     // Initialize the class variables
     returnDocList = new Vector();
     filterDocList = new Vector();
     elementStack = new Stack();
     queryStack   = new Stack();
     returnFieldList = new Vector();
     ownerList = new Vector();
     siteList = new Vector();
     this.accNumberSeparator = accNumberSeparator;
+   }
   /**
-            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;
-            tao
+    ownerQuery = "SELECT docid FROM xml_documents WHERE ";
-            tao
+    if (userName != null && !userName.equals(""))
+    {
-            tao
+      ownerQuery = ownerQuery + "user_owner ='"+ userName +"'";
             tao
     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;
-            tao
+    String allowString = constructAllowString();
-            tao
+    allowQuery ="SELECT docid from xml_access WHERE( "+allowString;
     allowQuery = allowQuery +") AND subtreeid IS NULL";
-            tao
+    MetaCatUtil.debugMessage("allow query is: "+ allowQuery, 30);
     return allowQuery;
+  }
   /* Method to construct a allow rule string */
   private String constructAllowString()
+  {
     String allowQuery ="";
      // add allow rule for user name
      if (userName != null && !userName.equals(""))
             tao
       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
-            tao
+    MetaCatUtil.debugMessage("allow string is: "+ allowQuery, 40);
-            tao
+    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;
-            tao
+    String denyString = constructDenyString();
-            tao
+    denyQuery ="SELECT docid from xml_access WHERE( " + denyString;
     denyQuery = denyQuery + ") AND subtreeid IS NULL ";
-            tao
+    MetaCatUtil.debugMessage("denyquery is: "+ denyQuery, 30);
     return denyQuery;
+  }
   /* Construct deny string */
   private String constructDenyString()
+  {
     String denyQuery ="";
-            tao
+    // 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
     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;
+  }
             tao
   /**
    * set the querygroup
    */
   public void setQueryGroup(QueryGroup group)
+  {
     query = group;
+  }
             tao
-            jones
+  /**
-            tao
+   * set if this query sepcification has extendQuery(has return doc type or not)
    */
   public void setContainsExtenedSQL(boolean hasExtenedQuery)
+  {
      containsExtendedSQL = hasExtenedQuery;
+  }
   /**
-            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
+       handleReturnField(inputString);
     } else if (currentTag.equals("filterdoctype")) {
       filterDocList.add(inputString);
     } else if (currentTag.equals("owner")) {
       ownerList.add(inputString);
     } else if (currentTag.equals("site")) {
       siteList.add(inputString);
+    }
+  }
   /**
    * Method to transfer string to return field
    */
   public void handleReturnField(String inputString)
+  {
      // make sure if return fields has an attribute or not
-            tao
+      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
-            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
-            tao
+    MetaCatUtil.debugMessage("percentage number: " +
                                          query.getPercentageSymbolCount(), 35);
     if (query.getPercentageSymbolCount() ==1 )
             tao
-            tao
+      MetaCatUtil.debugMessage("it is a percentage search", 30);
-            tao
+      percentageSearch =true;
+    }
-            jones
+    return self.toString();
+  }
             berkley
-            tao
+  /** This sql command will selecet startnodeid and endnodeid that user can NOT
     * access
-            tao
+    */
-            tao
+  public String printAccessControlSQLForReturnField(String doclist)
+  {
     StringBuffer sql = new StringBuffer();
     String allowString = constructAllowString();
     String denyString = constructDenyString();
-            tao
+    sql.append("SELECT distinct startnodeid, endnodeid from xml_access ");
-            tao
+    sql.append("WHERE docid in (");
     sql.append(doclist);
-            tao
+    sql.append(") AND startnodeid IS NOT NULL AND ");
-            tao
+    sql.append("(");
-            tao
+    sql.append("(");
     sql.append("startnodeid NOT IN (SELECT startnodeid from xml_access, xml_documents ");
     sql.append(" WHERE xml_access.docid = xml_documents.docid");
     sql.append(" AND xml_documents.user_owner ='");
     sql.append(userName);
-            tao
+    sql.append("' AND xml_access.startnodeid IS NOT NULL)");
-            tao
+    sql.append(")");
     sql.append(" AND ");
     sql.append("(");
-            tao
+    sql.append("(startnodeid NOT IN (SELECT startnodeid from xml_access where( ");
-            tao
+    sql.append(allowString);
-            tao
+    sql.append(") AND (startnodeid IS NOT NULL))");
-            tao
+    sql.append(")");
-            tao
+    sql.append(" OR (startnodeid IN (SELECT startnodeid from xml_access where( ");
-            tao
+    sql.append(denyString);
-            tao
+    sql.append(") AND (startnodeid IS NOT NULL))");
-            tao
+    sql.append(")");
     sql.append(")");
     sql.append(")");
     MetaCatUtil.debugMessage("accessControlSQLForReturnField: " +
                              sql.toString(), 30);
     return sql.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
-            tao
+   * @param unaccessableNodePair  the node pair(start id and end id) which this
    *                               user could not access it
-            berkley
+   */
-            tao
+  public String printExtendedSQL(String doclist, Hashtable unaccessableNodePair)
             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'");
             tao
     // 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
-            tao
+      self.append(" AND( xml_nodes.nodeid < ");
-            tao
+      self.append(startNodeId);
-            tao
+      self.append(" OR xml_nodes.nodeid > ");
-            tao
+      self.append(endNodeId);
       self.append(")");
+    }
             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();
-            tao
+    self.append("select z.nodedata, z.parentnodeid, ");
     self.append("x.nodedata, x.parentnodeid, y.nodedata, y.parentnodeid from ");
-            berkley
+    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);
+      }
-            tao
+      MetaCatUtil.debugMessage("The path expression without attributes: " +
-            tao
+                               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);
+      }
-            tao
+      MetaCatUtil.debugMessage("The attirbute name from path: " +
-            tao
+                               attributeName, 30);
       return attributeName;
+  }
             jones
             jones
             jones

Project

General

Profile

Metacat