net.sf.saxon.query
Class QueryParser

java.lang.Object
  net.sf.saxon.expr.ExpressionParser
      net.sf.saxon.query.QueryParser

Direct Known Subclasses:

Query30Parser, UpdateParser

public class QueryParser
extends ExpressionParser

This class defines extensions to the XPath parser to handle the additional syntax supported in XQuery

Nested Class Summary

protected static class

QueryParser.LetClause

Nested classes/interfaces inherited from class net.sf.saxon.expr.ExpressionParser

ExpressionParser.FLWORClause, ExpressionParser.ForClause, ExpressionParser.TemporaryContainer

Field Summary

protected Executable	executable
protected static int	FUNCTION_IS_NONDETERMINISTIC
protected static int	FUNCTION_IS_PRIVATE
protected static int	FUNCTION_IS_UPDATING
Set	importedModules
protected String	queryVersion
static String	XQUERY10
static String	XQUERY30

Fields inherited from class net.sf.saxon.expr.ExpressionParser

allowXPath30Syntax, compileWithTracing, defaultContainer, env, language, languageVersion, nameChecker, rangeVariables, scanOnly, SEQUENCE_TYPE, t, XPATH, XQUERY, XSLT_PATTERN

Constructor Summary

QueryParser()
Constructor for internal use: this class should be instantiated via the QueryModule

Method Summary

void	applyModuleImport(net.sf.saxon.query.QueryParser.Import mImport)
protected boolean	atStartOfRelativePath() Test whether the current token is one that can start a RelativePathExpression
protected void	checkForClauseAllowingEmpty(ExpressionParser.ForClause clause) Check a ForClause for an "outer for"
Executable	getExecutable() Get the executable containing this expression.
protected String	getLanguage() Get the current language (XPath or XQuery)
int	getPermittedFunctions() Get the permitted set of standard functions in this environment
protected void	grumble(String message, StructuredQName errorCode, int offset) Report a static error
protected void	lookAhead() Lookahead one token, catching any exception thrown by the tokenizer.
protected LetExpression	makeLetExpression() Make a LetExpression.
protected void	makeSimpleContent(Expression content, SimpleNodeConstructor inst, int offset) Make the instructions for the children of a node with simple content (attribute, text, PI, etc)
static Expression	makeStringJoin(Expression exp, StaticContext env) Make a string-join expression that concatenates the string-values of items in a sequence with intervening spaces.
protected Literal	makeStringLiteral(String token) Method to make a string literal from a token identified as a string literal.
XQueryExpression	makeXQueryExpression(String query, QueryModule mainModule, Configuration config) Create an XQueryExpression
QueryParser	newParser() Create a new parser of the same kind
protected String	normalizeEQName(String s) Convert a QName in expanded-name format "uri":local into Clark format
protected Expression	parseConstructor() Parse a node constructor.
protected void	parseContextItemDeclaration() Parse a context item declaration.
protected void	parseDecimalFormatDeclaration() Parse the "declare decimal-format" declaration.
protected void	parseDefaultDecimalFormat()
protected Expression	parseExtensionExpression() Parse an Extension Expression.
protected ForExpression	parseForClauseAllowingVersion(ExpressionParser.ForClause clause, StructuredQName varQName) Parse an "outer for" clause - XQuery 1.1 only
protected Expression	parseForExpression() Parse a FLWOR expression.
protected void	parseFunctionDeclaration(int functionOptions) Parse a function declaration.
protected void	parseGroupByClause(List clauseList) Parse a Group By clause.
void	parseLibraryModule(String queryString, QueryModule env) Parse a library module.
protected Expression	parseNamedNamespaceConstructor(int offset)
protected Expression	parseNamespaceConstructor(int offset)
protected void	parseRevalidationDeclaration() Parse the "declare revalidation" declaration.
protected Expression	parseTypeswitchExpression() Parse a Typeswitch Expression.
protected void	parseUpdatingFunctionDeclaration() Parse an updating function declaration (allowed in XQuery Update only)
protected Expression	parseValidateExpression() Parse a Validate Expression.
protected Expression	processGroupingExpression(List<ExpressionParser.FLWORClause> clauseList, Expression action) Process a grouping expression Not supported in 1.0; subclassed in the XQuery 1.1 parser
protected String	readCollationName()
Expression	setDefaultValue(String exp) Parse the expression (inside a string literal) used to define default values for external variables.
void	setDisableCycleChecks(boolean disable) Disable checks for certain kinds of cycle.
void	setExecutable(Executable exec) Set the executable used for this query expression
static Expression	stringify(Expression exp, boolean noNodeIfEmpty) Convert an expression so it generates a space-separated sequence of strings
String	URILiteral(String in) Handle a URI literal.

