Edit on GitHub

sqlglot.parsers.dax

View Source

 1from __future__ import annotations
 2
 3from sqlglot import exp, parser
 4from sqlglot.tokens import TokenType
 5
 6
 7class DAXParser(parser.Parser):
 8    CONJUNCTION = {
 9        **parser.Parser.CONJUNCTION,
10        TokenType.DAMP: exp.And,
11    }
12
13    DISJUNCTION = {
14        **parser.Parser.DISJUNCTION,
15        TokenType.DPIPE: exp.Or,
16    }
17
18    def _parse_statement(self) -> exp.Expr | None:
19        if not self._match_text_seq("EVALUATE"):
20            return None
21
22        query = self._parse_table_expression()
23
24        if query and self._match(TokenType.ORDER_BY):
25            order = exp.Order(expressions=self._parse_csv(self._parse_ordered))
26            query = query.order_by(self.expression(order), copy=False)
27
28        return query
29
30    def _parse_table_expression(self) -> exp.Query | None:
31        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
32            query = self._parse_table_expression()
33            self._match(TokenType.COMMA)
34            where = self._parse_disjunction()
35            self._match_r_paren()
36            return query.where(where, copy=False) if query else None
37
38        table = self._parse_table_parts()
39        return exp.select("*").from_(table, copy=False) if table else None
40
41    def _parse_column(self) -> exp.Expr | None:
42        this = super()._parse_column()
43
44        # Combine adjacent identifiers into a column reference: Table[Column]
45        if isinstance(this, exp.Column) and (column := self._parse_identifier()):
46            this = self.expression(exp.Column(this=column, table=this.this))
47
48        return this

class DAXParser(sqlglot.parser.Parser): View Source

 8class DAXParser(parser.Parser):
 9    CONJUNCTION = {
10        **parser.Parser.CONJUNCTION,
11        TokenType.DAMP: exp.And,
12    }
13
14    DISJUNCTION = {
15        **parser.Parser.DISJUNCTION,
16        TokenType.DPIPE: exp.Or,
17    }
18
19    def _parse_statement(self) -> exp.Expr | None:
20        if not self._match_text_seq("EVALUATE"):
21            return None
22
23        query = self._parse_table_expression()
24
25        if query and self._match(TokenType.ORDER_BY):
26            order = exp.Order(expressions=self._parse_csv(self._parse_ordered))
27            query = query.order_by(self.expression(order), copy=False)
28
29        return query
30
31    def _parse_table_expression(self) -> exp.Query | None:
32        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
33            query = self._parse_table_expression()
34            self._match(TokenType.COMMA)
35            where = self._parse_disjunction()
36            self._match_r_paren()
37            return query.where(where, copy=False) if query else None
38
39        table = self._parse_table_parts()
40        return exp.select("*").from_(table, copy=False) if table else None
41
42    def _parse_column(self) -> exp.Expr | None:
43        this = super()._parse_column()
44
45        # Combine adjacent identifiers into a column reference: Table[Column]
46        if isinstance(this, exp.Column) and (column := self._parse_identifier()):
47            this = self.expression(exp.Column(this=column, table=this.this))
48
49        return this

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:

error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
max_nodes: Maximum number of AST nodes to prevent memory exhaustion. Set to -1 (default) to disable the check.

CONJUNCTION = {<TokenType.AND: 34>: <class 'sqlglot.expressions.core.And'>, <TokenType.DAMP: 62>: <class 'sqlglot.expressions.core.And'>}

DISJUNCTION = {<TokenType.OR: 35>: <class 'sqlglot.expressions.core.Or'>, <TokenType.DPIPE: 37>: <class 'sqlglot.expressions.core.Or'>}

Inherited Members

