org.jboss.dna.graph.query.parse
Class SqlQueryParser

java.lang.Object
  extended by org.jboss.dna.graph.query.parse.SqlQueryParser
All Implemented Interfaces:
QueryParser

public class SqlQueryParser
extends Object
implements QueryParser

A QueryParser implementation that parses a subset of SQL select and set queries.

This grammar is equivalent to the SQL grammar as defined by the JCR 2.0 specification, with some useful additions:

SQL grammar

This section defines the complete grammar for the SQL dialect supported by this parser.

Queries

 QueryCommand ::= Query | SetQuery
 
 SetQuery ::= Query ('UNION'|'INTERSECT'|'EXCEPT') [ALL] Query
                  { ('UNION'|'INTERSECT'|'EXCEPT') [ALL] Query }
 
 Query ::= 'SELECT' ['DISINCT'] columns
           'FROM' Source
           ['WHERE' Constraint]
           ['ORDER BY' orderings]
           [Limit]
 

Sources

 Source ::= Selector | Join
 
 Selector ::= nodeTypeName ['AS' selectorName]
 
 nodeTypeName ::= Name
 

Joins

 Join ::= left [JoinType] 'JOIN' right 'ON' JoinCondition
          // If JoinType is omitted INNER is assumed.
          
 left ::= Source
 right ::= Source
 
 JoinType ::= Inner | LeftOuter | RightOuter | FullOuter | Cross
 
 Inner ::= 'INNER' ['JOIN']
 
 LeftOuter ::= 'LEFT JOIN' | 'OUTER JOIN' | 'LEFT OUTER JOIN'
 
 RightOuter ::= 'RIGHT OUTER' ['JOIN']
 
 RightOuter ::= 'FULL OUTER' ['JOIN']
 
 RightOuter ::= 'CROSS' ['JOIN']
 
 JoinCondition ::= EquiJoinCondition | SameNodeJoinCondition | ChildNodeJoinCondition | DescendantNodeJoinCondition
 
Equi-join conditions
 EquiJoinCondition ::= selector1Name'.'property1Name '=' selector2Name'.'property2Name
 
 selector1Name ::= selectorName
 selector2Name ::= selectorName
 property1Name ::= propertyName
 property2Name ::= propertyName
 
Same-node join condition
 SameNodeJoinCondition ::= 'ISSAMENODE(' selector1Name ',' selector2Name [',' selector2Path] ')'
 
 selector2Path ::= Path
 
Child-node join condition
 ChildNodeJoinCondition ::= 'ISCHILDNODE(' childSelectorName ',' parentSelectorName ')'
 
 childSelectorName ::= selectorName
 parentSelectorName ::= selectorName
 
Descendant-node join condition
 DescendantNodeJoinCondition ::= 'ISDESCENDANTNODE(' descendantSelectorName ',' ancestorSelectorName ')'
 descendantSelectorName ::= selectorName
 ancestorSelectorName ::= selectorName
 

Constraints

 Constraint ::= ConstraintItem | '(' ConstraintItem ')'
 
 ConstraintItem ::= And | Or | Not | Comparison | Between | PropertyExistence | SetConstraint | FullTextSearch | 
                    SameNode | ChildNode | DescendantNode
 
And constraint
 And ::= constraint1 'AND' constraint2
 
 constraint1 ::= Constraint
 constraint2 ::= Constraint
 
Or constraint
 Or ::= constraint1 'OR' constraint2
 
Not constraint
 Not ::= 'NOT' Constraint
 
Comparison constraint
 Comparison ::= DynamicOperand Operator StaticOperand
 
 Operator ::= '=' | '!=' | '<' | '<=' | '>' | '>=' | 'LIKE'
 
Between constraint
 Between ::= DynamicOperand ['NOT'] 'BETWEEN' lowerBound ['EXCLUSIVE'] 'AND' upperBound ['EXCLUSIVE']
 
 lowerBound ::= StaticOperand
 upperBound ::= StaticOperand
 
Property existence constraint
 PropertyExistence ::= selectorName'.'propertyName 'IS' ['NOT'] 'NULL' | 
                       propertyName 'IS' ['NOT'] 'NULL' /* If only one selector exists in this query */
 
 
Set constraint
 SetConstraint ::= selectorName'.'propertyName ['NOT'] 'IN' | 
                       propertyName ['NOT'] 'IN' /* If only one selector exists in this query */
                       '(' firstStaticOperand {',' additionalStaticOperand } ')'
 firstStaticOperand ::= StaticOperand
 additionalStaticOperand ::= StaticOperand
 
Full-text search constraint
 FullTextSearch ::= 'CONTAINS(' ([selectorName'.']propertyName | selectorName'.*') 
                            ',' ''' fullTextSearchExpression''' ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 fullTextSearchExpression ::= /* a full-text search expression, see FullTextSearchParser */
 