Methods inherited from class net.sf.saxon.expr.ExpressionParser

currentTokenDisplay, declareRangeVariable, disallowedAtStartOfRelativePath, expect, findRangeVariable, getDefaultContainer, getNameChecker, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, isCompileWithTracing, isKeyword, isNamespaceTestAllowed, makeCurriedFunction, makeLocalNameTest, makeNameCode, makeNameCodeSilently, makeNamespaceTest, makeNameTest, makeStructuredQName, makeTracer, nextToken, parse, parseBasicStep, parseDynamicFunctionCall, parseExpression, parseExprSingle, parseFunctionArgument, parseFunctionCall, parseFunctionItemType, parseInlineFunction, parseItemType, parseLiteralFunctionItem, parseNodeTest, parseNumericLiteral, parseParenthesizedItemType, parsePathExpression, parsePredicate, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseStepExpression, parseStringLiteral, parseSwitchExpression, parseTryCatchExpression, parseUnionExpression, parseVariableReference, resolveFunctionName, setCompileWithTracing, setDefaultContainer, setLanguage, setLocation, setLocation, setRangeVariables, setRangeVariableStack, setScanOnly, undeclareRangeVariable, warning

Methods inherited from class java.lang.Object

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

Field Detail

XQUERY10

public static String XQUERY10

XQUERY30

public static String XQUERY30

queryVersion

protected String queryVersion

executable

protected Executable executable

importedModules

public Set importedModules

FUNCTION_IS_UPDATING

protected static final int FUNCTION_IS_UPDATING

See Also:

Constant Field Values

FUNCTION_IS_PRIVATE

protected static final int FUNCTION_IS_PRIVATE

See Also:

Constant Field Values

FUNCTION_IS_NONDETERMINISTIC

protected static final int FUNCTION_IS_NONDETERMINISTIC

See Also:

Constant Field Values

Constructor Detail

QueryParser

public QueryParser()

Constructor for internal use: this class should be instantiated via the QueryModule

Method Detail

newParser

public QueryParser newParser()

Create a new parser of the same kind

makeXQueryExpression

public XQueryExpression makeXQueryExpression(String query,
                                             QueryModule mainModule,
                                             Configuration config)
                                      throws XPathException

Create an XQueryExpression

Parameters:

query - the source text of the query

mainModule - the static context of the query

config - the Saxon configuration

Returns:

the compiled XQuery expression

Throws:

XPathException

getPermittedFunctions

public int getPermittedFunctions()

Get the permitted set of standard functions in this environment

getExecutable

public Executable getExecutable()

Get the executable containing this expression.

Returns:

the executable

setExecutable

public void setExecutable(Executable exec)

Set the executable used for this query expression

Parameters:

exec - the executable

setDisableCycleChecks

public void setDisableCycleChecks(boolean disable)

Disable checks for certain kinds of cycle. This is equivalent to

declare option saxon:allow-cycles "true"

Parameters:

disable - true if checks for import cycles are to be suppressed, that is, if cycles should be allowed

parseLibraryModule

public final void parseLibraryModule(String queryString,
                                     QueryModule env)
                              throws XPathException

Parse a library module. Prolog? Expression

Parameters:

queryString - The text of the library module.

env - The static context. The result of parsing a library module is that the static context is populated with a set of function declarations and variable declarations. Each library module must have its own static context objext.

Throws:

XPathException - if the expression contains a syntax error

grumble

protected void grumble(String message,
                       StructuredQName errorCode,
                       int offset)
                throws XPathException

Report a static error

Overrides:

grumble in class ExpressionParser

Parameters:

message - the error message

offset -

errorCode - the error code

Throws:

XPathException - always thrown: an exception containing the supplied message

parseRevalidationDeclaration

protected void parseRevalidationDeclaration()
                                     throws XPathException

Parse the "declare revalidation" declaration. Syntax: not allowed unless XQuery update is in use

Throws:

XPathException

applyModuleImport

public void applyModuleImport(net.sf.saxon.query.QueryParser.Import mImport)
                       throws XPathException

Throws:

XPathException

parseDecimalFormatDeclaration

protected void parseDecimalFormatDeclaration()
                                      throws XPathException

Parse the "declare decimal-format" declaration. Allowed in XQuery 1.1 only

