QueryParser (saxon JavaDoc)

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

```
public class QueryParser
extends ExpressionParser
```
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 and Description

protected static class QueryParser.LetClause
- Nested classes/interfaces inherited from class net.sf.saxon.expr.ExpressionParser
  ExpressionParser.FLWORClause, ExpressionParser.ForClause, ExpressionParser.TemporaryContainer

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`QueryParser.LetClause`

Field Summary

Fields
Modifier and Type	Field and Description
`protected Executable`	`executable`
`protected static int`	`FUNCTION_IS_NONDETERMINISTIC`
`protected static int`	`FUNCTION_IS_PRIVATE`
`protected static int`	`FUNCTION_IS_UPDATING`
`Set`	`importedModules`
`(package private) List`	`moduleImports`
`(package private) List`	`namespacesToBeSealed`
`protected String`	`queryVersion`
`(package private) List`	`schemaImports`
`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

Constructors
Constructor and Description

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

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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
```
  - namespacesToBeSealed
```
List namespacesToBeSealed
```
  - schemaImports
```
List schemaImports
```
  - moduleImports
```
List moduleImports
```
  - 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

Class QueryParser

Nested Class Summary

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

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

XQUERY10

XQUERY30

queryVersion

executable

importedModules

namespacesToBeSealed

schemaImports

moduleImports

FUNCTION_IS_UPDATING

FUNCTION_IS_PRIVATE

FUNCTION_IS_NONDETERMINISTIC

Constructor Detail

QueryParser

Method Detail

newParser

makeXQueryExpression

getPermittedFunctions

getExecutable

setExecutable

setDisableCycleChecks

parseLibraryModule

grumble

parseRevalidationDeclaration

applyModuleImport

parseDecimalFormatDeclaration

parseDefaultDecimalFormat

parseContextItemDeclaration

parseFunctionDeclaration

parseUpdatingFunctionDeclaration

setDefaultValue

parseForExpression

makeLetExpression

parseForClauseAllowingVersion

checkForClauseAllowingEmpty

parseGroupByClause

processGroupingExpression

makeStringJoin

readCollationName

parseTypeswitchExpression

parseValidateExpression

parseExtensionExpression

parseConstructor

parseNamespaceConstructor

parseNamedNamespaceConstructor

makeSimpleContent

stringify

makeStringLiteral

URILiteral

normalizeEQName

lookAhead

atStartOfRelativePath

getLanguage