Class QueryParser


public class QueryParser extends ExpressionParser
This class defines extensions to the XPath parser to handle the additional syntax supported in XQuery
  • Field Details

    • executable

      protected Executable executable
    • importedModules

      public Set importedModules
  • Constructor Details

    • QueryParser

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

    • makeXQueryExpression

      public XQueryExpression makeXQueryExpression(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(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, 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(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(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 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