Throws:

XPathException

parseDefaultDecimalFormat

protected void parseDefaultDecimalFormat()
                                  throws XPathException

Throws:

XPathException

parseContextItemDeclaration

protected void parseContextItemDeclaration()
                                    throws XPathException

Parse a context item declaration. Allowed only in XQuery 1.1

Throws:

XPathException

parseFunctionDeclaration

protected void parseFunctionDeclaration(int functionOptions)
                                 throws XPathException

Parse a function declaration.

Syntax:
<"declare" "function"> QName "(" ParamList? ")" ("as" SequenceType)? (EnclosedExpr | "external")

On entry, the "define function" has already been recognized

Throws:

XPathException - if a syntax error is found

parseUpdatingFunctionDeclaration

protected void parseUpdatingFunctionDeclaration()
                                         throws XPathException

Parse an updating function declaration (allowed in XQuery Update only)

Throws:

XPathException

setDefaultValue

public Expression setDefaultValue(String exp)

Parse the expression (inside a string literal) used to define default values for external variables. This requires instantiating a nested XPath parser. (This is a Saxon extension for XQuery 1.0 which becomes obsolete with XQuery 1.1)

Parameters:

exp - holds the expression used to define a default value

Returns:

the compiled expression that computes the default value

parseForExpression

protected Expression parseForExpression()
                                 throws XPathException

Parse a FLWOR expression. This replaces the XPath "for" expression. Full syntax:

[41] FLWORExpr ::= (ForClause | LetClause)+ WhereClause? OrderByClause? "return" ExprSingle [42] ForClause ::= <"for" "$"> VarName TypeDeclaration? PositionalVar? "in" ExprSingle ("," "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle)* [43] PositionalVar ::= "at" "$" VarName [44] LetClause ::= <"let" "$"> VarName TypeDeclaration? ":=" ExprSingle ("," "$" VarName TypeDeclaration? ":=" ExprSingle)* [45] WhereClause ::= "where" Expr [46] OrderByClause ::= (<"order" "by"> | <"stable" "order" "by">) OrderSpecList [47] OrderSpecList ::= OrderSpec ("," OrderSpec)* [48] OrderSpec ::= ExprSingle OrderModifier [49] OrderModifier ::= ("ascending" | "descending")? (<"empty" "greatest"> | <"empty" "least">)? ("collation" StringLiteral)?

Overrides:

parseForExpression in class ExpressionParser

Returns:

the resulting subexpression

Throws:

XPathException - if any error is encountered

makeLetExpression

protected LetExpression makeLetExpression()

Make a LetExpression. This returns an ordinary LetExpression if tracing is off, and an EagerLetExpression if tracing is on. This is so that trace events occur in an order that the user can follow.

Returns:

the constructed "let" expression

parseForClauseAllowingVersion

protected ForExpression parseForClauseAllowingVersion(ExpressionParser.ForClause clause,
                                                      StructuredQName varQName)
                                               throws XPathException

Parse an "outer for" clause - XQuery 1.1 only

Parameters:

clause - the "for clause"

varQName -

Throws:

XPathException

checkForClauseAllowingEmpty

protected void checkForClauseAllowingEmpty(ExpressionParser.ForClause clause)
                                    throws XPathException

Check a ForClause for an "outer for"

Throws:

XPathException - if invalid

parseGroupByClause

protected void parseGroupByClause(List clauseList)
                           throws XPathException

Parse a Group By clause. Not supported in 1.0; subclassed in the XQuery 1.1 parser

Throws:

XPathException

processGroupingExpression

protected Expression processGroupingExpression(List<ExpressionParser.FLWORClause> clauseList,
                                               Expression action)
                                        throws XPathException

Process a grouping expression Not supported in 1.0; subclassed in the XQuery 1.1 parser

Parameters:

clauseList - the list of clauses (for, let, group by)

action - the return clause, optionally wrapped with if-then-else to reflect the where clause

Throws:

XPathException

makeStringJoin

public static Expression makeStringJoin(Expression exp,
                                        StaticContext env)

Make a string-join expression that concatenates the string-values of items in a sequence with intervening spaces. This may be simplified later as a result of type-checking.

Parameters:

exp - the base expression, evaluating to a sequence

env - the static context

Returns:

a call on string-join to create a string containing the representations of the items in the sequence separated by spaces.

readCollationName

protected String readCollationName()
                            throws XPathException

Throws:

XPathException

parseTypeswitchExpression

protected Expression parseTypeswitchExpression()
                                        throws XPathException

Parse a Typeswitch Expression. This construct is XQuery-only. TypeswitchExpr ::= "typeswitch" "(" Expr ")" CaseClause+ "default" ("$" VarName)? "return" ExprSingle CaseClause ::= "case" ("$" VarName "as")? SequenceType "return" ExprSingle

Overrides:

parseTypeswitchExpression in class ExpressionParser

Returns:

the expression that results from the parsing

Throws:

XPathException

parseValidateExpression

protected Expression parseValidateExpression()
                                      throws XPathException

Parse a Validate Expression. This construct is XQuery-only. The syntax allows: validate mode? { Expr } mode ::= "strict" | "lax"

Overrides:

parseValidateExpression in class ExpressionParser

Returns:

the parsed expression; except that this version of the method always throws an exception

Throws:

XPathException

parseExtensionExpression

protected Expression parseExtensionExpression()
                                       throws XPathException

Parse an Extension Expression. Syntax: "(#" QName arbitrary-text "#)")+ "{" expr? "}"

