com.goldencode.p2j.persist.pl

Class Contains

java.lang.Object

com.goldencode.p2j.persist.pl.Contains

public final class Contains
extends java.lang.Object

Simplified implementation of the CONTAINS operator for lightweight use. Evaluates a data string against an expression which uses the CONTAINS operator's right operand expression syntax:

 Construct   Precedence   Description
 -----------------------------------------------------------------------------------------------
 (...)          3         Parentheses to change precedence of a subexpression operation.
 word           3         A full word to match
 prefix         3         A prefix of a word to match, followed by an asterisk (*), indicating
                          a wildcard. The asterisk may only be at the end of the word.
 &              2         Logical AND operator.
 | or ! or ^    1         Logical OR operator.
 

Subexpressions may be nested arbitrarily deeply. An empty expression is silently tolerated, but does not produce a match.

Match tests are performed by constructing an instance of this class and invoking the evaluate(String) method against it. The match expression is parsed into an AST, and the AST is walked to evaluate the expression for the data passed to the evaluate method.

In practice, a separate instance of this class is constructed for every data match. This design is necessary because this class will be used from within a database user defined function, which is driven statelessly by a database in connection with a query. Thus, we have no control over when or how often the feature is used. To amortize the expense of parsing the match expression, a cache is used to permit re-use of previously parsed expression ASTs. Since ASTs may be shared across threads, they are treated as immutable.

NOTE: since this implementation does not leverage true word break tables and joins, it is not suitable for use with large tables nor tables with very large data entries. Since it is used with a UDF that will be opaque to a database's query planner, this implementation often will result in full table scans, unless other components of a query allow the query planner to make a more efficient plan. In addition, each data entry will be scanned for each invocation. Thus, this implementation is suitable for lightweight uses where the primary objective is to properly honor the syntax of the CONTAINS operator's match expression.

TODO: properly handle match expression characters Progress simply ignores when matching. Do these have to do with word break rules?

TODO: at this time, word break rules are not used to delimit words.

Author:

ecf

Field Summary

Fields

Modifier and Type	Field and Description
private static java.util.Map<java.lang.String,java.util.List<LogicalExpressionConverter.EToken>>	cache Cache of match expressions to parsed ASTs
private boolean	caseSensitive Should matches be checked case-sensitively?
private java.util.regex.Pattern	delimiterPattern Regex pattern word delimiter for data strings
private java.util.List<LogicalExpressionConverter.EToken>	exprRPN Parsed match expression RPN, used to evaluate matches with string data
private static CentralLogger	LOG Logger

Constructor Summary

Constructors

Constructor and Description
Contains(java.lang.String expr, boolean caseSensitive, java.lang.String codePage) Constructor.
Contains(java.lang.String expr, java.lang.String codePage) Constructor.

Method Summary

Modifier and Type	Method and Description
boolean	evaluate(java.lang.String data) Given a data string, evaluate the expression to determine whether the data matches.
static void	main(java.lang.String[] args) Simple test harness for command line testing.
java.util.Set<java.lang.String>	words(java.lang.String data, boolean forCaseInsensitive) Split a string to a set of words

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final CentralLogger LOG

Logger

cache

private static final java.util.Map<java.lang.String,java.util.List<LogicalExpressionConverter.EToken>> cache

Cache of match expressions to parsed ASTs

delimiterPattern

private java.util.regex.Pattern delimiterPattern

Regex pattern word delimiter for data strings

caseSensitive

private final boolean caseSensitive

Should matches be checked case-sensitively?

exprRPN

private final java.util.List<LogicalExpressionConverter.EToken> exprRPN

Parsed match expression RPN, used to evaluate matches with string data

Constructor Detail

Contains

public Contains(java.lang.String expr,
                java.lang.String codePage)

Constructor.

Parameters:

expr - Match expression which uses CONTAINS operator syntax.

codePage - Character encoding used.

Throws:

ErrorConditionException - if there is an I/O error parsing the match expression.

Contains

public Contains(java.lang.String expr,
                boolean caseSensitive,
                java.lang.String codePage)

Constructor.

Parameters:

expr - Match expression which uses CONTAINS operator syntax.

caseSensitive - true to perform word match comparisons case-sensitively, false to ignore case.

codePage - Character encoding used.

Throws:

ErrorConditionException - if there is a syntax or an I/O error parsing the match expression.

Method Detail

evaluate

public boolean evaluate(java.lang.String data)

Given a data string, evaluate the expression to determine whether the data matches. Only read as many words from the data as are needed to determine a result.

Parameters:

data - A data string with words delimited by this object's specified delimiter.

Returns:

true if the words in the data match this object's expression, else false.

Throws:

ErrorConditionException - if there is an I/O error reading words from the data stream.

words

public java.util.Set<java.lang.String> words(java.lang.String data,
                                             boolean forCaseInsensitive)

Split a string to a set of words

Parameters:

data - string to be parsed

forCaseInsensitive - return words which are unique in case-insensitive sense

Returns:

words contained in a string

main

public static void main(java.lang.String[] args)

Simple test harness for command line testing.

Parameters:

args - Expects the first argument to be the match expression and the second to be the data to be matched.