Package net.sf.saxon.query

Class XQueryParser

java.lang.Object

net.sf.saxon.expr.parser.XPathParser

net.sf.saxon.query.XQueryParser

public class XQueryParser
extends XPathParser

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

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	XQueryParser.Import
static class	XQueryParser.Unescaper

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

XPathParser.Accelerator, XPathParser.InlineFunctionDetails, XPathParser.NestedLocation, XPathParser.ParsedLanguage

Field Summary

Fields

Modifier and Type	Field	Description
protected Executable	executable
final Set<NamespaceUri>	importedModules
static final StructuredQName	SAXON_MEMO_FUNCTION

Fields inherited from class net.sf.saxon.expr.parser.XPathParser

allowSaxonExtensions, allowXPath30XSLTExtensions, catchDepth, charChecker, codeInjector, env, inlineFunctionStack, language, languageVersion, parserExtension, qNameParser, rangeVariables, scanOnly, t

Constructor Summary

Constructors

Constructor	Description
XQueryParser(StaticContext env)	Constructor for internal use: this class should be instantiated via the QueryModule

Method Summary

Modifier and Type	Method	Description
void	applySchemaImports(List<XQueryParser.Import> schemaImports)
protected boolean	atStartOfRelativePath()	Test whether the current token is one that can start a RelativePathExpression, satisfying the special rule for disambiguation after a lone leading slash.
protected static boolean	containsLoopingClause(List<Clause> clauseList)
static void	createRunTimeFunctionLibrary(QueryModule mainModule, Configuration config, Executable exec)
protected void	customizeTokenizer(Tokenizer t)	Callback to tailor the tokenizer
protected void	ensureSchemaAware(String featureName)
Executable	getExecutable()	Get the executable containing this expression.
protected String	getLanguage()	Get the current language (XPath or XQuery)
protected boolean	isMaybeNamedConstructor()
boolean	isStreaming()	Ask whether the streaming option has been set, that is, whether subsequent calls on parseQuery() will compile queries to be capable of executing in streaming mode.
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, boolean doUnescaping)	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
protected AnnotationList	parseAnnotationsList()	Parse the annotations that can appear in a variable or function declaration
protected Expression	parseComputedNodeConstructor()	Parse a node constructor.
protected Expression	parseDeepUpdateExpression()	Parse an update map|array Expression.
protected Expression	parseDirectCommentConstructor()
protected Expression	parseDirectElementConstructor(boolean isNested)	Parse a direct element constructor
protected Expression	parseDirectPIConstructor()
protected Expression	parseExtensionExpression()	Parse an Extension Expression.
protected Expression	parseFLWORExpression()	Parse a FLWOR expression.
void	parseFunctionDeclaration(AnnotationList annotations)	Parse a function declaration.
protected void	parseItemTypeDeclaration(AnnotationList annotations)	Parse a type alias declaration.
final void	parseLibraryModule(String queryString, QueryModule env)	Parse a library module.
protected void	parseOutputDeclaration(StructuredQName varName, String value)
protected void	parseRevalidationDeclaration()	Parse the "declare revalidation" declaration.
protected Expression	parseStringConstructor()	Parse a string constructor: introduced in XQuery 3.1.
protected Expression	parseSwitchExpression()	Parse a Switch Expression.
protected Expression	parseTryCatchExpression()	Parse a Try/Catch Expression.
protected Expression	parseTypeswitchExpression()	Parse a Typeswitch Expression.
protected Expression	parseValidateExpression()	Parse a Validate Expression.
protected String	readCollationName()
protected void	requireXQuery(String construct)
void	setExecutable(Executable exec)	Set the executable used for this query expression
void	setStreaming(boolean option)	Say whether the query should be compiled and evaluated to use streaming.
static Expression	stringify(Expression exp, boolean noNodeIfEmpty, StaticContext env)	Convert an expression so it generates a space-separated sequence of strings
protected void	testPermittedAxis(int axis, String errorCode)
protected String	unescape(String token)	Unescape character references and built-in entity references in a string
String	uriLiteral(String in)	Handle a URI literal.

Methods inherited from class net.sf.saxon.expr.parser.XPathParser

