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

      • XQUERY10

        public static java.lang.String XQUERY10
      • XQUERY30

        public static java.lang.String XQUERY30
      • queryVersion

        protected java.lang.String queryVersion
      • importedModules

        public java.util.Set importedModules
      • namespacesToBeSealed

        java.util.List<java.lang.String> namespacesToBeSealed
      • schemaImports

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

        java.util.List<net.sf.saxon.query.QueryParser.Import> moduleImports
      • 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
        Returns:
        a new parser of the same kind as this one
      • makeXQueryExpression

        public XQueryExpression makeXQueryExpression​(java.lang.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
      • 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,
                               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
      • 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
      • 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​(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. (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​(java.util.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​(java.util.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​(java.util.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.
      • 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
      • 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.
      • 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​(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 - if parsing fails
      • URILiteral

        public java.lang.String URILiteral​(java.lang.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 java.lang.String normalizeEQName​(java.lang.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 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