Edit on GitHub

sqlglot.dialects.teradata

View Source

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, generator, parser, tokens, transforms
  6from sqlglot.dialects.dialect import (
  7    Dialect,
  8    max_or_greatest,
  9    min_or_least,
 10    rename_func,
 11    strposition_sql,
 12    to_number_with_nls_param,
 13)
 14from sqlglot.helper import seq_get
 15from sqlglot.tokens import TokenType
 16
 17
 18def _date_add_sql(
 19    kind: t.Literal["+", "-"],
 20) -> t.Callable[[Teradata.Generator, exp.DateAdd | exp.DateSub], str]:
 21    def func(self: Teradata.Generator, expression: exp.DateAdd | exp.DateSub) -> str:
 22        this = self.sql(expression, "this")
 23        unit = expression.args.get("unit")
 24        value = self._simplify_unless_literal(expression.expression)
 25
 26        if not isinstance(value, exp.Literal):
 27            self.unsupported("Cannot add non literal")
 28
 29        if isinstance(value, exp.Neg):
 30            kind_to_op = {"+": "-", "-": "+"}
 31            value = exp.Literal.string(value.this.to_py())
 32        else:
 33            kind_to_op = {"+": "+", "-": "-"}
 34            value.set("is_string", True)
 35
 36        return f"{this} {kind_to_op[kind]} {self.sql(exp.Interval(this=value, unit=unit))}"
 37
 38    return func
 39
 40
 41class Teradata(Dialect):
 42    SUPPORTS_SEMI_ANTI_JOIN = False
 43    TYPED_DIVISION = True
 44
 45    TIME_MAPPING = {
 46        "YY": "%y",
 47        "Y4": "%Y",
 48        "YYYY": "%Y",
 49        "M4": "%B",
 50        "M3": "%b",
 51        "M": "%-M",
 52        "MI": "%M",
 53        "MM": "%m",
 54        "MMM": "%b",
 55        "MMMM": "%B",
 56        "D": "%-d",
 57        "DD": "%d",
 58        "D3": "%j",
 59        "DDD": "%j",
 60        "H": "%-H",
 61        "HH": "%H",
 62        "HH24": "%H",
 63        "S": "%-S",
 64        "SS": "%S",
 65        "SSSSSS": "%f",
 66        "E": "%a",
 67        "EE": "%a",
 68        "E3": "%a",
 69        "E4": "%A",
 70        "EEE": "%a",
 71        "EEEE": "%A",
 72    }
 73
 74    class Tokenizer(tokens.Tokenizer):
 75        # Tested each of these and they work, although there is no
 76        # Teradata documentation explicitly mentioning them.
 77        HEX_STRINGS = [("X'", "'"), ("x'", "'"), ("0x", "")]
 78        # https://docs.teradata.com/r/Teradata-Database-SQL-Functions-Operators-Expressions-and-Predicates/March-2017/Comparison-Operators-and-Functions/Comparison-Operators/ANSI-Compliance
 79        # https://docs.teradata.com/r/SQL-Functions-Operators-Expressions-and-Predicates/June-2017/Arithmetic-Trigonometric-Hyperbolic-Operators/Functions
 80        KEYWORDS = {
 81            **tokens.Tokenizer.KEYWORDS,
 82            "**": TokenType.DSTAR,
 83            "^=": TokenType.NEQ,
 84            "BYTEINT": TokenType.SMALLINT,
 85            "COLLECT": TokenType.COMMAND,
 86            "DEL": TokenType.DELETE,
 87            "EQ": TokenType.EQ,
 88            "GE": TokenType.GTE,
 89            "GT": TokenType.GT,
 90            "HELP": TokenType.COMMAND,
 91            "INS": TokenType.INSERT,
 92            "LE": TokenType.LTE,
 93            "LOCKING": TokenType.LOCK,
 94            "LT": TokenType.LT,
 95            "MINUS": TokenType.EXCEPT,
 96            "MOD": TokenType.MOD,
 97            "NE": TokenType.NEQ,
 98            "NOT=": TokenType.NEQ,
 99            "SAMPLE": TokenType.TABLE_SAMPLE,
100            "SEL": TokenType.SELECT,
101            "ST_GEOMETRY": TokenType.GEOMETRY,
102            "TOP": TokenType.TOP,
103            "UPD": TokenType.UPDATE,
104        }
105        KEYWORDS.pop("/*+")
106
107        # Teradata does not support % as a modulo operator
108        SINGLE_TOKENS = {**tokens.Tokenizer.SINGLE_TOKENS}
109        SINGLE_TOKENS.pop("%")
110
111    class Parser(parser.Parser):
112        TABLESAMPLE_CSV = True
113        VALUES_FOLLOWED_BY_PAREN = False
114
115        CHARSET_TRANSLATORS = {
116            "GRAPHIC_TO_KANJISJIS",
117            "GRAPHIC_TO_LATIN",
118            "GRAPHIC_TO_UNICODE",
119            "GRAPHIC_TO_UNICODE_PadSpace",
120            "KANJI1_KanjiEBCDIC_TO_UNICODE",
121            "KANJI1_KanjiEUC_TO_UNICODE",
122            "KANJI1_KANJISJIS_TO_UNICODE",
123            "KANJI1_SBC_TO_UNICODE",
124            "KANJISJIS_TO_GRAPHIC",
125            "KANJISJIS_TO_LATIN",
126            "KANJISJIS_TO_UNICODE",
127            "LATIN_TO_GRAPHIC",
128            "LATIN_TO_KANJISJIS",
129            "LATIN_TO_UNICODE",
130            "LOCALE_TO_UNICODE",
131            "UNICODE_TO_GRAPHIC",
132            "UNICODE_TO_GRAPHIC_PadGraphic",
133            "UNICODE_TO_GRAPHIC_VarGraphic",
134            "UNICODE_TO_KANJI1_KanjiEBCDIC",
135            "UNICODE_TO_KANJI1_KanjiEUC",
136            "UNICODE_TO_KANJI1_KANJISJIS",
137            "UNICODE_TO_KANJI1_SBC",
138            "UNICODE_TO_KANJISJIS",
139            "UNICODE_TO_LATIN",
140            "UNICODE_TO_LOCALE",
141            "UNICODE_TO_UNICODE_FoldSpace",
142            "UNICODE_TO_UNICODE_Fullwidth",
143            "UNICODE_TO_UNICODE_Halfwidth",
144            "UNICODE_TO_UNICODE_NFC",
145            "UNICODE_TO_UNICODE_NFD",
146            "UNICODE_TO_UNICODE_NFKC",
147            "UNICODE_TO_UNICODE_NFKD",
148        }
149
150        FUNC_TOKENS = {*parser.Parser.FUNC_TOKENS}
151        FUNC_TOKENS.remove(TokenType.REPLACE)
152
153        STATEMENT_PARSERS = {
154            **parser.Parser.STATEMENT_PARSERS,
155            TokenType.DATABASE: lambda self: self.expression(
156                exp.Use, this=self._parse_table(schema=False)
157            ),
158            TokenType.REPLACE: lambda self: self._parse_create(),
159            TokenType.LOCK: lambda self: self._parse_locking_statement(),
160        }
161
162        def _parse_locking_statement(self) -> exp.LockingStatement:
163            # Reuse exp.LockingProperty parsing for the lock kind, type etc
164            locking_property = self._parse_locking()
165            wrapped_query = self._parse_select()
166
167            if not wrapped_query:
168                self.raise_error("Expected SELECT statement after LOCKING clause")
169
170            return self.expression(
171                exp.LockingStatement,
172                this=locking_property,
173                expression=wrapped_query,
174            )
175
176        SET_PARSERS = {
177            **parser.Parser.SET_PARSERS,
178            "QUERY_BAND": lambda self: self._parse_query_band(),
179        }
180
181        FUNCTION_PARSERS = {
182            **parser.Parser.FUNCTION_PARSERS,
183            # https://docs.teradata.com/r/SQL-Functions-Operators-Expressions-and-Predicates/June-2017/Data-Type-Conversions/TRYCAST
184            "TRYCAST": parser.Parser.FUNCTION_PARSERS["TRY_CAST"],
185            "RANGE_N": lambda self: self._parse_rangen(),
186            "TRANSLATE": lambda self: self._parse_translate(),
187        }
188
189        FUNCTIONS = {
190            **parser.Parser.FUNCTIONS,
191            "CARDINALITY": exp.ArraySize.from_arg_list,
192            "RANDOM": lambda args: exp.Rand(lower=seq_get(args, 0), upper=seq_get(args, 1)),
193        }
194
195        EXPONENT = {
196            TokenType.DSTAR: exp.Pow,
197        }
198
199        def _parse_translate(self) -> exp.TranslateCharacters:
200            this = self._parse_assignment()
201            self._match(TokenType.USING)
202            self._match_texts(self.CHARSET_TRANSLATORS)
203
204            return self.expression(
205                exp.TranslateCharacters,
206                this=this,
207                expression=self._prev.text.upper(),
208                with_error=self._match_text_seq("WITH", "ERROR"),
209            )
210
211        # FROM before SET in Teradata UPDATE syntax
212        # 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
213        def _parse_update(self) -> exp.Update:
214            return self.expression(
215                exp.Update,
216                this=self._parse_table(alias_tokens=self.UPDATE_ALIAS_TOKENS),
217                from_=self._parse_from(joins=True),
218                expressions=self._match(TokenType.SET) and self._parse_csv(self._parse_equality),
219                where=self._parse_where(),
220            )
221
222        def _parse_rangen(self):
223            this = self._parse_id_var()
224            self._match(TokenType.BETWEEN)
225
226            expressions = self._parse_csv(self._parse_assignment)
227            each = self._match_text_seq("EACH") and self._parse_assignment()
228
229            return self.expression(exp.RangeN, this=this, expressions=expressions, each=each)
230
231        def _parse_query_band(self) -> exp.QueryBand:
232            # Parse: SET QUERY_BAND = 'key=value;key2=value2;' FOR SESSION|TRANSACTION
233            # Also supports: SET QUERY_BAND = 'key=value;' UPDATE FOR SESSION|TRANSACTION
234            # Also supports: SET QUERY_BAND = NONE FOR SESSION|TRANSACTION
235            self._match(TokenType.EQ)
236
237            # Handle both string literals and NONE keyword
238            if self._match_text_seq("NONE"):
239                query_band_string: t.Optional[exp.Expression] = exp.Var(this="NONE")
240            else:
241                query_band_string = self._parse_string()
242
243            update = self._match_text_seq("UPDATE")
244            self._match_text_seq("FOR")
245
246            # Handle scope - can be SESSION, TRANSACTION, VOLATILE, or SESSION VOLATILE
247            if self._match_text_seq("SESSION", "VOLATILE"):
248                scope = "SESSION VOLATILE"
249            elif self._match_texts(("SESSION", "TRANSACTION")):
250                scope = self._prev.text.upper()
251            else:
252                scope = None
253
254            return self.expression(
255                exp.QueryBand,
256                this=query_band_string,
257                scope=scope,
258                update=update,
259            )
260
261        def _parse_index_params(self) -> exp.IndexParameters:
262            this = super()._parse_index_params()
263
264            if this.args.get("on"):
265                this.set("on", None)
266                self._retreat(self._index - 2)
267            return this
268
269        def _parse_function(
270            self,
271            functions: t.Optional[t.Dict[str, t.Callable]] = None,
272            anonymous: bool = False,
273            optional_parens: bool = True,
274            any_token: bool = False,
275        ) -> t.Optional[exp.Expression]:
276            # Teradata uses a `(FORMAT <format_string>)` clause after column references to
277            # override the output format. When we see this pattern we do not
278            # parse it as a function call.  The syntax is documented at
279            # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
280            if (
281                self._next
282                and self._next.token_type == TokenType.L_PAREN
283                and self._index + 2 < len(self._tokens)
284                and self._tokens[self._index + 2].token_type == TokenType.FORMAT
285            ):
286                return None
287
288            return super()._parse_function(
289                functions=functions,
290                anonymous=anonymous,
291                optional_parens=optional_parens,
292                any_token=any_token,
293            )
294
295        def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
296            this = super()._parse_column_ops(this)
297
298            if self._match_pair(TokenType.L_PAREN, TokenType.FORMAT):
299                # `(FORMAT <format_string>)` after a column specifies a Teradata format override.
300                # See https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
301                fmt_string = self._parse_string()
302                self._match_r_paren()
303
304                this = self.expression(exp.FormatPhrase, this=this, format=fmt_string)
305
306            return this
307
308    class Generator(generator.Generator):
309        LIMIT_IS_TOP = True
310        JOIN_HINTS = False
311        TABLE_HINTS = False
312        QUERY_HINTS = False
313        TABLESAMPLE_KEYWORDS = "SAMPLE"
314        LAST_DAY_SUPPORTS_DATE_PART = False
315        CAN_IMPLEMENT_ARRAY_ANY = True
316        TZ_TO_WITH_TIME_ZONE = True
317        ARRAY_SIZE_NAME = "CARDINALITY"
318
319        TYPE_MAPPING = {
320            **generator.Generator.TYPE_MAPPING,
321            exp.DataType.Type.GEOMETRY: "ST_GEOMETRY",
322            exp.DataType.Type.DOUBLE: "DOUBLE PRECISION",
323            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
324        }
325
326        PROPERTIES_LOCATION = {
327            **generator.Generator.PROPERTIES_LOCATION,
328            exp.OnCommitProperty: exp.Properties.Location.POST_INDEX,
329            exp.PartitionedByProperty: exp.Properties.Location.POST_EXPRESSION,
330            exp.StabilityProperty: exp.Properties.Location.POST_CREATE,
331        }
332
333        TRANSFORMS = {
334            **generator.Generator.TRANSFORMS,
335            exp.ArgMax: rename_func("MAX_BY"),
336            exp.ArgMin: rename_func("MIN_BY"),
337            exp.Max: max_or_greatest,
338            exp.Min: min_or_least,
339            exp.Pow: lambda self, e: self.binary(e, "**"),
340            exp.Rand: lambda self, e: self.func("RANDOM", e.args.get("lower"), e.args.get("upper")),
341            exp.Select: transforms.preprocess(
342                [transforms.eliminate_distinct_on, transforms.eliminate_semi_and_anti_joins]
343            ),
344            exp.StrPosition: lambda self, e: (
345                strposition_sql(
346                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
347                )
348            ),
349            exp.StrToDate: lambda self,
350            e: f"CAST({self.sql(e, 'this')} AS DATE FORMAT {self.format_time(e)})",
351            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
352            exp.ToNumber: to_number_with_nls_param,
353            exp.Use: lambda self, e: f"DATABASE {self.sql(e, 'this')}",
354            exp.DateAdd: _date_add_sql("+"),
355            exp.DateSub: _date_add_sql("-"),
356            exp.Quarter: lambda self, e: self.sql(exp.Extract(this="QUARTER", expression=e.this)),
357        }
358
359        def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
360            prefix, suffix = ("(", ")") if expression.this else ("", "")
361            return self.func("CURRENT_TIMESTAMP", expression.this, prefix=prefix, suffix=suffix)
362
363        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
364            if expression.to.this == exp.DataType.Type.UNKNOWN and expression.args.get("format"):
365                # We don't actually want to print the unknown type in CAST(<value> AS FORMAT <format>)
366                expression.to.pop()
367
368            return super().cast_sql(expression, safe_prefix=safe_prefix)
369
370        def trycast_sql(self, expression: exp.TryCast) -> str:
371            return self.cast_sql(expression, safe_prefix="TRY")
372
373        def tablesample_sql(
374            self,
375            expression: exp.TableSample,
376            tablesample_keyword: t.Optional[str] = None,
377        ) -> str:
378            return f"{self.sql(expression, 'this')} SAMPLE {self.expressions(expression)}"
379
380        def partitionedbyproperty_sql(self, expression: exp.PartitionedByProperty) -> str:
381            return f"PARTITION BY {self.sql(expression, 'this')}"
382
383        # FROM before SET in Teradata UPDATE syntax
384        # 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
385        def update_sql(self, expression: exp.Update) -> str:
386            this = self.sql(expression, "this")
387            from_sql = self.sql(expression, "from_")
388            set_sql = self.expressions(expression, flat=True)
389            where_sql = self.sql(expression, "where")
390            sql = f"UPDATE {this}{from_sql} SET {set_sql}{where_sql}"
391            return self.prepend_ctes(expression, sql)
392
393        def mod_sql(self, expression: exp.Mod) -> str:
394            return self.binary(expression, "MOD")
395
396        def rangen_sql(self, expression: exp.RangeN) -> str:
397            this = self.sql(expression, "this")
398            expressions_sql = self.expressions(expression)
399            each_sql = self.sql(expression, "each")
400            each_sql = f" EACH {each_sql}" if each_sql else ""
401
402            return f"RANGE_N({this} BETWEEN {expressions_sql}{each_sql})"
403
404        def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
405            """Generate SQL for LOCKING statement"""
406            locking_clause = self.sql(expression, "this")
407            query_sql = self.sql(expression, "expression")
408
409            return f"{locking_clause} {query_sql}"
410
411        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
412            kind = self.sql(expression, "kind").upper()
413            if kind == "TABLE" and locations.get(exp.Properties.Location.POST_NAME):
414                this_name = self.sql(expression.this, "this")
415                this_properties = self.properties(
416                    exp.Properties(expressions=locations[exp.Properties.Location.POST_NAME]),
417                    wrapped=False,
418                    prefix=",",
419                )
420                this_schema = self.schema_columns_sql(expression.this)
421                return f"{this_name}{this_properties}{self.sep()}{this_schema}"
422
423            return super().createable_sql(expression, locations)
424
425        def extract_sql(self, expression: exp.Extract) -> str:
426            this = self.sql(expression, "this")
427            if this.upper() != "QUARTER":
428                return super().extract_sql(expression)
429
430            to_char = exp.func("to_char", expression.expression, exp.Literal.string("Q"))
431            return self.sql(exp.cast(to_char, exp.DataType.Type.INT))
432
433        def interval_sql(self, expression: exp.Interval) -> str:
434            multiplier = 0
435            unit = expression.text("unit")
436
437            if unit.startswith("WEEK"):
438                multiplier = 7
439            elif unit.startswith("QUARTER"):
440                multiplier = 90
441
442            if multiplier:
443                return f"({multiplier} * {super().interval_sql(exp.Interval(this=expression.this, unit=exp.var('DAY')))})"
444
445            return super().interval_sql(expression)

