Metacat

/**

 *  '$RCSfile$'

 *             constructed from an XML serialization conforming to

 *             pathquery.dtd. The printSQL() method can be used to print

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * 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.util.Vector;

/** a utility class that represents a single term in a query */

{

    /**

     * the value only)

     *            flag indicating whether case is used to match

     * @param searchmode

     *            determines what kind of substring match is performed (one of

     *            starts-with|ends-with|contains|matches-exactly)

     * @param value

     *            the text value to match

    {

        this.casesensitive = casesensitive;

        this.searchmode = searchmode;

        this.value = value;

    /**

     * Construct a new instance of a query term for a structured search

     * (matching the value only for those nodes in the pathexpr)

     *            flag indicating whether case is used to match

     * @param searchmode

     *            determines what kind of substring match is performed (one of

     *            starts-with|ends-with|contains|matches-exactly)

     * @param value

     *            the text value to match

     * @param pathexpr

     *            the hierarchical path to the nodes to be searched

            String pathexpr)

    {

        this(casesensitive, searchmode, value);

        this.pathexpr = pathexpr;

    /** determine if the QueryTerm is case sensitive */

    {

        return casesensitive;

    /** get the searchmode parameter */

    {

        return searchmode;

    {

        return value;

    /** get the path expression parameter */

    {

        return pathexpr;

    /** get the percentage count for one query term */

    {

    /**

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

     */

    {

        StringBuffer self = new StringBuffer();

        String casevalue = null;

        String nodedataterm = null;

            nodedataterm = "nodedata";

            casevalue = value;

        } else {

            nodedataterm = "UPPER(nodedata)";

            casevalue = value.toUpperCase();

        }

        String searchexpr = null;

        if (searchmode.equals("starts-with")) {

            if (!casevalue.equals("%")) {

                percentageSymbol = true;

            }

        } else if (searchmode.equals("not-contains")) {

            searchexpr = nodedataterm + " = '" + casevalue + "' ";

        } else if (searchmode.equals("isnot-equal")) {

            searchexpr = nodedataterm + " = '" + casevalue + "' ";

            if (searchmode.equals("greater-than")) {

                oper = ">";

                oper = ">=";

                oper = "<";

                oper = "<=";

                System.out

                        .println("NOT expected case. NOT recognized operator: "

                                + searchmode);

                return null;

            }

            try {

                // it is number; numeric comparison

                // but we need to make sure there is no string in node data

                searchexpr = nodedataterm + " " + oper + " "

                // these are characters; character comparison

                searchexpr = nodedataterm + " " + oper + " '" + casevalue

                        + "' ";

            }

        boolean usePathIndex = false;

        // if pathexpr has been specified in metacat.properties for indexing

        if(pathexpr != null){

            if(MetaCatUtil.pathsForIndexing.contains(pathexpr)){

                usePathIndex = true;

            }

        }

        if(usePathIndex){

            // using xml_path_index table.....

        		self.append("SELECT DISTINCT docid from xml_path_index WHERE");

        		self.append(" docid NOT IN (Select docid FROM xml_path_index WHERE ");

        		self.append(searchexpr);

        		self.append("SELECT DISTINCT docid FROM xml_path_index WHERE ");

        		self.append(searchexpr);

        } else {

            // using xml_nodes and xml_index tables

        		self.append("SELECT DISTINCT docid from xml_nodes WHERE");

        		self.append(" docid NOT IN (Select docid FROM xml_nodes WHERE ");

        	} else {

        	self.append(searchexpr);

                // use XML Index

                if (useXMLIndex) {

                    if (!hasAttributeInPath(pathexpr)) {

                        // without attributes in path

                        self.append("AND parentnodeid IN ");

                        String attributeName = QuerySpecification

                            "AND nodetype LIKE 'ATTRIBUTE' AND nodename LIKE '"

                            + attributeName + "' ");

                        // and the path expression includes element content other than

                        // just './' or '../'

                        if ( (!pathexpr.startsWith(QuerySpecification.

                            ATTRIBUTESYMBOL)) &&

                            (!pathexpr.startsWith("./" +

                                                  QuerySpecification.ATTRIBUTESYMBOL)) &&

                            (!pathexpr.startsWith("../" +

                                                  QuerySpecification.ATTRIBUTESYMBOL))) {

                            pathexpr = QuerySpecification

                                .newPathExpressionWithOutAttribute(pathexpr);

                        }

                        "(SELECT nodeid FROM xml_index WHERE path LIKE "

                        + "'" + pathexpr + "') ");

                    // without using XML Index; using nested statements instead

                    self.append("AND parentnodeid IN ");

                    self.append(useNestedStatements(pathexpr));

                }

                //if pathexpr is null and search value is %, is a

                // percentageSearchItem

                // the count number will be increase one

                countPercentageSearchItem++;

    /** A method to judge if a path have attribute */

    {

            return true;

        } else {

            return false;

        }

    /*

     * Constraint the query with @pathexp without using the XML Index, but

     * nested SQL statements instead. The query migth be slower.

        Vector nodes = new Vector();

        String path = pathexpr;

        int inx = 0;

            inx = path.lastIndexOf("/");

            path = path.substring(0, Math.abs(inx));

        } while (inx > 0);

        int i = 0;

        for (i = 0; i < nodes.size() - 1; i++) {

            nestedStmts.append("(SELECT nodeid FROM xml_nodes"

                    + " WHERE nodename LIKE '" + (String) nodes.elementAt(i)

                    + "'" + " AND parentnodeid IN ");

        }

        // for the last statement: it is without " AND parentnodeid IN "

        nestedStmts.append("(SELECT nodeid FROM xml_nodes"

                + " WHERE nodename LIKE '" + (String) nodes.elementAt(i) + "'");

        // node.size() number of closing brackets

        for (i = 0; i < nodes.size(); i++) {

            nestedStmts.append(")");

        }

    /**

     * create a String description of the query that this instance represents.

     * This should become a way to get the XML serialization of the query.

     */

    {