Overrides:

parseExtensionExpression in class ExpressionParser

Returns:

the parsed expression; except that this version of the method always throws an exception

Throws:

XPathException

parseConstructor

protected Expression parseConstructor()
                               throws XPathException

Parse a node constructor. This is allowed only in XQuery. This method handles both the XML-like "direct" constructors, and the XQuery-based "computed" constructors.

Overrides:

parseConstructor in class ExpressionParser

Returns:

an Expression for evaluating the parsed constructor

Throws:

XPathException - in the event of a syntax error.

parseNamespaceConstructor

protected Expression parseNamespaceConstructor(int offset)
                                        throws XPathException

Throws:

XPathException

parseNamedNamespaceConstructor

protected Expression parseNamedNamespaceConstructor(int offset)
                                             throws XPathException

Throws:

XPathException

makeSimpleContent

protected void makeSimpleContent(Expression content,
                                 SimpleNodeConstructor inst,
                                 int offset)
                          throws XPathException

Make the instructions for the children of a node with simple content (attribute, text, PI, etc)

Parameters:

content - the expression making up the simple content

inst - the skeletal instruction for creating the node

offset - the character position of this construct within the source query

Throws:

XPathException

stringify

public static Expression stringify(Expression exp,
                                   boolean noNodeIfEmpty)
                            throws XPathException

Convert an expression so it generates a space-separated sequence of strings

Parameters:

exp - the expression that calculates the content

noNodeIfEmpty - if true, no node is produced when the value of the content expression is an empty sequence. If false, the effect of supplying an empty sequence is that a node is created whose string-value is a zero-length string. Set to true for text node constructors, false for other kinds of node.

Returns:

an expression that computes the content and converts the result to a character string

Throws:

XPathException

makeStringLiteral

protected Literal makeStringLiteral(String token)
                             throws XPathException

Method to make a string literal from a token identified as a string literal. This is trivial in XPath, but in XQuery the method is overridden to identify pseudo-XML character and entity references

Overrides:

makeStringLiteral in class ExpressionParser

Parameters:

token - the string as written (or as returned by the tokenizer)

Returns:

The string value of the string literal, after dereferencing entity and character references

Throws:

XPathException

URILiteral

public String URILiteral(String in)
                  throws XPathException

Handle a URI literal. This is whitespace-normalized as well as being unescaped

Parameters:

in - the string as written

Returns:

the URI after unescaping of entity and character references followed by whitespace normalization

Throws:

XPathException

normalizeEQName

protected String normalizeEQName(String s)
                          throws XPathException

Convert a QName in expanded-name format "uri":local into Clark format

Overrides:

normalizeEQName in class ExpressionParser

Parameters:

s - the QName in expanded-name format

Returns:

the corresponding expanded name in Clark format

Throws:

XPathException

lookAhead

protected void lookAhead()
                  throws XPathException

Lookahead one token, catching any exception thrown by the tokenizer. This method is only called from the query parser when switching from character-at-a-time mode to tokenizing mode

Throws:

XPathException

atStartOfRelativePath

protected boolean atStartOfRelativePath()

Description copied from class: ExpressionParser

Test whether the current token is one that can start a RelativePathExpression

Overrides:

atStartOfRelativePath in class ExpressionParser

Returns:

the resulting subexpression

getLanguage

protected String getLanguage()

Get the current language (XPath or XQuery)

Overrides:

getLanguage in class ExpressionParser

Returns:

a string representation of the language being parsed, for use in error messages