class Teradata(sqlglot.dialects.dialect.Dialect): View Source

 42class Teradata(Dialect):
 43    SUPPORTS_SEMI_ANTI_JOIN = False
 44    TYPED_DIVISION = True
 45
 46    TIME_MAPPING = {
 47        "YY": "%y",
 48        "Y4": "%Y",
 49        "YYYY": "%Y",
 50        "M4": "%B",
 51        "M3": "%b",
 52        "M": "%-M",
 53        "MI": "%M",
 54        "MM": "%m",
 55        "MMM": "%b",
 56        "MMMM": "%B",
 57        "D": "%-d",
 58        "DD": "%d",
 59        "D3": "%j",
 60        "DDD": "%j",
 61        "H": "%-H",
 62        "HH": "%H",
 63        "HH24": "%H",
 64        "S": "%-S",
 65        "SS": "%S",
 66        "SSSSSS": "%f",
 67        "E": "%a",
 68        "EE": "%a",
 69        "E3": "%a",
 70        "E4": "%A",
 71        "EEE": "%a",
 72        "EEEE": "%A",
 73    }
 74
 75    class Tokenizer(tokens.Tokenizer):
 76        # Tested each of these and they work, although there is no
 77        # Teradata documentation explicitly mentioning them.
 78        HEX_STRINGS = [("X'", "'"), ("x'", "'"), ("0x", "")]
 79        # https://docs.teradata.com/r/Teradata-Database-SQL-Functions-Operators-Expressions-and-Predicates/March-2017/Comparison-Operators-and-Functions/Comparison-Operators/ANSI-Compliance
 80        # https://docs.teradata.com/r/SQL-Functions-Operators-Expressions-and-Predicates/June-2017/Arithmetic-Trigonometric-Hyperbolic-Operators/Functions
 81        KEYWORDS = {
 82            **tokens.Tokenizer.KEYWORDS,
 83            "**": TokenType.DSTAR,
 84            "^=": TokenType.NEQ,
 85            "BYTEINT": TokenType.SMALLINT,
 86            "COLLECT": TokenType.COMMAND,
 87            "DEL": TokenType.DELETE,
 88            "EQ": TokenType.EQ,
 89            "GE": TokenType.GTE,
 90            "GT": TokenType.GT,
 91            "HELP": TokenType.COMMAND,
 92            "INS": TokenType.INSERT,
 93            "LE": TokenType.LTE,
 94            "LOCKING": TokenType.LOCK,
 95            "LT": TokenType.LT,
 96            "MINUS": TokenType.EXCEPT,
 97            "MOD": TokenType.MOD,
 98            "NE": TokenType.NEQ,
 99            "NOT=": TokenType.NEQ,
100            "SAMPLE": TokenType.TABLE_SAMPLE,
101            "SEL": TokenType.SELECT,
102            "ST_GEOMETRY": TokenType.GEOMETRY,
103            "TOP": TokenType.TOP,
104            "UPD": TokenType.UPDATE,
105        }
106        KEYWORDS.pop("/*+")
107
108        # Teradata does not support % as a modulo operator
109        SINGLE_TOKENS = {**tokens.Tokenizer.SINGLE_TOKENS}
110        SINGLE_TOKENS.pop("%")
111
112    class Parser(parser.Parser):
113        TABLESAMPLE_CSV = True
114        VALUES_FOLLOWED_BY_PAREN = False
115
116        CHARSET_TRANSLATORS = {
117            "GRAPHIC_TO_KANJISJIS",
118            "GRAPHIC_TO_LATIN",
119            "GRAPHIC_TO_UNICODE",
120            "GRAPHIC_TO_UNICODE_PadSpace",
121            "KANJI1_KanjiEBCDIC_TO_UNICODE",
122            "KANJI1_KanjiEUC_TO_UNICODE",
123            "KANJI1_KANJISJIS_TO_UNICODE",
124            "KANJI1_SBC_TO_UNICODE",
125            "KANJISJIS_TO_GRAPHIC",
126            "KANJISJIS_TO_LATIN",
127            "KANJISJIS_TO_UNICODE",
128            "LATIN_TO_GRAPHIC",
129            "LATIN_TO_KANJISJIS",
130            "LATIN_TO_UNICODE",
131            "LOCALE_TO_UNICODE",
132            "UNICODE_TO_GRAPHIC",
133            "UNICODE_TO_GRAPHIC_PadGraphic",
134            "UNICODE_TO_GRAPHIC_VarGraphic",
135            "UNICODE_TO_KANJI1_KanjiEBCDIC",
136            "UNICODE_TO_KANJI1_KanjiEUC",
137            "UNICODE_TO_KANJI1_KANJISJIS",
138            "UNICODE_TO_KANJI1_SBC",
139            "UNICODE_TO_KANJISJIS",
140            "UNICODE_TO_LATIN",
141            "UNICODE_TO_LOCALE",
142            "UNICODE_TO_UNICODE_FoldSpace",
143            "UNICODE_TO_UNICODE_Fullwidth",
144            "UNICODE_TO_UNICODE_Halfwidth",
145            "UNICODE_TO_UNICODE_NFC",
146            "UNICODE_TO_UNICODE_NFD",
147            "UNICODE_TO_UNICODE_NFKC",
148            "UNICODE_TO_UNICODE_NFKD",
149        }
150
151        FUNC_TOKENS = {*parser.Parser.FUNC_TOKENS}
152        FUNC_TOKENS.remove(TokenType.REPLACE)
153
154        STATEMENT_PARSERS = {
155            **parser.Parser.STATEMENT_PARSERS,
156            TokenType.DATABASE: lambda self: self.expression(
157                exp.Use, this=self._parse_table(schema=False)
158            ),
159            TokenType.REPLACE: lambda self: self._parse_create(),
160            TokenType.LOCK: lambda self: self._parse_locking_statement(),
161        }
162
163        def _parse_locking_statement(self) -> exp.LockingStatement:
164            # Reuse exp.LockingProperty parsing for the lock kind, type etc
165            locking_property = self._parse_locking()
166            wrapped_query = self._parse_select()
167
168            if not wrapped_query:
169                self.raise_error("Expected SELECT statement after LOCKING clause")
170
171            return self.expression(
172                exp.LockingStatement,
173                this=locking_property,
174                expression=wrapped_query,
175            )
176
177        SET_PARSERS = {
178            **parser.Parser.SET_PARSERS,
179            "QUERY_BAND": lambda self: self._parse_query_band(),
180        }
181
182        FUNCTION_PARSERS = {
183            **parser.Parser.FUNCTION_PARSERS,
184            # https://docs.teradata.com/r/SQL-Functions-Operators-Expressions-and-Predicates/June-2017/Data-Type-Conversions/TRYCAST
185            "TRYCAST": parser.Parser.FUNCTION_PARSERS["TRY_CAST"],
186            "RANGE_N": lambda self: self._parse_rangen(),
187            "TRANSLATE": lambda self: self._parse_translate(),
188        }
189
190        FUNCTIONS = {
191            **parser.Parser.FUNCTIONS,
192            "CARDINALITY": exp.ArraySize.from_arg_list,
193            "RANDOM": lambda args: exp.Rand(lower=seq_get(args, 0), upper=seq_get(args, 1)),
194        }
195
196        EXPONENT = {
197            TokenType.DSTAR: exp.Pow,
198        }
199
200        def _parse_translate(self) -> exp.TranslateCharacters:
201            this = self._parse_assignment()
202            self._match(TokenType.USING)
203            self._match_texts(self.CHARSET_TRANSLATORS)
204
205            return self.expression(
206                exp.TranslateCharacters,
207                this=this,
208                expression=self._prev.text.upper(),
209                with_error=self._match_text_seq("WITH", "ERROR"),
210            )
211
212        # FROM before SET in Teradata UPDATE syntax
213        # 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
214        def _parse_update(self) -> exp.Update:
215            return self.expression(
216                exp.Update,
217                this=self._parse_table(alias_tokens=self.UPDATE_ALIAS_TOKENS),
218                from_=self._parse_from(joins=True),
219                expressions=self._match(TokenType.SET) and self._parse_csv(self._parse_equality),
220                where=self._parse_where(),
221            )
222
223        def _parse_rangen(self):
224            this = self._parse_id_var()
225            self._match(TokenType.BETWEEN)
226
227            expressions = self._parse_csv(self._parse_assignment)
228            each = self._match_text_seq("EACH") and self._parse_assignment()
229
230            return self.expression(exp.RangeN, this=this, expressions=expressions, each=each)
231
232        def _parse_query_band(self) -> exp.QueryBand:
233            # Parse: SET QUERY_BAND = 'key=value;key2=value2;' FOR SESSION|TRANSACTION
234            # Also supports: SET QUERY_BAND = 'key=value;' UPDATE FOR SESSION|TRANSACTION
235            # Also supports: SET QUERY_BAND = NONE FOR SESSION|TRANSACTION
236            self._match(TokenType.EQ)
237
238            # Handle both string literals and NONE keyword
239            if self._match_text_seq("NONE"):
240                query_band_string: t.Optional[exp.Expression] = exp.Var(this="NONE")
241            else:
242                query_band_string = self._parse_string()
243
244            update = self._match_text_seq("UPDATE")
245            self._match_text_seq("FOR")
246
247            # Handle scope - can be SESSION, TRANSACTION, VOLATILE, or SESSION VOLATILE
248            if self._match_text_seq("SESSION", "VOLATILE"):
249                scope = "SESSION VOLATILE"
250            elif self._match_texts(("SESSION", "TRANSACTION")):
251                scope = self._prev.text.upper()
252            else:
253                scope = None
254
255            return self.expression(
256                exp.QueryBand,
257                this=query_band_string,
258                scope=scope,
259                update=update,
260            )
261
262        def _parse_index_params(self) -> exp.IndexParameters:
263            this = super()._parse_index_params()
264
265            if this.args.get("on"):
266                this.set("on", None)
267                self._retreat(self._index - 2)
268            return this
269
270        def _parse_function(
271            self,
272            functions: t.Optional[t.Dict[str, t.Callable]] = None,
273            anonymous: bool = False,
274            optional_parens: bool = True,
275            any_token: bool = False,
276        ) -> t.Optional[exp.Expression]:
277            # Teradata uses a `(FORMAT <format_string>)` clause after column references to
278            # override the output format. When we see this pattern we do not
279            # parse it as a function call.  The syntax is documented at
280            # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
281            if (
282                self._next
283                and self._next.token_type == TokenType.L_PAREN
284                and self._index + 2 < len(self._tokens)
285                and self._tokens[self._index + 2].token_type == TokenType.FORMAT
286            ):
287                return None
288
289            return super()._parse_function(
290                functions=functions,
291                anonymous=anonymous,
292                optional_parens=optional_parens,
293                any_token=any_token,
294            )
295
296        def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
297            this = super()._parse_column_ops(this)
298
299            if self._match_pair(TokenType.L_PAREN, TokenType.FORMAT):
300                # `(FORMAT <format_string>)` after a column specifies a Teradata format override.
301                # See https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
302                fmt_string = self._parse_string()
303                self._match_r_paren()
304
305                this = self.expression(exp.FormatPhrase, this=this, format=fmt_string)
306
307            return this
308
309    class Generator(generator.Generator):
310        LIMIT_IS_TOP = True
311        JOIN_HINTS = False
312        TABLE_HINTS = False
313        QUERY_HINTS = False
314        TABLESAMPLE_KEYWORDS = "SAMPLE"
315        LAST_DAY_SUPPORTS_DATE_PART = False
316        CAN_IMPLEMENT_ARRAY_ANY = True
317        TZ_TO_WITH_TIME_ZONE = True
318        ARRAY_SIZE_NAME = "CARDINALITY"
319
320        TYPE_MAPPING = {
321            **generator.Generator.TYPE_MAPPING,
322            exp.DataType.Type.GEOMETRY: "ST_GEOMETRY",
323            exp.DataType.Type.DOUBLE: "DOUBLE PRECISION",
324            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
325        }
326
327        PROPERTIES_LOCATION = {
328            **generator.Generator.PROPERTIES_LOCATION,
329            exp.OnCommitProperty: exp.Properties.Location.POST_INDEX,
330            exp.PartitionedByProperty: exp.Properties.Location.POST_EXPRESSION,
331            exp.StabilityProperty: exp.Properties.Location.POST_CREATE,
332        }
333
334        TRANSFORMS = {
335            **generator.Generator.TRANSFORMS,
336            exp.ArgMax: rename_func("MAX_BY"),
337            exp.ArgMin: rename_func("MIN_BY"),
338            exp.Max: max_or_greatest,
339            exp.Min: min_or_least,
340            exp.Pow: lambda self, e: self.binary(e, "**"),
341            exp.Rand: lambda self, e: self.func("RANDOM", e.args.get("lower"), e.args.get("upper")),
342            exp.Select: transforms.preprocess(
343                [transforms.eliminate_distinct_on, transforms.eliminate_semi_and_anti_joins]
344            ),
345            exp.StrPosition: lambda self, e: (
346                strposition_sql(
347                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
348                )
349            ),
350            exp.StrToDate: lambda self,
351            e: f"CAST({self.sql(e, 'this')} AS DATE FORMAT {self.format_time(e)})",
352            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
353            exp.ToNumber: to_number_with_nls_param,
354            exp.Use: lambda self, e: f"DATABASE {self.sql(e, 'this')}",
355            exp.DateAdd: _date_add_sql("+"),
356            exp.DateSub: _date_add_sql("-"),
357            exp.Quarter: lambda self, e: self.sql(exp.Extract(this="QUARTER", expression=e.this)),
358        }
359
360        def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
361            prefix, suffix = ("(", ")") if expression.this else ("", "")
362            return self.func("CURRENT_TIMESTAMP", expression.this, prefix=prefix, suffix=suffix)
363
364        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
365            if expression.to.this == exp.DataType.Type.UNKNOWN and expression.args.get("format"):
366                # We don't actually want to print the unknown type in CAST(<value> AS FORMAT <format>)
367                expression.to.pop()
368
369            return super().cast_sql(expression, safe_prefix=safe_prefix)
370
371        def trycast_sql(self, expression: exp.TryCast) -> str:
372            return self.cast_sql(expression, safe_prefix="TRY")
373
374        def tablesample_sql(
375            self,
376            expression: exp.TableSample,
377            tablesample_keyword: t.Optional[str] = None,
378        ) -> str:
379            return f"{self.sql(expression, 'this')} SAMPLE {self.expressions(expression)}"
380
381        def partitionedbyproperty_sql(self, expression: exp.PartitionedByProperty) -> str:
382            return f"PARTITION BY {self.sql(expression, 'this')}"
383
384        # FROM before SET in Teradata UPDATE syntax
385        # 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
386        def update_sql(self, expression: exp.Update) -> str:
387            this = self.sql(expression, "this")
388            from_sql = self.sql(expression, "from_")
389            set_sql = self.expressions(expression, flat=True)
390            where_sql = self.sql(expression, "where")
391            sql = f"UPDATE {this}{from_sql} SET {set_sql}{where_sql}"
392            return self.prepend_ctes(expression, sql)
393
394        def mod_sql(self, expression: exp.Mod) -> str:
395            return self.binary(expression, "MOD")
396
397        def rangen_sql(self, expression: exp.RangeN) -> str:
398            this = self.sql(expression, "this")
399            expressions_sql = self.expressions(expression)
400            each_sql = self.sql(expression, "each")
401            each_sql = f" EACH {each_sql}" if each_sql else ""
402
403            return f"RANGE_N({this} BETWEEN {expressions_sql}{each_sql})"
404
405        def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
406            """Generate SQL for LOCKING statement"""
407            locking_clause = self.sql(expression, "this")
408            query_sql = self.sql(expression, "expression")
409
410            return f"{locking_clause} {query_sql}"
411
412        def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
413            kind = self.sql(expression, "kind").upper()
414            if kind == "TABLE" and locations.get(exp.Properties.Location.POST_NAME):
415                this_name = self.sql(expression.this, "this")
416                this_properties = self.properties(
417                    exp.Properties(expressions=locations[exp.Properties.Location.POST_NAME]),
418                    wrapped=False,
419                    prefix=",",
420                )
421                this_schema = self.schema_columns_sql(expression.this)
422                return f"{this_name}{this_properties}{self.sep()}{this_schema}"
423
424            return super().createable_sql(expression, locations)
425
426        def extract_sql(self, expression: exp.Extract) -> str:
427            this = self.sql(expression, "this")
428            if this.upper() != "QUARTER":
429                return super().extract_sql(expression)
430
431            to_char = exp.func("to_char", expression.expression, exp.Literal.string("Q"))
432            return self.sql(exp.cast(to_char, exp.DataType.Type.INT))
433
434        def interval_sql(self, expression: exp.Interval) -> str:
435            multiplier = 0
436            unit = expression.text("unit")
437
438            if unit.startswith("WEEK"):
439                multiplier = 7
440            elif unit.startswith("QUARTER"):
441                multiplier = 90
442
443            if multiplier:
444                return f"({multiplier} * {super().interval_sql(exp.Interval(this=expression.this, unit=exp.var('DAY')))})"
445
446            return super().interval_sql(expression)