sqlglot.parser.Parser: Parser; FUNCTIONS; NO_PAREN_FUNCTIONS; STRUCT_TYPE_TOKENS; NESTED_TYPE_TOKENS; ENUM_TYPE_TOKENS; AGGREGATE_TYPE_TOKENS; TYPE_TOKENS; SIGNED_TO_UNSIGNED_TYPE_TOKEN; SUBQUERY_PREDICATES; SUBQUERY_TOKENS; RESERVED_TOKENS; TEXT_MATCH_EXCLUDED_TOKENS; DB_CREATABLES; CREATABLES; TRIGGER_EVENTS; ALTERABLES; ID_VAR_TOKENS; TABLE_ALIAS_TOKENS; ALIAS_TOKENS; COLON_PLACEHOLDER_TOKENS; ARRAY_CONSTRUCTORS; COMMENT_TABLE_ALIAS_TOKENS; UPDATE_ALIAS_TOKENS; TRIM_TYPES; IDENTIFIER_TOKENS; BRACKETS; COLUMN_POSTFIX_TOKENS; TABLE_POSTFIX_TOKENS; FUNC_TOKENS; ASSIGNMENT; EQUALITY; COMPARISON; BITWISE; TERM; FACTOR; EXPONENT; TIMES; TIMESTAMPS; SET_OPERATIONS; JOIN_METHODS; JOIN_SIDES; JOIN_KINDS; JOIN_HINTS; TABLE_TERMINATORS; LAMBDAS; TYPED_LAMBDA_ARGS; LAMBDA_ARG_TERMINATORS; COLUMN_OPERATORS; CAST_COLUMN_OPERATORS; EXPRESSION_PARSERS; STATEMENT_PARSERS; UNARY_PARSERS; STRING_PARSERS; NUMERIC_PARSERS; PRIMARY_PARSERS; PLACEHOLDER_PARSERS; RANGE_PARSERS; PIPE_SYNTAX_TRANSFORM_PARSERS; PROPERTY_PARSERS; CONSTRAINT_PARSERS; ALTER_PARSERS; ALTER_ALTER_PARSERS; SCHEMA_UNNAMED_CONSTRAINTS; NO_PAREN_FUNCTION_PARSERS; INVALID_FUNC_NAME_TOKENS; FUNCTIONS_WITH_ALIASED_ARGS; KEY_VALUE_DEFINITIONS; FUNCTION_PARSERS; QUERY_MODIFIER_PARSERS; QUERY_MODIFIER_TOKENS; SET_PARSERS; SHOW_PARSERS; TYPE_LITERAL_PARSERS; TYPE_CONVERTERS; DDL_SELECT_TOKENS; PRE_VOLATILE_TOKENS; TRANSACTION_KIND; TRANSACTION_CHARACTERISTICS; CONFLICT_ACTIONS; TRIGGER_TIMING; TRIGGER_DEFERRABLE; CREATE_SEQUENCE; ISOLATED_LOADING_OPTIONS; USABLES; CAST_ACTIONS; SCHEMA_BINDING_OPTIONS; PROCEDURE_OPTIONS; EXECUTE_AS_OPTIONS; KEY_CONSTRAINT_OPTIONS; WINDOW_EXCLUDE_OPTIONS; INSERT_ALTERNATIVES; CLONE_KEYWORDS; HISTORICAL_DATA_PREFIX; HISTORICAL_DATA_KIND; OPCLASS_FOLLOW_KEYWORDS; OPTYPE_FOLLOW_TOKENS; TABLE_INDEX_HINT_TOKENS; VIEW_ATTRIBUTES; WINDOW_ALIAS_TOKENS; WINDOW_BEFORE_PAREN_TOKENS; WINDOW_SIDES; JSON_KEY_VALUE_SEPARATOR_TOKENS; FETCH_TOKENS; ADD_CONSTRAINT_TOKENS; DISTINCT_TOKENS; UNNEST_OFFSET_ALIAS_TOKENS; SELECT_START_TOKENS; COPY_INTO_VARLEN_OPTIONS; IS_JSON_PREDICATE_KIND; ODBC_DATETIME_LITERALS; ON_CONDITION_TOKENS; PRIVILEGE_FOLLOW_TOKENS; DESCRIBE_STYLES; SET_ASSIGNMENT_DELIMITERS; ANALYZE_STYLES; ANALYZE_EXPRESSION_PARSERS; PARTITION_KEYWORDS; AMBIGUOUS_ALIAS_TOKENS; OPERATION_MODIFIERS; RECURSIVE_CTE_SEARCH_KIND; SECURITY_PROPERTY_KEYWORDS; MODIFIABLES; STRICT_CAST; PREFIXED_PIVOT_COLUMNS; IDENTIFY_PIVOT_STRINGS; PIVOT_COLUMN_NAMING; LOG_DEFAULTS_TO_LN; TABLESAMPLE_CSV; DEFAULT_SAMPLING_METHOD; SET_REQUIRES_ASSIGNMENT_DELIMITER; TRIM_PATTERN_FIRST; STRING_ALIASES; MODIFIERS_ATTACHED_TO_SET_OP; SET_OP_MODIFIERS; NO_PAREN_IF_COMMANDS; JSON_ARROWS_REQUIRE_JSON_TYPE; COLON_IS_VARIANT_EXTRACT; COLON_CHAIN_IS_SINGLE_EXTRACT; VALUES_FOLLOWED_BY_PAREN; SUPPORTS_IMPLICIT_UNNEST; INTERVAL_SPANS; SUPPORTS_PARTITION_SELECTION; WRAPPED_TRANSFORM_COLUMN_CONSTRAINT; OPTIONAL_ALIAS_TOKEN_CTE; ALTER_RENAME_REQUIRES_COLUMN; ALTER_TABLE_PARTITIONS; JOINS_HAVE_EQUAL_PRECEDENCE; ZONE_AWARE_TIMESTAMP_CONSTRUCTOR; MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS; JSON_EXTRACT_REQUIRES_JSON_EXPRESSION; ADD_JOIN_ON_TRUE; SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT; ADJACENT_STRINGS_CANNOT_BE_CONNECTED; SHOW_TRIE; SET_TRIE; error_level; error_message_context; max_errors; max_nodes; dialect; sql; errors; reset; raise_error; validate_expression; parse; parse_into; check_errors; expression; parse_set_operation; build_cast