Class QueryParser


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

        java.util.List namespacesToBeSealed
      • schemaImports

        java.util.List schemaImports
      • moduleImports

        java.util.List moduleImports
    • Constructor Detail

      • QueryParser

        protected QueryParser()
        Protected Constructor: this class should be instantiated via the StaticQueryContext
    • Method Detail

      • getExecutable

        public Executable getExecutable()
        Get the executable containing this expression.
      • setExecutable

        public void setExecutable​(Executable exec)
        Set the executable used for this query expression
      • parseLibraryModule

        public final void parseLibraryModule​(java.lang.String queryString,
                                             StaticQueryContext env)
                                      throws StaticError
        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:
        StaticError - if the expression contains a syntax error
      • grumble

        protected void grumble​(java.lang.String message,
                               java.lang.String errorCode)
                        throws StaticError
        Report a static error
        Overrides:
        grumble in class ExpressionParser
        Parameters:
        message - the error message
        errorCode - the error code
        Throws:
        StaticError - always thrown: an exception containing the supplied message
      • applyModuleImport

        public void applyModuleImport​(net.sf.saxon.query.QueryParser.Import mImport)
                               throws StaticError
        Throws:
        StaticError
      • 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.
      • parseForExpression

        protected Expression parseForExpression()
                                         throws StaticError
        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:
        StaticError - 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.
      • parseTypeswitchExpression

        protected Expression parseTypeswitchExpression()
                                                throws StaticError
        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
        Throws:
        StaticError
      • parseConstructor

        protected Expression parseConstructor()
                                       throws StaticError
        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:
        StaticError - in the event of a syntax error.
      • makeStringLiteral

        protected StringValue makeStringLiteral​(java.lang.String token)
                                         throws StaticError
        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 -
        Returns:
        The string value of the string literal, after dereferencing entity and character references
        Throws:
        StaticError
      • getLanguage

        protected java.lang.String getLanguage()
        Get the current language (XPath or XQuery)
        Overrides:
        getLanguage in class ExpressionParser