SUPPORTS_SEMI_ANTI_JOIN = False

Whether SEMI or ANTI joins are supported.

TYPED_DIVISION = True

Whether the behavior of a / b depends on the types of a and b. False means a / b is always float division. True means a / b is integer division if both a and b are integers.

TIME_MAPPING: Dict[str, str] = {'YY': '%y', 'Y4': '%Y', 'YYYY': '%Y', 'M4': '%B', 'M3': '%b', 'M': '%-M', 'MI': '%M', 'MM': '%m', 'MMM': '%b', 'MMMM': '%B', 'D': '%-d', 'DD': '%d', 'D3': '%j', 'DDD': '%j', 'H': '%-H', 'HH': '%H', 'HH24': '%H', 'S': '%-S', 'SS': '%S', 'SSSSSS': '%f', 'E': '%a', 'EE': '%a', 'E3': '%a', 'E4': '%A', 'EEE': '%a', 'EEEE': '%A'}

Associates this dialect's time formats with their equivalent Python strftime formats.

SUPPORTS_COLUMN_JOIN_MARKS = False

Whether the old-style outer join (+) syntax is supported.

INITCAP_SUPPORTS_CUSTOM_DELIMITERS = False

tokenizer_class = <class 'Teradata.Tokenizer'>

jsonpath_tokenizer_class = <class 'sqlglot.dialects.dialect.JSONPathTokenizer'>