Same-node constraint
 SameNode ::= 'ISSAMENODE(' [selectorName ','] Path ')' 
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 
Child-node constraint
 ChildNode ::= 'ISCHILDNODE(' [selectorName ','] Path ')' 
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 
Descendant-node constraint
 DescendantNode ::= 'ISDESCENDANTNODE(' [selectorName ','] Path ')' 
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 
Paths and names
 
 Name ::= '[' quotedName ']' | '[' simpleName ']' | simpleName
 
 quotedName ::= /* A JCR Name (see the JCR specification) */
 simpleName ::= /* A JCR Name that contains only SQL-legal characters (namely letters, digits, and underscore) */

 Path ::= '[' quotedPath ']' | '[' simplePath ']' | simplePath

 quotedPath ::= /* A JCR Path that contains non-SQL-legal characters */
 simplePath ::= /* A JCR Path (rather Name) that contains only SQL-legal characters (namely letters, digits, and underscore) */
 

Static operands

 StaticOperand ::= Literal | BindVariableValue
 
Literal
 Literal ::= CastLiteral | UncastLiteral
 
 CastLiteral ::= 'CAST(' UncastLiteral ' AS ' PropertyType ')'
 
 PropertyType ::= 'STRING' | 'BINARY' | 'DATE' | 'LONG' | 'DOUBLE' | 'DECIMAL' | 'BOOLEAN' | 'NAME' | 'PATH' | 
                  'REFERENCE' | 'WEAKREFERENCE' | 'URI'
                  /* 'WEAKREFERENCE' is not currently supported in JCR 1.0 */
                  
 UncastLiteral ::= UnquotedLiteral | ''' UnquotedLiteral ''' | '"' UnquotedLiteral '"'
 
 UnquotedLiteral ::= /* String form of a JCR Value, as defined in the JCR specification */
 
Bind variables
 BindVariableValue ::= '$'bindVariableName
 
 bindVariableName ::= /* A string that conforms to the JCR Name syntax, though the prefix does not need to be
                         a registered namespace prefix. */
 

Dynamic operands

 DynamicOperand ::= PropertyValue | Length | NodeName | NodeLocalName | NodePath | NodeDepth | 
                    FullTextSearchScore | LowerCase | UpperCase | Arithmetic | 
                    '(' DynamicOperand ')'
 
Property value
 PropertyValue ::= [selectorName'.'] propertyName
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 
Property length
 Length ::= 'LENGTH(' PropertyValue ')'
 
Node name
 NodeName ::= 'NAME(' [selectorName] ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       is optional */
 
Node local name
 NodeLocalName ::= 'LOCALNAME(' [selectorName] ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       is optional */
 
Node path
 NodePath ::= 'PATH(' [selectorName] ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       is optional */
 
Node depth
 NodeDepth ::= 'DEPTH(' [selectorName] ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       is optional */
 
Full-text search score
 FullTextSearchScore ::= 'SCORE(' [selectorName] ')'
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       is optional */
 
Lowercase
 LowerCase ::= 'LOWER(' DynamicOperand ')'
 
Uppercase
 UpperCase ::= 'UPPER(' DynamicOperand ')'
 
Arithmetic
 Arithmetic ::= DynamicOperand ('+'|'-'|'*'|'/') DynamicOperand
 

Ordering

 orderings ::= Ordering {',' Ordering}
 
 Ordering ::= DynamicOperand [Order]
 
 Order ::= 'ASC' | 'DESC'
 

Columns

 columns ::= (Column ',' {Column}) | '*'
 
 Column ::= ([selectorName'.']propertyName ['AS' columnName]) | (selectorName'.*')
                    /* If only one selector exists in this query, explicit specification of the selectorName
                       preceding the propertyName is optional */
 selectorName ::= Name
 propertyName ::= Name
 columnName ::= Name
 

Limit

 Limit ::= 'LIMIT' count [ 'OFFSET' offset ]
 count ::= /* Positive integer value */
 offset ::= /* Non-negative integer value */
 


Nested Class Summary
static class SqlQueryParser.SqlTokenizer
          A TokenStream.Tokenizer implementation that parses words, quoted phrases, comments, and symbols.
 
Field Summary
static String LANGUAGE
           
 
Constructor Summary
SqlQueryParser()
           
 
Method Summary
 boolean equals(Object obj)
          
 String getLanguage()
          Get the name of the language that this parser is able to understand.
 QueryCommand parseQuery(String query, TypeSystem typeSystem)
          Parse the supplied query from a string representation into a QueryCommand.
 String toString()
          
 
Methods inherited from class java.lang.Object
getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

LANGUAGE

public static final String LANGUAGE
See Also:
Constant Field Values
Constructor Detail

SqlQueryParser

public SqlQueryParser()
Method Detail

getLanguage

public String getLanguage()
Get the name of the language that this parser is able to understand.

Specified by:
getLanguage in interface QueryParser
Returns:
the language name; never null
See Also:
QueryParser.getLanguage()

toString

public String toString()

Overrides:
toString in class Object
See Also:
Object.toString()

equals

public boolean equals(Object obj)

Overrides:
equals in class Object
See Also:
Object.equals(java.lang.Object)

parseQuery

public QueryCommand parseQuery(String query,
                               TypeSystem typeSystem)
Parse the supplied query from a string representation into a QueryCommand.

Specified by:
parseQuery in interface QueryParser
Parameters:
query - the query in string form; may not be null
typeSystem - the type system used by the query; may not be null
Returns:
the query command
See Also:
QueryParser.parseQuery(String, TypeSystem)


Copyright © 2008-2010 JBoss, a division of Red Hat. All Rights Reserved.