checkAllowedFunctionArgument, checkLanguageVersion30, checkLanguageVersion31, checkLanguageVersion40, checkLanguageVersion40, checkMapExtensions, checkSyntaxExtensions, currentTokenDisplay, declareRangeVariable, expect, expectKeyword, expectName, expectStringLiteral, findOuterRangeVariable, findOuterRangeVariable, findRangeVariable, gatherComponents, getCodeInjector, getMissingFunctionExplanation, getOffsetAfterParsing, getPlainType, getQNameParser, getRangeVariables, getStaticContext, getTokenizer, grumble, grumble, grumble, grumble, grumble, handleExternalFunctionDeclaration, isAllowAbsentExpression, isAllowArgumentKeywords, isAllowXPath31Syntax, isAllowXPath40Syntax, isKeyword, isKeyword, isKeywordPair, isNamespaceTestAllowed, isReservedFunctionName, isReservedInQuery, makeFingerprint, makeInlineFunctionValue, makeLocalQNameTest, makeLocation, makeLocation, makeLookupExpression, makeNamedFunctionReference, makeNamespaceQNameTest, makeNameTest, makeNestedLocation, makeNodeName, makeQNameTest, makeStructuredQName, makeStructuredQNameSilently, makeTracer, nextToken, notAllowedInPattern, parse, parseArrayCurlyConstructor, parseArrayItemType, parseArraySquareConstructor, parseArrowPostfix, parseBasicStep, parseBinaryExpression, parseConstant, parseDynamicFunctionCall, parseEnumType, parseEQName, parseExpression, parseExprSingle, parseExtendedSequenceType, parseFilterExprAM, parseFocusFunction, parseFunctionArgument, parseFunctionCall, parseFunctionItemType, parseInlineFunction, parseInlineFunctionBody, parseItemType, parseItemType, parseLookup, parseMapConstructor, parseMapItemType, parseMappingArrowPostfix, parseMethodCall, parseNamedFunctionReference, parseNameTestUnion, parseNodeTest, parseNumericLiteral, parseOccurrenceIndicator, parseParenthesizedExpression, parsePathExpression, parsePredicate, parsePredicate, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseSimpleMappingExpression, parseStepExpression, parseStringLiteral, parseStringTemplate, parseUnionNodeTest, readKeyword, readName, readOptionalAsClause, readToken, readVariableName, reportMissingFunction, resolveFunctionName, resolveVariableReference, setAccelerator, setAllowAbsentExpression, setCatchDepth, setCodeInjector, setLanguage, setLocation, setLocation, setLocation, setParserExtension, setQNameParser, setRangeVariables, setRangeVariableStack, setScanOnly, tryKeyword, tryKeywordPair, undeclareRangeVariable, warning, whyDisallowedType

Methods inherited from class java.lang.Object

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

Field Details

executable

protected Executable executable

importedModules

public final Set<NamespaceUri> importedModules

SAXON_MEMO_FUNCTION

public static final StructuredQName SAXON_MEMO_FUNCTION

Constructor Details

XQueryParser

public XQueryParser(StaticContext env)

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

Method Details

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 - if the expression contains static errors

createRunTimeFunctionLibrary

public static void createRunTimeFunctionLibrary(QueryModule mainModule,
 Configuration config,
 Executable exec)

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

customizeTokenizer

protected void customizeTokenizer(Tokenizer t)

Callback to tailor the tokenizer

Overrides:

customizeTokenizer in class XPathParser

Parameters:

t - the Tokenizer to be customized

setStreaming

public void setStreaming(boolean option)

Say whether the query should be compiled and evaluated to use streaming. This affects subsequent calls on the parseQuery() method. This option requires Saxon-EE.

Parameters:

option - if true, the compiler will attempt to compile a query to be capable of executing in streaming mode. If the query cannot be streamed, a compile-time exception is reported. In streaming mode, the source document is supplied as a stream, and no tree is built in memory. The default is false.

Since:

9.6

isStreaming

public boolean isStreaming()

Ask whether the streaming option has been set, that is, whether subsequent calls on parseQuery() will compile queries to be capable of executing in streaming mode.

Returns:

true if the streaming option has been set.

Since:

9.6

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

parseAnnotationsList

protected AnnotationList parseAnnotationsList()
                                       throws XPathException

Parse the annotations that can appear in a variable or function declaration

Overrides:

parseAnnotationsList in class XPathParser

Returns:

the annotations as a list

Throws:

XPathException - in the event of a syntax error

parseRevalidationDeclaration

protected void parseRevalidationDeclaration()
                                     throws XPathException

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

Throws:

XPathException - if the syntax is incorrect, or is not allowed in this XQuery processor

ensureSchemaAware

protected void ensureSchemaAware(String featureName)
                          throws XPathException

Throws:

XPathException

applySchemaImports

public void applySchemaImports(List<XQueryParser.Import> schemaImports)
                        throws XPathException

Throws:

XPathException

parseFunctionDeclaration

public void parseFunctionDeclaration(AnnotationList annotations)
                              throws XPathException

Parse a function declaration.

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

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

Parameters:

annotations - the list of annotations that have been encountered for this function declaration

Throws:

XPathException - if a syntax error is found

parseItemTypeDeclaration

protected void parseItemTypeDeclaration(AnnotationList annotations)
                                 throws XPathException

Parse a type alias declaration. Allowed only in Saxon-PE and higher

Throws:

XPathException - if parsing fails

parseOutputDeclaration

protected void parseOutputDeclaration(StructuredQName varName,
 String value)
                               throws XPathException

Throws:

XPathException

parseFLWORExpression

protected Expression parseFLWORExpression()
                                   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:

parseFLWORExpression in class XPathParser

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

containsLoopingClause

protected static boolean containsLoopingClause(List<Clause> clauseList)

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 XPathParser

Returns:

the expression that results from the parsing

Throws:

XPathException - if parsing fails

parseSwitchExpression

protected Expression parseSwitchExpression()
                                    throws XPathException