parser_class = <class 'Teradata.Parser'>

generator_class = <class 'Teradata.Generator'>

TIME_TRIE: Dict = {'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}, '4': {0: True}}, 'M': {'4': {0: True}, '3': {0: True}, 0: True, 'I': {0: True}, 'M': {0: True, 'M': {0: True, 'M': {0: True}}}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}, '3': {0: True}}, 'H': {0: True, 'H': {0: True, '2': {'4': {0: True}}}}, 'S': {0: True, 'S': {0: True, 'S': {'S': {'S': {'S': {0: True}}}}}}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}, '3': {0: True}, '4': {0: True}}}

FORMAT_TRIE: Dict = {'Y': {'Y': {0: True, 'Y': {'Y': {0: True}}}, '4': {0: True}}, 'M': {'4': {0: True}, '3': {0: True}, 0: True, 'I': {0: True}, 'M': {0: True, 'M': {0: True, 'M': {0: True}}}}, 'D': {0: True, 'D': {0: True, 'D': {0: True}}, '3': {0: True}}, 'H': {0: True, 'H': {0: True, '2': {'4': {0: True}}}}, 'S': {0: True, 'S': {0: True, 'S': {'S': {'S': {'S': {0: True}}}}}}, 'E': {0: True, 'E': {0: True, 'E': {0: True, 'E': {0: True}}}, '3': {0: True}, '4': {0: True}}}

INVERSE_TIME_MAPPING: Dict[str, str] = {'%y': 'YY', '%Y': 'YYYY', '%B': 'MMMM', '%b': 'MMM', '%-M': 'M', '%M': 'MI', '%m': 'MM', '%-d': 'D', '%d': 'DD', '%j': 'DDD', '%-H': 'H', '%H': 'HH24', '%-S': 'S', '%S': 'SS', '%f': 'SSSSSS', '%a': 'EEE', '%A': 'EEEE'}

INVERSE_TIME_TRIE: Dict = {'%': {'y': {0: True}, 'Y': {0: True}, 'B': {0: True}, 'b': {0: True}, '-': {'M': {0: True}, 'd': {0: True}, 'H': {0: True}, 'S': {0: True}}, 'M': {0: True}, 'm': {0: True}, 'd': {0: True}, 'j': {0: True}, 'H': {0: True}, 'S': {0: True}, 'f': {0: True}, 'a': {0: True}, 'A': {0: True}}}

INVERSE_FORMAT_MAPPING: Dict[str, str] = {}

INVERSE_FORMAT_TRIE: Dict = {}

INVERSE_CREATABLE_KIND_MAPPING: dict[str, str] = {}

ESCAPED_SEQUENCES: Dict[str, str] = {}

QUOTE_START = "'"

QUOTE_END = "'"

IDENTIFIER_START = '"'

IDENTIFIER_END = '"'

VALID_INTERVAL_UNITS: Set[str] = {'WOY', 'DECADE', 'YR', 'QUARTERS', 'MON', 'DAYOFWEEK', 'TZH', 'MS', 'MILLENNIUM', 'NANOSECOND', 'MONTHS', 'EPOCH_MICROSECONDS', 'WEEKOFYEAR_ISO', 'C', 'SECONDS', 'WEEKOFYEAR', 'NS', 'EPOCH_MILLISECOND', 'Y', 'WK', 'WY', 'USECOND', 'EPOCH_MICROSECOND', 'MILLISEC', 'MONTH', 'YEAR', 'EPOCH_NANOSECONDS', 'MILS', 'DOY', 'NANOSEC', 'DOW_ISO', 'CENT', 'DAYS', 'MINS', 'SEC', 'MILLISECS', 'MI', 'Q', 'MICROSECS', 'DAYOFMONTH', 'WEEKOFYEARISO', 'DECADES', 'S', 'YRS', 'YYYY', 'WEEK', 'MINUTES', 'WEEKDAY', 'EPOCH', 'HOUR', 'YEARS', 'NSEC', 'MSECOND', 'USEC', 'DAYOFWEEK_ISO', 'CENTURIES', 'QTRS', 'MM', 'D', 'MILLISECONDS', 'DAYOFYEAR', 'WEEKISO', 'NANOSECS', 'CENTS', 'WEEKDAY_ISO', 'DAYOFWEEKISO', 'EPOCH_NANOSECOND', 'MICROSECONDS', 'DAY OF YEAR', 'EPOCH_MILLISECONDS', 'USECONDS', 'TIMEZONE_MINUTE', 'YY', 'HR', 'EPOCH_SECONDS', 'MILLENIA', 'W', 'MICROSECOND', 'DECS', 'MINUTE', 'CENTURY', 'MIN', 'YYY', 'MSECONDS', 'HH', 'DD', 'QTR', 'TIMEZONE_HOUR', 'DAY OF WEEK', 'DW', 'QUARTER', 'SECS', 'NSECONDS', 'DW_ISO', 'DAY', 'DY', 'SECOND', 'MILLISECON', 'MICROSEC', 'EPOCH_SECOND', 'HRS', 'HOURS', 'MIL', 'TZM', 'MSEC', 'H', 'DOW', 'MSECS', 'MILLISECOND', 'US', 'MONS', 'DEC', 'WEEK_ISO', 'NSECOND', 'USECS', 'M'}

BIT_START: Optional[str] = None

BIT_END: Optional[str] = None

HEX_START: Optional[str] = "X'"

HEX_END: Optional[str] = "'"

BYTE_START: Optional[str] = None

BYTE_END: Optional[str] = None

UNICODE_START: Optional[str] = None

UNICODE_END: Optional[str] = None

STRINGS_SUPPORT_ESCAPED_SEQUENCES = False

BYTE_STRINGS_SUPPORT_ESCAPED_SEQUENCES = False

class Teradata.Tokenizer(sqlglot.tokens.Tokenizer): View Source

 75    class Tokenizer(tokens.Tokenizer):
 76        # Tested each of these and they work, although there is no
 77        # Teradata documentation explicitly mentioning them.
 78        HEX_STRINGS = [("X'", "'"), ("x'", "'"), ("0x", "")]
 79        # https://docs.teradata.com/r/Teradata-Database-SQL-Functions-Operators-Expressions-and-Predicates/March-2017/Comparison-Operators-and-Functions/Comparison-Operators/ANSI-Compliance
 80        # https://docs.teradata.com/r/SQL-Functions-Operators-Expressions-and-Predicates/June-2017/Arithmetic-Trigonometric-Hyperbolic-Operators/Functions
 81        KEYWORDS = {
 82            **tokens.Tokenizer.KEYWORDS,
 83            "**": TokenType.DSTAR,
 84            "^=": TokenType.NEQ,
 85            "BYTEINT": TokenType.SMALLINT,
 86            "COLLECT": TokenType.COMMAND,
 87            "DEL": TokenType.DELETE,
 88            "EQ": TokenType.EQ,
 89            "GE": TokenType.GTE,
 90            "GT": TokenType.GT,
 91            "HELP": TokenType.COMMAND,
 92            "INS": TokenType.INSERT,
 93            "LE": TokenType.LTE,
 94            "LOCKING": TokenType.LOCK,
 95            "LT": TokenType.LT,
 96            "MINUS": TokenType.EXCEPT,
 97            "MOD": TokenType.MOD,
 98            "NE": TokenType.NEQ,
 99            "NOT=": TokenType.NEQ,
100            "SAMPLE": TokenType.TABLE_SAMPLE,
101            "SEL": TokenType.SELECT,
102            "ST_GEOMETRY": TokenType.GEOMETRY,
103            "TOP": TokenType.TOP,
104            "UPD": TokenType.UPDATE,
105        }
106        KEYWORDS.pop("/*+")
107
108        # Teradata does not support % as a modulo operator
109        SINGLE_TOKENS = {**tokens.Tokenizer.SINGLE_TOKENS}
110        SINGLE_TOKENS.pop("%")

HEX_STRINGS = [("X'", "'"), ("x'", "'"), ('0x', '')]

KEYWORDS = {'{%': <TokenType.BLOCK_START: 70>, '{%+': <TokenType.BLOCK_START: 70>, '{%-': <TokenType.BLOCK_START: 70>, '%}': <TokenType.BLOCK_END: 71>, '+%}': <TokenType.BLOCK_END: 71>, '-%}': <TokenType.BLOCK_END: 71>, '{{+': <TokenType.BLOCK_START: 70>, '{{-': <TokenType.BLOCK_START: 70>, '+}}': <TokenType.BLOCK_END: 71>, '-}}': <TokenType.BLOCK_END: 71>, '&<': <TokenType.AMP_LT: 60>, '&>': <TokenType.AMP_GT: 61>, '==': <TokenType.EQ: 27>, '::': <TokenType.DCOLON: 13>, '?::': <TokenType.QDCOLON: 360>, '||': <TokenType.DPIPE: 36>, '|>': <TokenType.PIPE_GT: 37>, '>=': <TokenType.GTE: 25>, '<=': <TokenType.LTE: 23>, '<>': <TokenType.NEQ: 28>, '!=': <TokenType.NEQ: 28>, ':=': <TokenType.COLON_EQ: 30>, '<=>': <TokenType.NULLSAFE_EQ: 29>, '->': <TokenType.ARROW: 44>, '->>': <TokenType.DARROW: 45>, '=>': <TokenType.FARROW: 46>, '#>': <TokenType.HASH_ARROW: 48>, '#>>': <TokenType.DHASH_ARROW: 49>, '<->': <TokenType.LR_ARROW: 50>, '&&': <TokenType.DAMP: 59>, '??': <TokenType.DQMARK: 17>, '~~~': <TokenType.GLOB: 282>, '~~': <TokenType.LIKE: 312>, '~~*': <TokenType.ILIKE: 290>, '~*': <TokenType.IRLIKE: 301>, '-|-': <TokenType.ADJACENT: 62>, 'ALL': <TokenType.ALL: 216>, 'AND': <TokenType.AND: 33>, 'ANTI': <TokenType.ANTI: 217>, 'ANY': <TokenType.ANY: 218>, 'ASC': <TokenType.ASC: 221>, 'AS': <TokenType.ALIAS: 214>, 'ASOF': <TokenType.ASOF: 222>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 224>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 224>, 'BEGIN': <TokenType.BEGIN: 225>, 'BETWEEN': <TokenType.BETWEEN: 226>, 'CACHE': <TokenType.CACHE: 228>, 'UNCACHE': <TokenType.UNCACHE: 400>, 'CASE': <TokenType.CASE: 229>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 230>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 231>, 'COLLATE': <TokenType.COLLATE: 232>, 'COLUMN': <TokenType.COLUMN: 78>, 'COMMIT': <TokenType.COMMIT: 235>, 'CONNECT BY': <TokenType.CONNECT_BY: 236>, 'CONSTRAINT': <TokenType.CONSTRAINT: 237>, 'COPY': <TokenType.COPY: 238>, 'CREATE': <TokenType.CREATE: 239>, 'CROSS': <TokenType.CROSS: 240>, 'CUBE': <TokenType.CUBE: 241>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 242>, 'CURRENT_SCHEMA': <TokenType.CURRENT_SCHEMA: 244>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 245>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 246>, 'CURRENT_USER': <TokenType.CURRENT_USER: 247>, 'CURRENT_CATALOG': <TokenType.CURRENT_CATALOG: 249>, 'DATABASE': <TokenType.DATABASE: 77>, 'DEFAULT': <TokenType.DEFAULT: 251>, 'DELETE': <TokenType.DELETE: 252>, 'DESC': <TokenType.DESC: 253>, 'DESCRIBE': <TokenType.DESCRIBE: 254>, 'DISTINCT': <TokenType.DISTINCT: 257>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 258>, 'DIV': <TokenType.DIV: 259>, 'DROP': <TokenType.DROP: 260>, 'ELSE': <TokenType.ELSE: 261>, 'END': <TokenType.END: 262>, 'ENUM': <TokenType.ENUM: 201>, 'ESCAPE': <TokenType.ESCAPE: 263>, 'EXCEPT': <TokenType.EXCEPT: 264>, 'EXECUTE': <TokenType.EXECUTE: 265>, 'EXISTS': <TokenType.EXISTS: 266>, 'FALSE': <TokenType.FALSE: 267>, 'FETCH': <TokenType.FETCH: 268>, 'FILTER': <TokenType.FILTER: 271>, 'FILE': <TokenType.FILE: 269>, 'FIRST': <TokenType.FIRST: 273>, 'FULL': <TokenType.FULL: 279>, 'FUNCTION': <TokenType.FUNCTION: 280>, 'FOR': <TokenType.FOR: 274>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 276>, 'FORMAT': <TokenType.FORMAT: 277>, 'FROM': <TokenType.FROM: 278>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 168>, 'GEOMETRY': <TokenType.GEOMETRY: 171>, 'GLOB': <TokenType.GLOB: 282>, 'GROUP BY': <TokenType.GROUP_BY: 285>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 286>, 'HAVING': <TokenType.HAVING: 287>, 'ILIKE': <TokenType.ILIKE: 290>, 'IN': <TokenType.IN: 291>, 'INDEX': <TokenType.INDEX: 292>, 'INET': <TokenType.INET: 196>, 'INNER': <TokenType.INNER: 294>, 'INSERT': <TokenType.INSERT: 295>, 'INTERVAL': <TokenType.INTERVAL: 298>, 'INTERSECT': <TokenType.INTERSECT: 297>, 'INTO': <TokenType.INTO: 299>, 'IS': <TokenType.IS: 302>, 'ISNULL': <TokenType.ISNULL: 303>, 'JOIN': <TokenType.JOIN: 304>, 'KEEP': <TokenType.KEEP: 306>, 'KILL': <TokenType.KILL: 308>, 'LATERAL': <TokenType.LATERAL: 310>, 'LEFT': <TokenType.LEFT: 311>, 'LIKE': <TokenType.LIKE: 312>, 'LIMIT': <TokenType.LIMIT: 313>, 'LOAD': <TokenType.LOAD: 315>, 'LOCALTIME': <TokenType.LOCALTIME: 175>, 'LOCALTIMESTAMP': <TokenType.LOCALTIMESTAMP: 176>, 'LOCK': <TokenType.LOCK: 316>, 'MERGE': <TokenType.MERGE: 322>, 'NAMESPACE': <TokenType.NAMESPACE: 426>, 'NATURAL': <TokenType.NATURAL: 325>, 'NEXT': <TokenType.NEXT: 326>, 'NOT': <TokenType.NOT: 26>, 'NOTNULL': <TokenType.NOTNULL: 328>, 'NULL': <TokenType.NULL: 329>, 'OBJECT': <TokenType.OBJECT: 195>, 'OFFSET': <TokenType.OFFSET: 331>, 'ON': <TokenType.ON: 332>, 'OR': <TokenType.OR: 34>, 'XOR': <TokenType.XOR: 63>, 'ORDER BY': <TokenType.ORDER_BY: 335>, 'ORDINALITY': <TokenType.ORDINALITY: 338>, 'OUT': <TokenType.OUT: 339>, 'OUTER': <TokenType.OUTER: 341>, 'OVER': <TokenType.OVER: 342>, 'OVERLAPS': <TokenType.OVERLAPS: 343>, 'OVERWRITE': <TokenType.OVERWRITE: 344>, 'PARTITION': <TokenType.PARTITION: 345>, 'PARTITION BY': <TokenType.PARTITION_BY: 346>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 346>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 346>, 'PERCENT': <TokenType.PERCENT: 347>, 'PIVOT': <TokenType.PIVOT: 348>, 'PRAGMA': <TokenType.PRAGMA: 351>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 353>, 'PROCEDURE': <TokenType.PROCEDURE: 354>, 'OPERATOR': <TokenType.OPERATOR: 334>, 'QUALIFY': <TokenType.QUALIFY: 358>, 'RANGE': <TokenType.RANGE: 361>, 'RECURSIVE': <TokenType.RECURSIVE: 362>, 'REGEXP': <TokenType.RLIKE: 370>, 'RENAME': <TokenType.RENAME: 364>, 'REPLACE': <TokenType.REPLACE: 365>, 'RETURNING': <TokenType.RETURNING: 366>, 'REFERENCES': <TokenType.REFERENCES: 368>, 'RIGHT': <TokenType.RIGHT: 369>, 'RLIKE': <TokenType.RLIKE: 370>, 'ROLLBACK': <TokenType.ROLLBACK: 371>, 'ROLLUP': <TokenType.ROLLUP: 372>, 'ROW': <TokenType.ROW: 373>, 'ROWS': <TokenType.ROWS: 374>, 'SCHEMA': <TokenType.SCHEMA: 80>, 'SELECT': <TokenType.SELECT: 375>, 'SEMI': <TokenType.SEMI: 376>, 'SESSION': <TokenType.SESSION: 56>, 'SESSION_USER': <TokenType.SESSION_USER: 58>, 'SET': <TokenType.SET: 380>, 'SETTINGS': <TokenType.SETTINGS: 381>, 'SHOW': <TokenType.SHOW: 382>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 383>, 'SOME': <TokenType.SOME: 384>, 'SORT BY': <TokenType.SORT_BY: 385>, 'START WITH': <TokenType.START_WITH: 387>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 389>, 'TABLE': <TokenType.TABLE: 81>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 392>, 'TEMP': <TokenType.TEMPORARY: 394>, 'TEMPORARY': <TokenType.TEMPORARY: 394>, 'THEN': <TokenType.THEN: 396>, 'TRUE': <TokenType.TRUE: 397>, 'TRUNCATE': <TokenType.TRUNCATE: 398>, 'TRIGGER': <TokenType.TRIGGER: 399>, 'UNION': <TokenType.UNION: 401>, 'UNKNOWN': <TokenType.UNKNOWN: 210>, 'UNNEST': <TokenType.UNNEST: 402>, 'UNPIVOT': <TokenType.UNPIVOT: 403>, 'UPDATE': <TokenType.UPDATE: 404>, 'USE': <TokenType.USE: 405>, 'USING': <TokenType.USING: 406>, 'UUID': <TokenType.UUID: 167>, 'VALUES': <TokenType.VALUES: 407>, 'VIEW': <TokenType.VIEW: 409>, 'VOLATILE': <TokenType.VOLATILE: 411>, 'WHEN': <TokenType.WHEN: 412>, 'WHERE': <TokenType.WHERE: 413>, 'WINDOW': <TokenType.WINDOW: 414>, 'WITH': <TokenType.WITH: 415>, 'APPLY': <TokenType.APPLY: 219>, 'ARRAY': <TokenType.ARRAY: 220>, 'BIT': <TokenType.BIT: 93>, 'BOOL': <TokenType.BOOLEAN: 94>, 'BOOLEAN': <TokenType.BOOLEAN: 94>, 'BYTE': <TokenType.TINYINT: 95>, 'MEDIUMINT': <TokenType.MEDIUMINT: 99>, 'INT1': <TokenType.TINYINT: 95>, 'TINYINT': <TokenType.TINYINT: 95>, 'INT16': <TokenType.SMALLINT: 97>, 'SHORT': <TokenType.SMALLINT: 97>, 'SMALLINT': <TokenType.SMALLINT: 97>, 'HUGEINT': <TokenType.INT128: 106>, 'UHUGEINT': <TokenType.UINT128: 107>, 'INT2': <TokenType.SMALLINT: 97>, 'INTEGER': <TokenType.INT: 101>, 'INT': <TokenType.INT: 101>, 'INT4': <TokenType.INT: 101>, 'INT32': <TokenType.INT: 101>, 'INT64': <TokenType.BIGINT: 103>, 'INT128': <TokenType.INT128: 106>, 'INT256': <TokenType.INT256: 108>, 'LONG': <TokenType.BIGINT: 103>, 'BIGINT': <TokenType.BIGINT: 103>, 'INT8': <TokenType.TINYINT: 95>, 'UINT': <TokenType.UINT: 102>, 'UINT128': <TokenType.UINT128: 107>, 'UINT256': <TokenType.UINT256: 109>, 'DEC': <TokenType.DECIMAL: 113>, 'DECIMAL': <TokenType.DECIMAL: 113>, 'DECIMAL32': <TokenType.DECIMAL32: 114>, 'DECIMAL64': <TokenType.DECIMAL64: 115>, 'DECIMAL128': <TokenType.DECIMAL128: 116>, 'DECIMAL256': <TokenType.DECIMAL256: 117>, 'DECFLOAT': <TokenType.DECFLOAT: 118>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 120>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 120>, 'BIGNUM': <TokenType.BIGNUM: 105>, 'LIST': <TokenType.LIST: 314>, 'MAP': <TokenType.MAP: 317>, 'NULLABLE': <TokenType.NULLABLE: 170>, 'NUMBER': <TokenType.DECIMAL: 113>, 'NUMERIC': <TokenType.DECIMAL: 113>, 'FIXED': <TokenType.DECIMAL: 113>, 'REAL': <TokenType.FLOAT: 110>, 'FLOAT': <TokenType.FLOAT: 110>, 'FLOAT4': <TokenType.FLOAT: 110>, 'FLOAT8': <TokenType.DOUBLE: 111>, 'DOUBLE': <TokenType.DOUBLE: 111>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 111>, 'JSON': <TokenType.JSON: 137>, 'JSONB': <TokenType.JSONB: 138>, 'CHAR': <TokenType.CHAR: 121>, 'CHARACTER': <TokenType.CHAR: 121>, 'CHAR VARYING': <TokenType.VARCHAR: 123>, 'CHARACTER VARYING': <TokenType.VARCHAR: 123>, 'NCHAR': <TokenType.NCHAR: 122>, 'VARCHAR': <TokenType.VARCHAR: 123>, 'VARCHAR2': <TokenType.VARCHAR: 123>, 'NVARCHAR': <TokenType.NVARCHAR: 124>, 'NVARCHAR2': <TokenType.NVARCHAR: 124>, 'BPCHAR': <TokenType.BPCHAR: 125>, 'STR': <TokenType.TEXT: 126>, 'STRING': <TokenType.TEXT: 126>, 'TEXT': <TokenType.TEXT: 126>, 'LONGTEXT': <TokenType.LONGTEXT: 128>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 127>, 'TINYTEXT': <TokenType.TINYTEXT: 133>, 'CLOB': <TokenType.TEXT: 126>, 'LONGVARCHAR': <TokenType.TEXT: 126>, 'BINARY': <TokenType.BINARY: 135>, 'BLOB': <TokenType.VARBINARY: 136>, 'LONGBLOB': <TokenType.LONGBLOB: 131>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 130>, 'TINYBLOB': <TokenType.TINYBLOB: 132>, 'BYTEA': <TokenType.VARBINARY: 136>, 'VARBINARY': <TokenType.VARBINARY: 136>, 'TIME': <TokenType.TIME: 139>, 'TIMETZ': <TokenType.TIMETZ: 140>, 'TIME_NS': <TokenType.TIME_NS: 141>, 'TIMESTAMP': <TokenType.TIMESTAMP: 142>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 143>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 144>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 144>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 145>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 145>, 'DATE': <TokenType.DATE: 153>, 'DATETIME': <TokenType.DATETIME: 149>, 'INT4RANGE': <TokenType.INT4RANGE: 155>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 156>, 'INT8RANGE': <TokenType.INT8RANGE: 157>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 158>, 'NUMRANGE': <TokenType.NUMRANGE: 159>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 160>, 'TSRANGE': <TokenType.TSRANGE: 161>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 162>, 'TSTZRANGE': <TokenType.TSTZRANGE: 163>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 164>, 'DATERANGE': <TokenType.DATERANGE: 165>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 166>, 'UNIQUE': <TokenType.UNIQUE: 416>, 'VECTOR': <TokenType.VECTOR: 211>, 'STRUCT': <TokenType.STRUCT: 390>, 'SEQUENCE': <TokenType.SEQUENCE: 378>, 'VARIANT': <TokenType.VARIANT: 194>, 'ALTER': <TokenType.ALTER: 215>, 'ANALYZE': <TokenType.ANALYZE: 425>, 'CALL': <TokenType.COMMAND: 233>, 'COMMENT': <TokenType.COMMENT: 234>, 'EXPLAIN': <TokenType.COMMAND: 233>, 'GRANT': <TokenType.GRANT: 284>, 'REVOKE': <TokenType.REVOKE: 367>, 'OPTIMIZE': <TokenType.COMMAND: 233>, 'PREPARE': <TokenType.COMMAND: 233>, 'VACUUM': <TokenType.COMMAND: 233>, 'USER-DEFINED': <TokenType.USERDEFINED: 189>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 420>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 421>, '**': <TokenType.DSTAR: 64>, '^=': <TokenType.NEQ: 28>, 'BYTEINT': <TokenType.SMALLINT: 97>, 'COLLECT': <TokenType.COMMAND: 233>, 'DEL': <TokenType.DELETE: 252>, 'EQ': <TokenType.EQ: 27>, 'GE': <TokenType.GTE: 25>, 'GT': <TokenType.GT: 24>, 'HELP': <TokenType.COMMAND: 233>, 'INS': <TokenType.INSERT: 295>, 'LE': <TokenType.LTE: 23>, 'LOCKING': <TokenType.LOCK: 316>, 'LT': <TokenType.LT: 22>, 'MINUS': <TokenType.EXCEPT: 264>, 'MOD': <TokenType.MOD: 323>, 'NE': <TokenType.NEQ: 28>, 'NOT=': <TokenType.NEQ: 28>, 'SAMPLE': <TokenType.TABLE_SAMPLE: 392>, 'SEL': <TokenType.SELECT: 375>, 'ST_GEOMETRY': <TokenType.GEOMETRY: 171>, 'TOP': <TokenType.TOP: 395>, 'UPD': <TokenType.UPDATE: 404>}

SINGLE_TOKENS = {'(': <TokenType.L_PAREN: 1>, ')': <TokenType.R_PAREN: 2>, '[': <TokenType.L_BRACKET: 3>, ']': <TokenType.R_BRACKET: 4>, '{': <TokenType.L_BRACE: 5>, '}': <TokenType.R_BRACE: 6>, '&': <TokenType.AMP: 35>, '^': <TokenType.CARET: 41>, ':': <TokenType.COLON: 11>, ',': <TokenType.COMMA: 7>, '.': <TokenType.DOT: 8>, '-': <TokenType.DASH: 9>, '=': <TokenType.EQ: 27>, '>': <TokenType.GT: 24>, '<': <TokenType.LT: 22>, '!': <TokenType.NOT: 26>, '|': <TokenType.PIPE: 38>, '+': <TokenType.PLUS: 10>, ';': <TokenType.SEMICOLON: 18>, '/': <TokenType.SLASH: 21>, '\\': <TokenType.BACKSLASH: 20>, '*': <TokenType.STAR: 19>, '~': <TokenType.TILDE: 43>, '?': <TokenType.PLACEHOLDER: 349>, '@': <TokenType.PARAMETER: 55>, '#': <TokenType.HASH: 47>, "'": <TokenType.UNKNOWN: 210>, '`': <TokenType.UNKNOWN: 210>, '"': <TokenType.UNKNOWN: 210>}

BYTE_STRING_ESCAPES: ClassVar[List[str]] = ["'"]

Inherited Members

sqlglot.tokens.Tokenizer: Tokenizer; BIT_STRINGS; BYTE_STRINGS; RAW_STRINGS; HEREDOC_STRINGS; UNICODE_STRINGS; IDENTIFIERS; QUOTES; STRING_ESCAPES; VAR_SINGLE_TOKENS; ESCAPE_FOLLOW_CHARS; IDENTIFIER_ESCAPES; HEREDOC_TAG_IS_IDENTIFIER; HEREDOC_STRING_ALTERNATIVE; STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS; NESTED_COMMENTS; HINT_START; TOKENS_PRECEDING_HINT; COMMANDS; COMMAND_PREFIX_TOKENS; NUMERIC_LITERALS; COMMENTS; dialect; tokenize; sql; size; tokens

sqlglot.dialects.teradata

Inherited Members

Arguments:

Inherited Members

Arguments:

Inherited Members