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

    • XQUERY10

      public static String XQUERY10
    • XQUERY30

      public static String XQUERY30
    • queryVersion

      protected String queryVersion
    • executable

      protected Executable executable
    • importedModules

      public Set importedModules
    • namespacesToBeSealed

      List<String> namespacesToBeSealed
    • schemaImports

      List<net.sf.saxon.query.QueryParser.Import> schemaImports
    • moduleImports

      List<net.sf.saxon.query.QueryParser.Import> moduleImports
    • FUNCTION_IS_UPDATING

      protected static final int FUNCTION_IS_UPDATING
      See Also:
    • FUNCTION_IS_PRIVATE

      protected static final int FUNCTION_IS_PRIVATE
      See Also:
    • FUNCTION_IS_NONDETERMINISTIC

      protected static final int FUNCTION_IS_NONDETERMINISTIC
      See Also:
  • Constructor Details

    • QueryParser

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

    • newParser

      public QueryParser newParser()
      Create a new parser of the same kind
      Returns:
      a new parser of the same kind as this one
    • 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
    • getPermittedFunctions

      public int getPermittedFunctions()
      Get the permitted set of standard functions in this environment
      Returns:
      a code indicating which system library functions are supported in this version of the language
    • 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
    • customizeTokenizer

      protected void customizeTokenizer(Tokenizer t)
      Callback to tailor the tokenizer
      Overrides:
      customizeTokenizer in class ExpressionParser
      Parameters:
      t - the Tokenizer to be customized
    • 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 - the location in the source query
      errorCode - the error code
      Throws:
      XPathException - always thrown: an exception containing the supplied message
    • parseAnnotations

      protected int parseAnnotations() throws XPathException
      Throws:
      XPathException
    • 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
    • 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 - if parsing fails
    • parseDefaultDecimalFormat

      protected void parseDefaultDecimalFormat() throws XPathException
      Throws:
      XPathException
    • parseContextItemDeclaration

      protected void parseContextItemDeclaration() throws XPathException
      Parse a context item declaration. Allowed only in XQuery 3.0
      Throws:
      XPathException - if parsing fails
    • parseFunctionDeclaration

      protected void parseFunctionDeclaration(int functionOptions) 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:
      functionOptions - function annotations such as updating, deterministic etc
      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 - if parsing fails or if updating functions are not allowed
    • 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 3.0)
      Parameters:
      exp - holds the expression used to define a default value
      Returns:
      the compiled expression that computes the default value
    • 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 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
    • checkForClauseAllowingEmpty

      protected void checkForClauseAllowingEmpty(ForClause clause) throws XPathException
      Check a ForClause for an "outer for"
      Parameters:
      clause - the clause to be checked
      Throws:
      XPathException - if invalid
    • parseCountClause

      protected void parseCountClause(List clauseList) throws XPathException
      Parse a count clause. Not supported in 1.0; subclassed in the XQuery 1.1 parser
      Parameters:
      clauseList - the list of clauses for the expression, to which this clause will be added
      Throws:
      XPathException - if a static error is found
    • parseGroupByClause

      protected void parseGroupByClause(List<Clause> clauseList) throws XPathException
      Parse a Group By clause. Not supported in 1.0; subclassed in the XQuery 3.0 parser
      Parameters:
      clauseList - the list of clauses for the expression, to which this clause will be added
      Throws:
      XPathException - if a static error is found
    • parseWindowClause

      protected void parseWindowClause(List<Clause> clauseList) throws XPathException
      Parse a tumbling or sliding window clause. Not supported in 1.0; subclassed in the XQuery 3.0 parser
      Parameters:
      clauseList - the list of clauses for the expression, to which this clause will be added
      Throws:
      XPathException - if a static error is found
    • 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 - if parsing fails
    • 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 - if parsing fails
    • 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 - if parsing fails
    • 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 - if a static error is encountered
    • stringify

      public static Expression stringify(Expression exp, boolean noNodeIfEmpty, Configuration config) 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.
      config - the Saxon configuration
      Returns:
      an expression that computes the content and converts the result to a character string
      Throws:
      XPathException - if parsing fails
    • 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 - if parsing fails
    • 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
    • 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 - if parsing fails
    • 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