sqlglot.dialects.redshift

 30class Redshift(Postgres):
 31    # https://docs.aws.amazon.com/redshift/latest/dg/r_names.html
 32    RESOLVES_IDENTIFIERS_AS_UPPERCASE = None
 33
 34    SUPPORTS_USER_DEFINED_TYPES = False
 35    INDEX_OFFSET = 0
 36
 37    TIME_FORMAT = "'YYYY-MM-DD HH:MI:SS'"
 38    TIME_MAPPING = {
 39        **Postgres.TIME_MAPPING,
 40        "MON": "%b",
 41        "HH": "%H",
 42    }
 43
 44    class Parser(Postgres.Parser):
 45        FUNCTIONS = {
 46            **Postgres.Parser.FUNCTIONS,
 47            "ADD_MONTHS": lambda args: exp.DateAdd(
 48                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
 49                expression=seq_get(args, 1),
 50                unit=exp.var("month"),
 51            ),
 52            "DATEADD": _parse_date_add,
 53            "DATE_ADD": _parse_date_add,
 54            "DATEDIFF": lambda args: exp.DateDiff(
 55                this=exp.TsOrDsToDate(this=seq_get(args, 2)),
 56                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
 57                unit=seq_get(args, 0),
 58            ),
 59            "STRTOL": exp.FromBase.from_arg_list,
 60        }
 61
 62        def _parse_table(
 63            self,
 64            schema: bool = False,
 65            joins: bool = False,
 66            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 67            parse_bracket: bool = False,
 68        ) -> t.Optional[exp.Expression]:
 69            # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
 70            unpivot = self._match(TokenType.UNPIVOT)
 71            table = super()._parse_table(
 72                schema=schema,
 73                joins=joins,
 74                alias_tokens=alias_tokens,
 75                parse_bracket=parse_bracket,
 76            )
 77
 78            return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table
 79
 80        def _parse_types(
 81            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
 82        ) -> t.Optional[exp.Expression]:
 83            this = super()._parse_types(
 84                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
 85            )
 86
 87            if (
 88                isinstance(this, exp.DataType)
 89                and this.is_type("varchar")
 90                and this.expressions
 91                and this.expressions[0].this == exp.column("MAX")
 92            ):
 93                this.set("expressions", [exp.var("MAX")])
 94
 95            return this
 96
 97        def _parse_convert(
 98            self, strict: bool, safe: t.Optional[bool] = None
 99        ) -> t.Optional[exp.Expression]:
