sqlglot.parsers.teradata

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, parser
  6from sqlglot.helper import seq_get
  7from sqlglot.tokens import TokenType
  8from sqlglot.trie import new_trie
  9
 10
 11class TeradataParser(parser.Parser):
 12    TABLESAMPLE_CSV = True
 13    VALUES_FOLLOWED_BY_PAREN = False
 14
 15    TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS | {
 16        TokenType.ANTI,
 17        TokenType.SEMI,
 18    }
 19
 20    CHARSET_TRANSLATORS = {
 21        "GRAPHIC_TO_KANJISJIS",
 22        "GRAPHIC_TO_LATIN",
 23        "GRAPHIC_TO_UNICODE",
 24        "GRAPHIC_TO_UNICODE_PadSpace",
 25        "KANJI1_KanjiEBCDIC_TO_UNICODE",
 26        "KANJI1_KanjiEUC_TO_UNICODE",
 27        "KANJI1_KANJISJIS_TO_UNICODE",
 28        "KANJI1_SBC_TO_UNICODE",
 29        "KANJISJIS_TO_GRAPHIC",
 30        "KANJISJIS_TO_LATIN",
 31        "KANJISJIS_TO_UNICODE",
 32        "LATIN_TO_GRAPHIC",
 33        "LATIN_TO_KANJISJIS",
 34        "LATIN_TO_UNICODE",
 35        "LOCALE_TO_UNICODE",
 36        "UNICODE_TO_GRAPHIC",
 37        "UNICODE_TO_GRAPHIC_PadGraphic",
 38        "UNICODE_TO_GRAPHIC_VarGraphic",
 39        "UNICODE_TO_KANJI1_KanjiEBCDIC",
 40        "UNICODE_TO_KANJI1_KanjiEUC",
 41        "UNICODE_TO_KANJI1_KANJISJIS",
 42        "UNICODE_TO_KANJI1_SBC",
 43        "UNICODE_TO_KANJISJIS",
 44        "UNICODE_TO_LATIN",
 45        "UNICODE_TO_LOCALE",
 46        "UNICODE_TO_UNICODE_FoldSpace",
 47        "UNICODE_TO_UNICODE_Fullwidth",
 48        "UNICODE_TO_UNICODE_Halfwidth",
 49        "UNICODE_TO_UNICODE_NFC",
 50        "UNICODE_TO_UNICODE_NFD",
 51        "UNICODE_TO_UNICODE_NFKC",
 52        "UNICODE_TO_UNICODE_NFKD",
 53    }
 54
 55    FUNC_TOKENS = parser.Parser.FUNC_TOKENS - {TokenType.REPLACE}
 56
 57    STATEMENT_PARSERS = {
 58        **parser.Parser.STATEMENT_PARSERS,
 59        TokenType.DATABASE: lambda self: self.expression(
 60            exp.Use(this=self._parse_table(schema=False))
 61        ),
 62        TokenType.REPLACE: lambda self: self._parse_create(),
 63        TokenType.LOCK: lambda self: self._parse_locking_statement(),
 64    }
 65
 66    def _parse_locking_statement(self) -> exp.LockingStatement:
 67        # Reuse exp.LockingProperty parsing for the lock kind, type etc
 68        locking_property = self._parse_locking()
 69        wrapped_query = self._parse_select()
 70
 71        if not wrapped_query:
 72            self.raise_error("Expected SELECT statement after LOCKING clause")
 73
 74        return self.expression(
 75            exp.LockingStatement(this=locking_property, expression=wrapped_query)
 76        )
 77
 78    SET_PARSERS = {
 79        **parser.Parser.SET_PARSERS,
 80        "QUERY_BAND": lambda self: self._parse_query_band(),
 81    }
 82
 83    SET_TRIE = new_trie(key.split(" ") for key in SET_PARSERS)
 84
 85    FUNCTION_PARSERS = {
 86        **parser.Parser.FUNCTION_PARSERS,
 87        # https://docs.teradata.com/r/SQL-Functions-Operators-Exprs-and-Predicates/June-2017/Data-Type-Conversions/TRYCAST
 88        "TRYCAST": parser.Parser.FUNCTION_PARSERS["TRY_CAST"],
 89        "RANGE_N": lambda self: self._parse_rangen(),
 90        "TRANSLATE": lambda self: self._parse_translate(),
 91    }
 92
 93    FUNCTIONS = {
 94        **parser.Parser.FUNCTIONS,
 95        "CARDINALITY": exp.ArraySize.from_arg_list,
 96        "RANDOM": lambda args: exp.Rand(lower=seq_get(args, 0), upper=seq_get(args, 1)),
 97    }
 98
 99    EXPONENT = {
100        TokenType.DSTAR: exp.Pow,
101    }
102
103    def _parse_translate(self) -> exp.TranslateCharacters:
104        this = self._parse_assignment()
105        self._match(TokenType.USING)
106        self._match_texts(self.CHARSET_TRANSLATORS)
107
108        return self.expression(
109            exp.TranslateCharacters(
110                this=this,
111                expression=self._prev.text.upper(),
112                with_error=self._match_text_seq("WITH", "ERROR"),
113            )
114        )
115
116    # FROM before SET in Teradata UPDATE syntax
117    # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/Teradata-VantageTM-SQL-Data-Manipulation-Language-17.20/Statement-Syntax/UPDATE/UPDATE-Syntax-Basic-Form-FROM-Clause
118    def _parse_update(self) -> exp.Update:
119        return self.expression(
120            exp.Update(
121                this=self._parse_table(alias_tokens=self.UPDATE_ALIAS_TOKENS),
122                from_=self._parse_from(joins=True),
123                expressions=self._match(TokenType.SET) and self._parse_csv(self._parse_equality),
124                where=self._parse_where(),
125            )
126        )
127
128    def _parse_rangen(self):
129        this = self._parse_id_var()
130        self._match(TokenType.BETWEEN)
131
132        expressions = self._parse_csv(self._parse_assignment)
133        each = self._match_text_seq("EACH") and self._parse_assignment()
134
135        return self.expression(exp.RangeN(this=this, expressions=expressions, each=each))
136
137    def _parse_query_band(self) -> exp.QueryBand:
138        # Parse: SET QUERY_BAND = 'key=value;key2=value2;' FOR SESSION|TRANSACTION
139        # Also supports: SET QUERY_BAND = 'key=value;' UPDATE FOR SESSION|TRANSACTION
140        # Also supports: SET QUERY_BAND = NONE FOR SESSION|TRANSACTION
141        self._match(TokenType.EQ)
142
143        # Handle both string literals and NONE keyword
144        if self._match_text_seq("NONE"):
145            query_band_string: exp.Expr | None = exp.Var(this="NONE")
146        else:
147            query_band_string = self._parse_string()
148
149        update = self._match_text_seq("UPDATE")
150        self._match_text_seq("FOR")
151
152        # Handle scope - can be SESSION, TRANSACTION, VOLATILE, or SESSION VOLATILE
153        if self._match_text_seq("SESSION", "VOLATILE"):
154            scope = "SESSION VOLATILE"
155        elif self._match_texts(("SESSION", "TRANSACTION")):
156            scope = self._prev.text.upper()
157        else:
158            scope = None
159
160        return self.expression(exp.QueryBand(this=query_band_string, scope=scope, update=update))
161
162    def _parse_index_params(self) -> exp.IndexParameters:
163        this = super()._parse_index_params()
164
165        if this.args.get("on"):
166            this.set("on", None)
167            self._retreat(self._index - 2)
168        return this
169
170    def _parse_function(
171        self,
172        functions: dict[str, t.Callable] | None = None,
173        anonymous: bool = False,
174        optional_parens: bool = True,
175        any_token: bool = False,
176    ) -> exp.Expr | None:
177        # Teradata uses a `(FORMAT <format_string>)` clause after column references to
178        # override the output format. When we see this pattern we do not
179        # parse it as a function call.  The syntax is documented at
180        # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
181        if (
182            self._next
183            and self._next.token_type == TokenType.L_PAREN
184            and self._index + 2 < len(self._tokens)
185            and self._tokens[self._index + 2].token_type == TokenType.FORMAT
186        ):
187            return None
188
189        return super()._parse_function(
190            functions=functions,
191            anonymous=anonymous,
192            optional_parens=optional_parens,
193            any_token=any_token,
194        )
195
196    def _parse_column_ops(self, this: exp.Expr | None) -> exp.Expr | None:
197        this = super()._parse_column_ops(this)
198
199        if self._match_pair(TokenType.L_PAREN, TokenType.FORMAT):
200            # `(FORMAT <format_string>)` after a column specifies a Teradata format override.
201            # See https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
202            fmt_string = self._parse_string()
203            self._match_r_paren()
204
205            this = self.expression(exp.FormatPhrase(this=this, format=fmt_string))
206
207        return this