Parse a Switch Expression. This construct is XQuery-3.0-only. SwitchExpr ::= "switch" ("(" Expr ")")? SwitchCaseClause+ "default" "return" ExprSingle SwitchCaseClause ::= ("case" ExprSingle)+ "return" ExprSingle

4.0 allows the parenthesized expression to be omitted, and also allows braces around the cases. This means there are three ways of recognizing the start of the expression: (a) "switch (", (b) "switch {" (c) "switch case"}

Overrides:

parseSwitchExpression in class XPathParser

Returns:

the parsed expression

Throws:

XPathException - in the event of a syntax error

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 XPathParser

Returns:

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

Throws:

XPathException - if parsing fails

parseDeepUpdateExpression

protected Expression parseDeepUpdateExpression()
                                        throws XPathException

Parse an update map|array Expression.

Overrides:

parseDeepUpdateExpression in class XPathParser

Returns:

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

Throws:

XPathException - if a static error is found

parseExtensionExpression

protected Expression parseExtensionExpression()
                                       throws XPathException

Parse an Extension Expression. Syntax: "(#" QName arbitrary-text "#)")+ "{" expr? "}" The pragma "(#...#)" is represented as a single token, which is the current token on entry to this method.

Overrides:

parseExtensionExpression in class XPathParser

Returns:

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

Throws:

XPathException - if parsing fails

isMaybeNamedConstructor

protected boolean isMaybeNamedConstructor()

Overrides:

isMaybeNamedConstructor in class XPathParser

parseComputedNodeConstructor

protected Expression parseComputedNodeConstructor()
                                           throws XPathException

Parse a node constructor. This is allowed only in XQuery. This method handles the XQuery-based "computed" constructors, not the XML-style "direct" constructors. On entry the current token is the node-kind keyword such as "element" or "attribute".

Overrides:

parseComputedNodeConstructor in class XPathParser

Returns:

an Expression for evaluating the parsed constructor

Throws:

XPathException - in the event of a syntax error.

parseDirectPIConstructor

protected Expression parseDirectPIConstructor()
                                       throws XPathException

Overrides:

parseDirectPIConstructor in class XPathParser

Throws:

XPathException

parseDirectCommentConstructor

protected Expression parseDirectCommentConstructor()
                                            throws XPathException

Throws:

XPathException

parseTryCatchExpression

protected Expression parseTryCatchExpression()
                                      throws XPathException

Parse a Try/Catch Expression. This construct is XQuery-3.0 only. The syntax allows: try { Expr } catch NameTest ('|' NameTest)* { Expr } We don't currently implement the CatchVars

Overrides:

parseTryCatchExpression in class XPathParser

Returns:

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

Throws:

XPathException - if a static error is found

makeSimpleContent

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)

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

parseDirectElementConstructor

protected Expression parseDirectElementConstructor(boolean isNested)
                                            throws XPathException

Parse a direct element constructor

Overrides:

parseDirectElementConstructor in class XPathParser

Parameters:

isNested - true if this constructor is nested directly as part of the content of another element constructor. This has the effect that the child element is not copied, which means that namespace inheritance (which only happens during copying) has no effect

Returns:

the expression representing the constructor

Throws:

XPathException - if a syntax error is found

stringify

public static Expression stringify(Expression exp,
 boolean noNodeIfEmpty,
 StaticContext env)

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.

env - the static context

Returns:

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

makeStringLiteral

protected Literal makeStringLiteral(String token,
 boolean doUnescaping)
                             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 XPathParser

Parameters:

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

doUnescaping - if true, XML escape sequences (`&#xHH;`, etc) are recognized and expanded.

Returns:

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

Throws:

XPathException - if parsing fails

unescape

protected String unescape(String token)
                   throws XPathException

Unescape character references and built-in entity references in a string

Overrides:

unescape in class XPathParser

Parameters:

token - the input string, which may include XML-style character references or built-in entity references

Returns:

the string with character references and built-in entity references replaced by their expansion

Throws:

XPathException - if a malformed character or entity reference is found

parseStringConstructor

protected Expression parseStringConstructor()
                                     throws XPathException

Parse a string constructor: introduced in XQuery 3.1. A StringConstructor is delimited by "``[ ... ]``" and contains embedded expressions signalled by "`{" Expr? "}`"

Overrides:

parseStringConstructor in class XPathParser

Throws:

XPathException

requireXQuery

protected void requireXQuery(String construct)
                      throws XPathException

Overrides:

requireXQuery in class XPathParser

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 - if an error is found while unescaping the URI

atStartOfRelativePath

protected boolean atStartOfRelativePath()

Description copied from class: XPathParser

Test whether the current token is one that can start a RelativePathExpression, satisfying the special rule for disambiguation after a lone leading slash.

Overrides:

atStartOfRelativePath in class XPathParser

Returns:

true if the current token is to be interpreted as the start of a relative path expression.

testPermittedAxis

protected void testPermittedAxis(int axis,
 String errorCode)
                          throws XPathException

Overrides:

testPermittedAxis in class XPathParser

Throws:

XPathException

getLanguage

protected String getLanguage()

Get the current language (XPath or XQuery)

Overrides:

getLanguage in class XPathParser

Returns:

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