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

{

    public static final String CONTAINS = "contains";

    public static final String EQUALS = "equals";

    /**

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

        }

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

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

        }

    public static String useNestedStatements(String pathexpr)

    {

        log.info("useNestedStatements()");

        log.info("pathexpr: " + pathexpr);

        StringBuffer nestedStmts = new StringBuffer();

        String path = pathexpr.trim();

        {

            nestedStmts.append("AND parentnodeid = rootnodeid ");

            path = path.substring(1).trim();

        }

        do

        {

            int inx = path.indexOf('/');

            int predicateStart = -1;

            int predicateEnd;

            String node;

            Vector predicates = new Vector();

            // extract predicates

            predicateStart = path.indexOf(QuerySpecification.PREDICATE_START, predicateStart + 1);

            // any predicates in this node?

            if (inx != -1 && (predicateStart == -1 || predicateStart > inx))

            {

                // no

                node = path.substring(0, inx).trim();

                path = path.substring(inx + 1).trim();

            }

            else if (predicateStart == -1)

            {

                // no and it's the last node

                node = path;

                path = "";

            }

            else

            {

                // yes

                node = path.substring(0, predicateStart).trim();

                path = path.substring(predicateStart);

                predicateStart = 0;

                while (predicateStart == 0)

                {

                    predicateEnd = path.indexOf(QuerySpecification.PREDICATE_END,

                            predicateStart);

                    if (predicateEnd == -1)

                    {

                        log.warn("useNestedStatements(): ");

                        log.warn("    Invalid path: " + pathexpr);

                        return "";

                    }

                    predicates.add(path.substring(1, predicateEnd).trim());

                    path = path.substring(predicateEnd + 1).trim();

                    inx = path.indexOf('/');

                    predicateStart = path.indexOf(QuerySpecification.PREDICATE_START);

                }

                if (inx == 0)

                    path = path.substring(1).trim();

                else if (!path.equals(""))

                {

                    log.warn("useNestedStatements(): ");

                    log.warn("    Invalid path: " + pathexpr);

                    return "";

                }

            }

            nestedStmts.insert(0, "' ").insert(0, node).insert(0,

                    "(SELECT nodeid FROM xml_nodes WHERE nodename LIKE '");

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

            if (!path.equals(""))

                nestedStmts.insert(0, "AND parentnodeid IN ");

            if (predicates.size() > 0)

            {

                for (int n = 0; n < predicates.size(); n++)

                {

                    String predSQL = predicate2SQL((String) predicates.get(n));

                    if (predSQL.equals(""))

                        return "";

                    nestedStmts.append(predSQL).append(' ');

                }

            }

            nestedStmts.append(") ");

        }

        while (!path.equals(""));

        return nestedStmts.toString();

    }

     */

    public static String predicate2SQL(String predicate)

    {

        String path = predicate.trim();

        int equals = path.indexOf('=');

        String literal = null;

        if (equals != -1)

        {

            literal = path.substring(equals + 1).trim();

            path = path.substring(0, equals).trim();

            int sQuote = literal.indexOf('\'');

            int dQuote = literal.indexOf('"');

            if (sQuote == -1 && dQuote == -1)

            {

                log.warn("predicate2SQL(): ");

                log.warn("    Invalid or unsupported predicate: " + predicate);

                return "";

            }

            if (sQuote == -1 &&

                (dQuote != 0 ||

                 literal.indexOf('"', dQuote + 1) != literal.length() - 1))

            {

                log.warn("predicate2SQL(): ");

                log.warn("    Invalid or unsupported predicate: " + predicate);

                return "";

            }

            if (sQuote != 0 ||

                literal.indexOf('\'', sQuote + 1) != literal.length() - 1)

            {

                log.warn("predicate2SQL(): ");

                log.warn("    Invalid or unsupported predicate: " + predicate);

                return "";

            }

        }

        StringBuffer sql = new StringBuffer();

        int attribute = path.indexOf('@');

        if (attribute == -1)

        {

            if (literal != null)

            {

                sql.append("AND nodeid IN (SELECT parentnodeid FROM xml_nodes WHERE nodetype = 'TEXT' AND nodedata LIKE ")

                    .append(literal).append(")");

            }

        }

        else

        {

            sql.append(

                    "AND nodeid IN (SELECT parentnodeid FROM xml_nodes WHERE nodetype = 'ATTRIBUTE' AND nodename LIKE '")

                    .append(path.substring(attribute + 1).trim()).append("' ");

            if (literal != null)

            {

                sql.append("AND nodedata LIKE ").append(literal);

            }

            sql.append(")");

            path = path.substring(0, attribute).trim();

            if (path.endsWith("/"))

                path = path.substring(0, path.length() - 1).trim();

            else

            {

                if (!path.equals(""))

                {

                    log.warn("predicate2SQL(): ");

                    log.warn("    Invalid or unsupported predicate: " + predicate);

                    return "";

                }

            }

        }

        while (!path.equals(""))

        {

            int ndx = path.lastIndexOf('/');

            int predicateEnd = -1;

            int predicateStart;

            String node;

            if (ndx != -1)

            {

                node = path.substring(ndx + 1).trim();

                path = path.substring(0, ndx).trim();

            }

            else

            {

                node = path;

                path = "";

            }

            if (!node.equals(""))

                sql.insert(0, "' ").insert(0, node)

                    .insert(0, "(SELECT parentnodeid FROM xml_nodes WHERE nodename LIKE '").append(") ");

            else if (!path.equals(""))

            {

                log.warn("predicate2SQL(): ");

                log.warn("    Invalid or unsupported predicate: " + predicate);

                return "";

            }

            if (path.equals(""))

            {

                sql.insert(0,

                        node.equals("") ? "AND rootnodeid IN " : "AND nodeid IN ");

            }

            else

            {

                sql.append("AND nodeid IN ");

            }

        }

        return sql.toString();

    }

    /**

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

     */

    {

    /**

     * Compare two query terms to see if they have same search value.

     * @param term

     * @return

     */

    public boolean hasSameSearchValue(QueryTerm term)

    {

    	boolean same = false;

    	if (term != null)

    	{

    		String searchValue = term.getValue();

    		if (searchValue != null && this.value != null)

    		{

    			if (searchValue.equalsIgnoreCase(this.value))

    			{

    				same = true;

    			}

    		}

    	}

    	return same;

    }