Metacat

/**

 *  '$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

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2004-04-01 15:40:28 -0800 (Thu, 01 Apr 2004) $'

 * '$Revision: 2093 $'

 *

 * 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

 */

package edu.ucsb.nceas.metacat;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

import edu.ucsb.nceas.dbadapter.AbstractDatabase;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.DefaultHandler;

import org.xml.sax.helpers.XMLReaderFactory;

/**

 * A Class that represents a structured query, and can be constructed from an

 * XML serialization conforming to

 *

 * @see pathquery.dtd. The printSQL() method can be used to print a SQL

 *      serialization of the query.

 */

public class QuerySpecification extends DefaultHandler

{

    /** flag determining whether extended query terms are present */

    private boolean containsExtendedSQL = false;

    /** Identifier for this query document */

    private String meta_file_id;

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

    /** List of sites/scopes used to constrain search */

    private Vector siteList;

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

    private StringBuffer textBuffer = new StringBuffer();

    /**

     * construct an instance of the QuerySpecification class

     *

     * @param queryspec

     *            the XML representation of the query (should conform to

     *            pathquery.dtd) as a Reader

     * @param parserName

     *            the fully qualified name of a Java Class implementing the

     *            org.xml.sax.XMLReader interface

     */

    public QuerySpecification(Reader queryspec, String parserName,

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

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

        }

    }

    /**

     * construct an instance of the QuerySpecification class

     *

     * @param queryspec

     *            the XML representation of the query (should conform to

     *            pathquery.dtd) as a String

     * @param parserName

     *            the fully qualified name of a Java Class implementing the

     *            org.xml.sax.Parser interface

     */

    public QuerySpecification(String queryspec, String parserName,

            String accNumberSeparator) throws IOException

    {

        this(new StringReader(queryspec), parserName, accNumberSeparator);

    }

    /**

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

    }

    /**

     * Method to set user name

     *

     * @param myName

     *            the user name

     */

    public void setUserName(String myName)

    {

        //to lower case

        if (myName != null) {

            this.userName = myName.toLowerCase();

        } else {

            this.userName = myName;

        }

    }

    /**

     * Method to set user group

     *

     * @param myGroup

     *            the user group

     */

    public void setGroup(String[] myGroup)

    {

        this.group = myGroup;

    }

    /**

     * Method to indicate this query is a percentage search

     */

    public boolean isPercentageSearch()

    {

        return percentageSearch;

    }

    /*

     * 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 ";

        if (userName != null && !userName.equals("")) {

            ownerQuery = ownerQuery + "lower(user_owner) ='" + userName + "'";

        }

        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;

        String allowString = constructAllowString();

        allowQuery = "SELECT docid from xml_access WHERE( " + allowString;

        allowQuery = allowQuery + ") AND subtreeid IS NULL";

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

            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

        }//if

        MetaCatUtil.debugMessage("allow string is: " + allowQuery, 40);

        return allowQuery;

    }

    /*

     * 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 ";

        MetaCatUtil.debugMessage("denyquery is: " + denyQuery, 30);

        return denyQuery;

    }

    /* Construct deny string */

    private String constructDenyString()

    {

        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;

    }

    /**

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

    }

    /**

     * Returns true if the parsed query contains and extended xml query (i.e.

     * there is at least one <returnfield> in the pathquery document)

     */

    public boolean containsExtendedSQL()

    {

        if (containsExtendedSQL) {

            return true;

        } else {

            return false;

        }

    }

    /**

     * A method to get if the query has an attribute return field

     */

    public boolean containAttributeReturnField()

    {

        return hasAttributeReturnField;

    }

    /**

     * 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 <returndoctype> 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 <filterdoctype> 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;

    }

    /**

     * Accessor method to return a vector of the extended return fields as

     * defined in the <returnfield> tag in the pathquery dtd.

     */

    public Vector getReturnFieldList()

    {

        return this.returnFieldList;

    }

    /**

     * 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

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

     * <site> 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;

    }

    /**

     * set the querygroup

     */

    public void setQueryGroup(QueryGroup group)

    {

        query = group;

    }

    /**

     * set if this query sepcification has extendQuery(has return doc type or

     * not)

     */

    public void setContainsExtenedSQL(boolean hasExtenedQuery)

    {

        containsExtendedSQL = hasExtenedQuery;

    }

    /**

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

    }

    /**

     * callback method used by the SAX Parser when the start tag of an element

     * is detected. Used in this context to parse and store the query

     * information in class variables.

     */

    public void startElement(String uri, String localName, String qName,

            Attributes atts) throws SAXException

    {

        BasicNode currentNode = new BasicNode(localName);

        // add attributes to BasicNode here

        if (atts != null) {

            int len = atts.getLength();

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

                currentNode

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

            }

        }

        elementStack.push(currentNode);

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

            QueryGroup currentGroup = new QueryGroup(currentNode

                    .getAttribute("operator"));

            if (query == null) {

                query = currentGroup;

            } else {

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

                parentGroup.addChild(currentGroup);

            }

            queryStack.push(currentGroup);

        }

    }

    /**

     * callback method used by the SAX Parser when the end tag of an element is

     * detected. Used in this context to parse and store the query information

     * in class variables.

     */

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

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

        if (leaving.getTagName().equals("queryterm")) {

            boolean isCaseSensitive = (new Boolean(leaving

                    .getAttribute("casesensitive"))).booleanValue();

            QueryTerm currentTerm = null;

            if (currentPathexpr == null) {

                currentTerm = new QueryTerm(isCaseSensitive, leaving

                        .getAttribute("searchmode"), currentValue);

            } else {

                currentTerm = new QueryTerm(isCaseSensitive, leaving

                        .getAttribute("searchmode"), currentValue,

                        currentPathexpr);

            }

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

            currentGroup.addChild(currentTerm);

            currentValue = null;

            currentPathexpr = null;

        } else if (leaving.getTagName().equals("querygroup")) {

            QueryGroup leavingGroup = (QueryGroup) queryStack.pop();

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

        } else if (leaving.getTagName().equals("site")) {

              siteList.add(textBuffer.toString().trim());

        }

        //rest textBuffer

        textBuffer = null;

        textBuffer = new StringBuffer();

    }

    /**

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

    {

      // buffer all text nodes for same element. This is for text was splited

      // into different nodes

      textBuffer.append(new String(ch, start, length));

    }

    /**

     * 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

            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;

        }

    }

    /**

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

     */

    public String printSQL(boolean useXMLIndex)

    {

        StringBuffer self = new StringBuffer();

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

        self.append("date_created, date_updated, rev ");

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

        // This determines the documents that meet the query conditions

        self.append(query.printSQL(useXMLIndex));

        self.append(") ");

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

            self.append(" AND (");

            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 + "'");

                }

            }

            self.append(") ");

        }

        // 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 (current != null) {

                    current = current.toLowerCase();

                }

                if (first) {

                    first = false;

                    self.append(" lower(user_owner) = '" + current + "'");

                } else {

                    self.append(" OR lower(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(") ");

        }

        // if there is only one percentage search item, this query is a

        // percentage

        // search query

        MetaCatUtil.debugMessage("percentage number: "

                + query.getPercentageSymbolCount(), 35);

        if (query.getPercentageSymbolCount() == 1) {

            MetaCatUtil.debugMessage("it is a percentage search", 30);

            percentageSearch = true;

        }

        return self.toString();

    }

    /**

     * This sql command will selecet startnodeid and endnodeid that user can

     * NOT access

     */

    public String printAccessControlSQLForReturnField(String doclist)

    {

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

        sql

                .append("startnodeid NOT IN (SELECT startnodeid from xml_access, xml_documents ");

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

        sql

                .append("(startnodeid NOT IN (SELECT startnodeid from xml_access where( ");

        sql.append(allowString);

        sql.append(") AND (startnodeid IS NOT NULL))");

        sql.append(")");

        sql

                .append(" OR (startnodeid IN (SELECT startnodeid from xml_access where( ");

        sql.append(denyString);

        sql.append(") AND (startnodeid IS NOT NULL))");

        sql.append(")");

        sql.append(")");

        sql.append(")");

        MetaCatUtil.debugMessage("accessControlSQLForReturnField: "

                + sql.toString(), 30);

        return sql.toString();

    }

    /**

     * This method prints sql based upon the <returnfield> tag in the

     * pathquery document. This allows for customization of the returned fields.

     * 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

     * avoids the use of the xml_index table.

     *

     * @param doclist the list of document ids to search

     * @param unaccessableNodePair the node pairs (start id and end id) which

     *            this user should not access

     * @param useXMLIndex a boolean flag indicating whether to search using

     *            xml_index

     */

    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 {

                    self.append(" UNION ");

                }

                String path  = (String) returnFieldList.elementAt(i);

                self.append("select xml_nodes.docid, ");

                self.append("'"+ path  + "' as path, xml_nodes.nodedata, ");

                self.append("xml_nodes.parentnodeid ");

                self.append("from xml_nodes, xml_documents ");

                self.append("where parentnodeid IN ");

                self.append(QueryTerm.useNestedStatements(path));

                self.append(" AND xml_nodes.docid in (");

                self.append(doclist);

                self.append(") AND xml_nodes.nodetype = 'TEXT'");

                self.append(" AND xml_nodes.rootnodeid = xml_documents.rootnodeid");

                addAccessRestrictionSQL(unaccessableNodePair, self);

            }

            return self.toString();

        }

    }

    /**

     * This method prints sql based upon the <returnfield> 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.

     *

     * @param doclist the list of document ids to search

     * @param unaccessableNodePair the node pairs (start id and end id)

     *            which this user should not access

     */

    public String printExtendedSQL(String doclist,

            Hashtable unaccessableNodePair)

    {

        StringBuffer self = new StringBuffer();

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

    }

    /**

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

     *

     * @param unaccessableNodePair hash of start/end nodeid pairs to restrict

     * @param self a stringbuffer to which the genrated SQL is appended

     */

    private void addAccessRestrictionSQL(Hashtable unaccessableNodePair,

            StringBuffer self)

    {

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

            self.append(" AND ( xml_nodes.nodeid < ");

            self.append(startNodeId);

            self.append(" OR xml_nodes.nodeid > ");

            self.append(endNodeId);

            self.append(")");

        }

    }

    /**

     * This method prints sql that finds the values of attributes in the xml

     * documents based upon the whether the returnfield tag in the pathquery

     * document has an attribute symbol (@). This allows for customization of

     * the returned fields.

     *

     * @param doclist the list of document ids to search

     * @param useXMLIndex a boolean flag indicating whether to search using

     *            xml_index

     */

    public String printAttributeQuery(String doclist, boolean useXMLIndex)

    {

        if (useXMLIndex) {

            return printAttributeQuery(doclist);

        } else {