## net.sf.saxon.query
Class QueryParser

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

Direct Known Subclasses:
  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

Nested classes/interfaces inherited from class net.sf.saxon.expr.ExpressionParser
`ExpressionParser.ForClause, ExpressionParser.TemporaryContainer`

Field Summary
`protected Executable` `executable`
`java.util.Set` `importedModules`

Fields inherited from class net.sf.saxon.expr.ExpressionParser
`compileWithTracing, env, language, 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)`
`Executable` `getExecutable()` Get the executable containing this expression.
`protected java.lang.String` `getLanguage()` Get the current language (XPath or XQuery)
`protected void` `grumble(java.lang.String message, java.lang.String errorCode)` Report a static error
`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(java.lang.String token)` Method to make a string literal from a token identified as a string literal.
`XQueryExpression` `makeXQueryExpression(java.lang.String query, QueryModule staticContext, Configuration config)` Create an XQueryExpression
`protected Expression` `parseConstructor()` Parse a node constructor.
`protected Expression` `parseExtensionExpression()` Parse an Extension Expression.
`protected Expression` `parseForExpression()` Parse a FLWOR expression.
`protected void` `parseFunctionDeclaration(boolean isUpdating)` Parse a function declaration.
`void` `parseLibraryModule(java.lang.String queryString, QueryModule env)` Parse a library module.
`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.
`Expression` `setDefaultValue(java.lang.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

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

`currentTokenDisplay, declareRangeVariable, expect, getRangeVariableStack, getTokenizer, grumble, isCompileWithTracing, isKeyword, makeLocalNameTest, makeNameCode, makeNameCodeSilently, makeNamespaceTest, makeNameTest, makeStructuredQName, makeTracer, nextToken, parse, parseExpression, parseExprSingle, parseFunctionCall, parseMappingExpression, parseNodeTest, parsePattern, parseRelativePath, parseRemainingPath, parseSequenceType, parseSequenceType, parseStepExpression, setCompileWithTracing, setLocation, setLocation, setRangeVariableStack, setScanOnly, undeclareRangeVariable, warning`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### executable

    protected Executable executable

### importedModules

    public java.util.Set importedModules

Constructor Detail

### QueryParser

    public QueryParser()

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

Method Detail

### makeXQueryExpression

    public XQueryExpression makeXQueryExpression(java.lang.String query,
                                                 QueryModule staticContext,
                                                 Configuration config)
                                          throws XPathException

  Create an XQueryExpression

  Parameters:
    `query` - the source text of the query
    `staticContext` - the static context of the query
    `config` - the Saxon configuration
  Returns:
    the compiled XQuery expression
  Throws:
    `XPathException`

### 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(java.lang.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(java.lang.String message,
                           java.lang.String errorCode)
                    throws XPathException

  Report a static error

  Overrides:
    `grumble` in class `ExpressionParser`
  Parameters:
    `message` - the error message
    `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`

### parseFunctionDeclaration

    protected void parseFunctionDeclaration(boolean isUpdating)
                                     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(java.lang.String exp)

  Parse the expression (inside a string literal) used to define default values for external variables. This requires instantiating a nested XPath parser.

  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

### 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.

### 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.

### makeStringLiteral

    protected Literal makeStringLiteral(java.lang.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`

### getLanguage

    protected java.lang.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

Copyright (c) Saxonica Limited. All rights reserved.