Class QueryParser


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

      • 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"> 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
      • 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