100            to = self._parse_types()
101            self._match(TokenType.COMMA)
102            this = self._parse_bitwise()
103            return self.expression(exp.TryCast, this=this, to=to, safe=safe)
104
105    class Tokenizer(Postgres.Tokenizer):
106        BIT_STRINGS = []
107        HEX_STRINGS = []
108        STRING_ESCAPES = ["\\", "'"]
109
110        KEYWORDS = {
111            **Postgres.Tokenizer.KEYWORDS,
112            "HLLSKETCH": TokenType.HLLSKETCH,
113            "SUPER": TokenType.SUPER,
114            "SYSDATE": TokenType.CURRENT_TIMESTAMP,
115            "TOP": TokenType.TOP,
116            "UNLOAD": TokenType.COMMAND,
117            "VARBYTE": TokenType.VARBINARY,
118        }
119
120        # Redshift allows # to appear as a table identifier prefix
121        SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy()
122        SINGLE_TOKENS.pop("#")
123
124    class Generator(Postgres.Generator):
125        LOCKING_READS_SUPPORTED = False
126        RENAME_TABLE_WITH_DB = False
127        QUERY_HINTS = False
128        VALUES_AS_TABLE = False
129        TZ_TO_WITH_TIME_ZONE = True
130        NVL2_SUPPORTED = True
131
132        TYPE_MAPPING = {
133            **Postgres.Generator.TYPE_MAPPING,
134            exp.DataType.Type.BINARY: "VARBYTE",
135            exp.DataType.Type.INT: "INTEGER",
136            exp.DataType.Type.TIMETZ: "TIME",
137            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
138            exp.DataType.Type.VARBINARY: "VARBYTE",
139        }
140
141        PROPERTIES_LOCATION = {
142            **Postgres.Generator.PROPERTIES_LOCATION,
143            exp.LikeProperty: exp.Properties.Location.POST_WITH,
144        }
145
146        TRANSFORMS = {
147            **Postgres.Generator.TRANSFORMS,
148            exp.Concat: concat_to_dpipe_sql,
149            exp.ConcatWs: concat_ws_to_dpipe_sql,
150            exp.CurrentTimestamp: lambda self, e: "SYSDATE",
151            exp.DateAdd: lambda self, e: self.func(
152                "DATEADD", exp.var(e.text("unit") or "day"), e.expression, e.this
153            ),
154            exp.DateDiff: lambda self, e: self.func(
155                "DATEDIFF", exp.var(e.text("unit") or "day"), e.expression, e.this
156            ),
157            exp.DistKeyProperty: lambda self, e: f"DISTKEY({e.name})",
158            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
159            exp.FromBase: rename_func("STRTOL"),
160            exp.JSONExtract: _json_sql,
161            exp.JSONExtractScalar: _json_sql,
162            exp.SafeConcat: concat_to_dpipe_sql,
163            exp.Select: transforms.preprocess(
164                [transforms.eliminate_distinct_on, transforms.eliminate_semi_and_anti_joins]
165            ),
166            exp.SortKeyProperty: lambda self, e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
167            exp.TsOrDsToDate: ts_or_ds_to_date_sql("redshift"),
168        }
169
170        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
171        TRANSFORMS.pop(exp.Pivot)
172
173        # Redshift uses the POW | POWER (expr1, expr2) syntax instead of expr1 ^ expr2 (postgres)
174        TRANSFORMS.pop(exp.Pow)
175
176        # Redshift supports ANY_VALUE(..)
177        TRANSFORMS.pop(exp.AnyValue)
178
179        RESERVED_KEYWORDS = {*Postgres.Generator.RESERVED_KEYWORDS, "snapshot", "type"}
180
181        def with_properties(self, properties: exp.Properties) -> str:
182            """Redshift doesn't have `WITH` as part of their with_properties so we remove it"""
183            return self.properties(properties, prefix=" ", suffix="")
184
185        def datatype_sql(self, expression: exp.DataType) -> str:
186            """
187            Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean
188            VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type
189            without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert
190            `TEXT` to `VARCHAR`.
191            """
192            if expression.is_type("text"):
193                expression = expression.copy()
194                expression.set("this", exp.DataType.Type.VARCHAR)
195                precision = expression.args.get("expressions")
196
197                if not precision:
198                    expression.append("expressions", exp.var("MAX"))
199
200            return super().datatype_sql(expression)

 44    class Parser(Postgres.Parser):
 45        FUNCTIONS = {
 46            **Postgres.Parser.FUNCTIONS,
 47            "ADD_MONTHS": lambda args: exp.DateAdd(
 48                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
 49                expression=seq_get(args, 1),
 50                unit=exp.var("month"),
 51            ),
 52            "DATEADD": _parse_date_add,
 53            "DATE_ADD": _parse_date_add,
 54            "DATEDIFF": lambda args: exp.DateDiff(
 55                this=exp.TsOrDsToDate(this=seq_get(args, 2)),
 56                expression=exp.TsOrDsToDate(this=seq_get(args, 1)),
 57                unit=seq_get(args, 0),
 58            ),
 59            "STRTOL": exp.FromBase.from_arg_list,
 60        }
 61
 62        def _parse_table(
 63            self,
 64            schema: bool = False,
 65            joins: bool = False,
 66            alias_tokens: t.Optional[t.Collection[TokenType]] = None,
 67            parse_bracket: bool = False,
 68        ) -> t.Optional[exp.Expression]:
 69            # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
 70            unpivot = self._match(TokenType.UNPIVOT)
 71            table = super()._parse_table(
 72                schema=schema,
 73                joins=joins,
 74                alias_tokens=alias_tokens,
 75                parse_bracket=parse_bracket,
 76            )
 77
 78            return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table
 79
 80        def _parse_types(
 81            self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
 82        ) -> t.Optional[exp.Expression]:
 83            this = super()._parse_types(
 84                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
 85            )
 86
 87            if (
 88                isinstance(this, exp.DataType)
 89                and this.is_type("varchar")
 90                and this.expressions
 91                and this.expressions[0].this == exp.column("MAX")
 92            ):
 93                this.set("expressions", [exp.var("MAX")])
 94
 95            return this
 96
 97        def _parse_convert(
 98            self, strict: bool, safe: t.Optional[bool] = None
 99        ) -> t.Optional[exp.Expression]:
100            to = self._parse_types()
101            self._match(TokenType.COMMA)
102            this = self._parse_bitwise()
103            return self.expression(exp.TryCast, this=this, to=to, safe=safe)

105    class Tokenizer(Postgres.Tokenizer):
106        BIT_STRINGS = []
107        HEX_STRINGS = []
108        STRING_ESCAPES = ["\\", "'"]
109
110        KEYWORDS = {
111            **Postgres.Tokenizer.KEYWORDS,
112            "HLLSKETCH": TokenType.HLLSKETCH,
113            "SUPER": TokenType.SUPER,
114            "SYSDATE": TokenType.CURRENT_TIMESTAMP,
115            "TOP": TokenType.TOP,
116            "UNLOAD": TokenType.COMMAND,
117            "VARBYTE": TokenType.VARBINARY,
118        }
119
120        # Redshift allows # to appear as a table identifier prefix
121        SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy()
122        SINGLE_TOKENS.pop("#")

124    class Generator(Postgres.Generator):
125        LOCKING_READS_SUPPORTED = False
126        RENAME_TABLE_WITH_DB = False
127        QUERY_HINTS = False
128        VALUES_AS_TABLE = False
129        TZ_TO_WITH_TIME_ZONE = True
130        NVL2_SUPPORTED = True
131
132        TYPE_MAPPING = {
133            **Postgres.Generator.TYPE_MAPPING,
134            exp.DataType.Type.BINARY: "VARBYTE",
135            exp.DataType.Type.INT: "INTEGER",
136            exp.DataType.Type.TIMETZ: "TIME",
137            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
138            exp.DataType.Type.VARBINARY: "VARBYTE",
139        }
140
141        PROPERTIES_LOCATION = {
142            **Postgres.Generator.PROPERTIES_LOCATION,
143            exp.LikeProperty: exp.Properties.Location.POST_WITH,
144        }
145
146        TRANSFORMS = {
147            **Postgres.Generator.TRANSFORMS,
148            exp.Concat: concat_to_dpipe_sql,
149            exp.ConcatWs: concat_ws_to_dpipe_sql,
150            exp.CurrentTimestamp: lambda self, e: "SYSDATE",
151            exp.DateAdd: lambda self, e: self.func(
152                "DATEADD", exp.var(e.text("unit") or "day"), e.expression, e.this
153            ),
154            exp.DateDiff: lambda self, e: self.func(
155                "DATEDIFF", exp.var(e.text("unit") or "day"), e.expression, e.this
156            ),
157            exp.DistKeyProperty: lambda self, e: f"DISTKEY({e.name})",
158            exp.DistStyleProperty: lambda self, e: self.naked_property(e),
159            exp.FromBase: rename_func("STRTOL"),
160            exp.JSONExtract: _json_sql,
161            exp.JSONExtractScalar: _json_sql,
162            exp.SafeConcat: concat_to_dpipe_sql,
163            exp.Select: transforms.preprocess(
164                [transforms.eliminate_distinct_on, transforms.eliminate_semi_and_anti_joins]
165            ),
166            exp.SortKeyProperty: lambda self, e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})",
167            exp.TsOrDsToDate: ts_or_ds_to_date_sql("redshift"),
168        }
169
170        # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
171        TRANSFORMS.pop(exp.Pivot)
172
173        # Redshift uses the POW | POWER (expr1, expr2) syntax instead of expr1 ^ expr2 (postgres)
174        TRANSFORMS.pop(exp.Pow)
175
176        # Redshift supports ANY_VALUE(..)
177        TRANSFORMS.pop(exp.AnyValue)
178
179        RESERVED_KEYWORDS = {*Postgres.Generator.RESERVED_KEYWORDS, "snapshot", "type"}
180
181        def with_properties(self, properties: exp.Properties) -> str:
182            """Redshift doesn't have `WITH` as part of their with_properties so we remove it"""
183            return self.properties(properties, prefix=" ", suffix="")
184
185        def datatype_sql(self, expression: exp.DataType) -> str:
186            """
187            Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean
188            VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type
189            without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert
190            `TEXT` to `VARCHAR`.
191            """
192            if expression.is_type("text"):
193                expression = expression.copy()
194                expression.set("this", exp.DataType.Type.VARCHAR)
195                precision = expression.args.get("expressions")
196
197                if not precision:
198                    expression.append("expressions", exp.var("MAX"))
199
200            return super().datatype_sql(expression)