sqlglot.dialects.redshift
1from __future__ import annotations 2 3import typing as t 4 5from sqlglot import exp, transforms 6from sqlglot.dialects.dialect import ( 7 NormalizationStrategy, 8 concat_to_dpipe_sql, 9 concat_ws_to_dpipe_sql, 10 date_delta_sql, 11 generatedasidentitycolumnconstraint_sql, 12 json_extract_segments, 13 no_tablesample_sql, 14 rename_func, 15 map_date_part, 16) 17from sqlglot.dialects.postgres import Postgres 18from sqlglot.helper import seq_get 19from sqlglot.tokens import TokenType 20from sqlglot.parser import build_convert_timezone 21 22if t.TYPE_CHECKING: 23 from sqlglot._typing import E 24 25 26def _build_date_delta(expr_type: t.Type[E]) -> t.Callable[[t.List], E]: 27 def _builder(args: t.List) -> E: 28 expr = expr_type( 29 this=seq_get(args, 2), 30 expression=seq_get(args, 1), 31 unit=map_date_part(seq_get(args, 0)), 32 ) 33 if expr_type is exp.TsOrDsAdd: 34 expr.set("return_type", exp.DataType.build("TIMESTAMP")) 35 36 return expr 37 38 return _builder 39 40 41class Redshift(Postgres): 42 # https://docs.aws.amazon.com/redshift/latest/dg/r_names.html 43 NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE 44 45 SUPPORTS_USER_DEFINED_TYPES = False 46 INDEX_OFFSET = 0 47 COPY_PARAMS_ARE_CSV = False 48 HEX_LOWERCASE = True 49 HAS_DISTINCT_ARRAY_CONSTRUCTORS = True 50 51 # ref: https://docs.aws.amazon.com/redshift/latest/dg/r_FORMAT_strings.html 52 TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'" 53 TIME_MAPPING = {**Postgres.TIME_MAPPING, "MON": "%b", "HH24": "%H", "HH": "%I"} 54 55 class Parser(Postgres.Parser): 56 FUNCTIONS = { 57 **Postgres.Parser.FUNCTIONS, 58 "ADD_MONTHS": lambda args: exp.TsOrDsAdd( 59 this=seq_get(args, 0), 60 expression=seq_get(args, 1), 61 unit=exp.var("month"), 62 return_type=exp.DataType.build("TIMESTAMP"), 63 ), 64 "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"), 65 "DATEADD": _build_date_delta(exp.TsOrDsAdd), 66 "DATE_ADD": _build_date_delta(exp.TsOrDsAdd), 67 "DATEDIFF": _build_date_delta(exp.TsOrDsDiff), 68 "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff), 69 "GETDATE": exp.CurrentTimestamp.from_arg_list, 70 "LISTAGG": exp.GroupConcat.from_arg_list, 71 "SPLIT_TO_ARRAY": lambda args: exp.StringToArray( 72 this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",") 73 ), 74 "STRTOL": exp.FromBase.from_arg_list, 75 } 76 77 NO_PAREN_FUNCTION_PARSERS = { 78 **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS, 79 "APPROXIMATE": lambda self: self._parse_approximate_count(), 80 "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True), 81 } 82 83 SUPPORTS_IMPLICIT_UNNEST = True 84 85 def _parse_table( 86 self, 87 schema: bool = False, 88 joins: bool = False, 89 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 90 parse_bracket: bool = False, 91 is_db_reference: bool = False, 92 parse_partition: bool = False, 93 consume_pipe: bool = False, 94 ) -> t.Optional[exp.Expression]: 95 # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr` 96 unpivot = self._match(TokenType.UNPIVOT) 97 table = super()._parse_table( 98 schema=schema, 99 joins=joins, 100 alias_tokens=alias_tokens, 101 parse_bracket=parse_bracket, 102 is_db_reference=is_db_reference, 103 ) 104 105 return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table 106 107 def _parse_convert( 108 self, strict: bool, safe: t.Optional[bool] = None 109 ) -> t.Optional[exp.Expression]: 110 to = self._parse_types() 111 self._match(TokenType.COMMA) 112 this = self._parse_bitwise() 113 return self.expression(exp.TryCast, this=this, to=to, safe=safe) 114 115 def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]: 116 index = self._index - 1 117 func = self._parse_function() 118 119 if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct): 120 return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0)) 121 self._retreat(index) 122 return None 123 124 class Tokenizer(Postgres.Tokenizer): 125 BIT_STRINGS = [] 126 HEX_STRINGS = [] 127 STRING_ESCAPES = ["\\", "'"] 128 129 KEYWORDS = { 130 **Postgres.Tokenizer.KEYWORDS, 131 "(+)": TokenType.JOIN_MARKER, 132 "HLLSKETCH": TokenType.HLLSKETCH, 133 "MINUS": TokenType.EXCEPT, 134 "SUPER": TokenType.SUPER, 135 "TOP": TokenType.TOP, 136 "UNLOAD": TokenType.COMMAND, 137 "VARBYTE": TokenType.VARBINARY, 138 "BINARY VARYING": TokenType.VARBINARY, 139 } 140 KEYWORDS.pop("VALUES") 141 142 # Redshift allows # to appear as a table identifier prefix 143 SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy() 144 SINGLE_TOKENS.pop("#") 145 146 class Generator(Postgres.Generator): 147 LOCKING_READS_SUPPORTED = False 148 QUERY_HINTS = False 149 VALUES_AS_TABLE = False 150 TZ_TO_WITH_TIME_ZONE = True 151 NVL2_SUPPORTED = True 152 LAST_DAY_SUPPORTS_DATE_PART = False 153 CAN_IMPLEMENT_ARRAY_ANY = False 154 MULTI_ARG_DISTINCT = True 155 COPY_PARAMS_ARE_WRAPPED = False 156 HEX_FUNC = "TO_HEX" 157 PARSE_JSON_NAME = "JSON_PARSE" 158 ARRAY_CONCAT_IS_VAR_LEN = False 159 SUPPORTS_CONVERT_TIMEZONE = True 160 EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False 161 SUPPORTS_MEDIAN = True 162 ALTER_SET_TYPE = "TYPE" 163 SUPPORTS_DECODE_CASE = True 164 SUPPORTS_BETWEEN_FLAGS = False 165 166 # Redshift doesn't have `WITH` as part of their with_properties so we remove it 167 WITH_PROPERTIES_PREFIX = " " 168 169 TYPE_MAPPING = { 170 **Postgres.Generator.TYPE_MAPPING, 171 exp.DataType.Type.BINARY: "VARBYTE", 172 exp.DataType.Type.BLOB: "VARBYTE", 173 exp.DataType.Type.INT: "INTEGER", 174 exp.DataType.Type.TIMETZ: "TIME", 175 exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP", 176 exp.DataType.Type.VARBINARY: "VARBYTE", 177 exp.DataType.Type.ROWVERSION: "VARBYTE", 178 } 179 180 TRANSFORMS = { 181 **Postgres.Generator.TRANSFORMS, 182 exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"), 183 exp.Concat: concat_to_dpipe_sql, 184 exp.ConcatWs: concat_ws_to_dpipe_sql, 185 exp.ApproxDistinct: lambda self, 186 e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})", 187 exp.CurrentTimestamp: lambda self, e: ( 188 "SYSDATE" if e.args.get("sysdate") else "GETDATE()" 189 ), 190 exp.DateAdd: date_delta_sql("DATEADD"), 191 exp.DateDiff: date_delta_sql("DATEDIFF"), 192 exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this), 193 exp.DistStyleProperty: lambda self, e: self.naked_property(e), 194 exp.Explode: lambda self, e: self.explode_sql(e), 195 exp.FromBase: rename_func("STRTOL"), 196 exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql, 197 exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 198 exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 199 exp.GroupConcat: rename_func("LISTAGG"), 200 exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))), 201 exp.Select: transforms.preprocess( 202 [ 203 transforms.eliminate_window_clause, 204 transforms.eliminate_distinct_on, 205 transforms.eliminate_semi_and_anti_joins, 206 transforms.unqualify_unnest, 207 transforms.unnest_generate_date_array_using_recursive_cte, 208 ] 209 ), 210 exp.SortKeyProperty: lambda self, 211 e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})", 212 exp.StartsWith: lambda self, 213 e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'", 214 exp.StringToArray: rename_func("SPLIT_TO_ARRAY"), 215 exp.TableSample: no_tablesample_sql, 216 exp.TsOrDsAdd: date_delta_sql("DATEADD"), 217 exp.TsOrDsDiff: date_delta_sql("DATEDIFF"), 218 exp.UnixToTime: lambda self, e: self._unix_to_time_sql(e), 219 } 220 221 # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots 222 TRANSFORMS.pop(exp.Pivot) 223 224 # Postgres doesn't support JSON_PARSE, but Redshift does 225 TRANSFORMS.pop(exp.ParseJSON) 226 227 # Redshift supports these functions 228 TRANSFORMS.pop(exp.AnyValue) 229 TRANSFORMS.pop(exp.LastDay) 230 TRANSFORMS.pop(exp.SHA2) 231 232 RESERVED_KEYWORDS = { 233 "aes128", 234 "aes256", 235 "all", 236 "allowoverwrite", 237 "analyse", 238 "analyze", 239 "and", 240 "any", 241 "array", 242 "as", 243 "asc", 244 "authorization", 245 "az64", 246 "backup", 247 "between", 248 "binary", 249 "blanksasnull", 250 "both", 251 "bytedict", 252 "bzip2", 253 "case", 254 "cast", 255 "check", 256 "collate", 257 "column", 258 "constraint", 259 "create", 260 "credentials", 261 "cross", 262 "current_date", 263 "current_time", 264 "current_timestamp", 265 "current_user", 266 "current_user_id", 267 "default", 268 "deferrable", 269 "deflate", 270 "defrag", 271 "delta", 272 "delta32k", 273 "desc", 274 "disable", 275 "distinct", 276 "do", 277 "else", 278 "emptyasnull", 279 "enable", 280 "encode", 281 "encrypt ", 282 "encryption", 283 "end", 284 "except", 285 "explicit", 286 "false", 287 "for", 288 "foreign", 289 "freeze", 290 "from", 291 "full", 292 "globaldict256", 293 "globaldict64k", 294 "grant", 295 "group", 296 "gzip", 297 "having", 298 "identity", 299 "ignore", 300 "ilike", 301 "in", 302 "initially", 303 "inner", 304 "intersect", 305 "interval", 306 "into", 307 "is", 308 "isnull", 309 "join", 310 "leading", 311 "left", 312 "like", 313 "limit", 314 "localtime", 315 "localtimestamp", 316 "lun", 317 "luns", 318 "lzo", 319 "lzop", 320 "minus", 321 "mostly16", 322 "mostly32", 323 "mostly8", 324 "natural", 325 "new", 326 "not", 327 "notnull", 328 "null", 329 "nulls", 330 "off", 331 "offline", 332 "offset", 333 "oid", 334 "old", 335 "on", 336 "only", 337 "open", 338 "or", 339 "order", 340 "outer", 341 "overlaps", 342 "parallel", 343 "partition", 344 "percent", 345 "permissions", 346 "pivot", 347 "placing", 348 "primary", 349 "raw", 350 "readratio", 351 "recover", 352 "references", 353 "rejectlog", 354 "resort", 355 "respect", 356 "restore", 357 "right", 358 "select", 359 "session_user", 360 "similar", 361 "snapshot", 362 "some", 363 "sysdate", 364 "system", 365 "table", 366 "tag", 367 "tdes", 368 "text255", 369 "text32k", 370 "then", 371 "timestamp", 372 "to", 373 "top", 374 "trailing", 375 "true", 376 "truncatecolumns", 377 "type", 378 "union", 379 "unique", 380 "unnest", 381 "unpivot", 382 "user", 383 "using", 384 "verbose", 385 "wallet", 386 "when", 387 "where", 388 "with", 389 "without", 390 } 391 392 def unnest_sql(self, expression: exp.Unnest) -> str: 393 args = expression.expressions 394 num_args = len(args) 395 396 if num_args != 1: 397 self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}") 398 return "" 399 400 if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select): 401 self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses") 402 return "" 403 404 arg = self.sql(seq_get(args, 0)) 405 406 alias = self.expressions(expression.args.get("alias"), key="columns", flat=True) 407 return f"{arg} AS {alias}" if alias else arg 408 409 def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: 410 if expression.is_type(exp.DataType.Type.JSON): 411 # Redshift doesn't support a JSON type, so casting to it is treated as a noop 412 return self.sql(expression, "this") 413 414 return super().cast_sql(expression, safe_prefix=safe_prefix) 415 416 def datatype_sql(self, expression: exp.DataType) -> str: 417 """ 418 Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean 419 VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type 420 without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert 421 `TEXT` to `VARCHAR`. 422 """ 423 if expression.is_type("text"): 424 expression.set("this", exp.DataType.Type.VARCHAR) 425 precision = expression.args.get("expressions") 426 427 if not precision: 428 expression.append("expressions", exp.var("MAX")) 429 430 return super().datatype_sql(expression) 431 432 def alterset_sql(self, expression: exp.AlterSet) -> str: 433 exprs = self.expressions(expression, flat=True) 434 exprs = f" TABLE PROPERTIES ({exprs})" if exprs else "" 435 location = self.sql(expression, "location") 436 location = f" LOCATION {location}" if location else "" 437 file_format = self.expressions(expression, key="file_format", flat=True, sep=" ") 438 file_format = f" FILE FORMAT {file_format}" if file_format else "" 439 440 return f"SET{exprs}{location}{file_format}" 441 442 def array_sql(self, expression: exp.Array) -> str: 443 if expression.args.get("bracket_notation"): 444 return super().array_sql(expression) 445 446 return rename_func("ARRAY")(self, expression) 447 448 def explode_sql(self, expression: exp.Explode) -> str: 449 self.unsupported("Unsupported EXPLODE() function") 450 return "" 451 452 def _unix_to_time_sql(self, expression: exp.UnixToTime) -> str: 453 scale = expression.args.get("scale") 454 this = self.sql(expression.this) 455 456 if scale is not None and scale != exp.UnixToTime.SECONDS and scale.is_int: 457 this = f"({this} / POWER(10, {scale.to_py()}))" 458 459 return f"(TIMESTAMP 'epoch' + {this} * INTERVAL '1 SECOND')"
42class Redshift(Postgres): 43 # https://docs.aws.amazon.com/redshift/latest/dg/r_names.html 44 NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE 45 46 SUPPORTS_USER_DEFINED_TYPES = False 47 INDEX_OFFSET = 0 48 COPY_PARAMS_ARE_CSV = False 49 HEX_LOWERCASE = True 50 HAS_DISTINCT_ARRAY_CONSTRUCTORS = True 51 52 # ref: https://docs.aws.amazon.com/redshift/latest/dg/r_FORMAT_strings.html 53 TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'" 54 TIME_MAPPING = {**Postgres.TIME_MAPPING, "MON": "%b", "HH24": "%H", "HH": "%I"} 55 56 class Parser(Postgres.Parser): 57 FUNCTIONS = { 58 **Postgres.Parser.FUNCTIONS, 59 "ADD_MONTHS": lambda args: exp.TsOrDsAdd( 60 this=seq_get(args, 0), 61 expression=seq_get(args, 1), 62 unit=exp.var("month"), 63 return_type=exp.DataType.build("TIMESTAMP"), 64 ), 65 "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"), 66 "DATEADD": _build_date_delta(exp.TsOrDsAdd), 67 "DATE_ADD": _build_date_delta(exp.TsOrDsAdd), 68 "DATEDIFF": _build_date_delta(exp.TsOrDsDiff), 69 "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff), 70 "GETDATE": exp.CurrentTimestamp.from_arg_list, 71 "LISTAGG": exp.GroupConcat.from_arg_list, 72 "SPLIT_TO_ARRAY": lambda args: exp.StringToArray( 73 this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",") 74 ), 75 "STRTOL": exp.FromBase.from_arg_list, 76 } 77 78 NO_PAREN_FUNCTION_PARSERS = { 79 **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS, 80 "APPROXIMATE": lambda self: self._parse_approximate_count(), 81 "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True), 82 } 83 84 SUPPORTS_IMPLICIT_UNNEST = True 85 86 def _parse_table( 87 self, 88 schema: bool = False, 89 joins: bool = False, 90 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 91 parse_bracket: bool = False, 92 is_db_reference: bool = False, 93 parse_partition: bool = False, 94 consume_pipe: bool = False, 95 ) -> t.Optional[exp.Expression]: 96 # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr` 97 unpivot = self._match(TokenType.UNPIVOT) 98 table = super()._parse_table( 99 schema=schema, 100 joins=joins, 101 alias_tokens=alias_tokens, 102 parse_bracket=parse_bracket, 103 is_db_reference=is_db_reference, 104 ) 105 106 return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table 107 108 def _parse_convert( 109 self, strict: bool, safe: t.Optional[bool] = None 110 ) -> t.Optional[exp.Expression]: 111 to = self._parse_types() 112 self._match(TokenType.COMMA) 113 this = self._parse_bitwise() 114 return self.expression(exp.TryCast, this=this, to=to, safe=safe) 115 116 def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]: 117 index = self._index - 1 118 func = self._parse_function() 119 120 if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct): 121 return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0)) 122 self._retreat(index) 123 return None 124 125 class Tokenizer(Postgres.Tokenizer): 126 BIT_STRINGS = [] 127 HEX_STRINGS = [] 128 STRING_ESCAPES = ["\\", "'"] 129 130 KEYWORDS = { 131 **Postgres.Tokenizer.KEYWORDS, 132 "(+)": TokenType.JOIN_MARKER, 133 "HLLSKETCH": TokenType.HLLSKETCH, 134 "MINUS": TokenType.EXCEPT, 135 "SUPER": TokenType.SUPER, 136 "TOP": TokenType.TOP, 137 "UNLOAD": TokenType.COMMAND, 138 "VARBYTE": TokenType.VARBINARY, 139 "BINARY VARYING": TokenType.VARBINARY, 140 } 141 KEYWORDS.pop("VALUES") 142 143 # Redshift allows # to appear as a table identifier prefix 144 SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy() 145 SINGLE_TOKENS.pop("#") 146 147 class Generator(Postgres.Generator): 148 LOCKING_READS_SUPPORTED = False 149 QUERY_HINTS = False 150 VALUES_AS_TABLE = False 151 TZ_TO_WITH_TIME_ZONE = True 152 NVL2_SUPPORTED = True 153 LAST_DAY_SUPPORTS_DATE_PART = False 154 CAN_IMPLEMENT_ARRAY_ANY = False 155 MULTI_ARG_DISTINCT = True 156 COPY_PARAMS_ARE_WRAPPED = False 157 HEX_FUNC = "TO_HEX" 158 PARSE_JSON_NAME = "JSON_PARSE" 159 ARRAY_CONCAT_IS_VAR_LEN = False 160 SUPPORTS_CONVERT_TIMEZONE = True 161 EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False 162 SUPPORTS_MEDIAN = True 163 ALTER_SET_TYPE = "TYPE" 164 SUPPORTS_DECODE_CASE = True 165 SUPPORTS_BETWEEN_FLAGS = False 166 167 # Redshift doesn't have `WITH` as part of their with_properties so we remove it 168 WITH_PROPERTIES_PREFIX = " " 169 170 TYPE_MAPPING = { 171 **Postgres.Generator.TYPE_MAPPING, 172 exp.DataType.Type.BINARY: "VARBYTE", 173 exp.DataType.Type.BLOB: "VARBYTE", 174 exp.DataType.Type.INT: "INTEGER", 175 exp.DataType.Type.TIMETZ: "TIME", 176 exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP", 177 exp.DataType.Type.VARBINARY: "VARBYTE", 178 exp.DataType.Type.ROWVERSION: "VARBYTE", 179 } 180 181 TRANSFORMS = { 182 **Postgres.Generator.TRANSFORMS, 183 exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"), 184 exp.Concat: concat_to_dpipe_sql, 185 exp.ConcatWs: concat_ws_to_dpipe_sql, 186 exp.ApproxDistinct: lambda self, 187 e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})", 188 exp.CurrentTimestamp: lambda self, e: ( 189 "SYSDATE" if e.args.get("sysdate") else "GETDATE()" 190 ), 191 exp.DateAdd: date_delta_sql("DATEADD"), 192 exp.DateDiff: date_delta_sql("DATEDIFF"), 193 exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this), 194 exp.DistStyleProperty: lambda self, e: self.naked_property(e), 195 exp.Explode: lambda self, e: self.explode_sql(e), 196 exp.FromBase: rename_func("STRTOL"), 197 exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql, 198 exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 199 exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 200 exp.GroupConcat: rename_func("LISTAGG"), 201 exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))), 202 exp.Select: transforms.preprocess( 203 [ 204 transforms.eliminate_window_clause, 205 transforms.eliminate_distinct_on, 206 transforms.eliminate_semi_and_anti_joins, 207 transforms.unqualify_unnest, 208 transforms.unnest_generate_date_array_using_recursive_cte, 209 ] 210 ), 211 exp.SortKeyProperty: lambda self, 212 e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})", 213 exp.StartsWith: lambda self, 214 e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'", 215 exp.StringToArray: rename_func("SPLIT_TO_ARRAY"), 216 exp.TableSample: no_tablesample_sql, 217 exp.TsOrDsAdd: date_delta_sql("DATEADD"), 218 exp.TsOrDsDiff: date_delta_sql("DATEDIFF"), 219 exp.UnixToTime: lambda self, e: self._unix_to_time_sql(e), 220 } 221 222 # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots 223 TRANSFORMS.pop(exp.Pivot) 224 225 # Postgres doesn't support JSON_PARSE, but Redshift does 226 TRANSFORMS.pop(exp.ParseJSON) 227 228 # Redshift supports these functions 229 TRANSFORMS.pop(exp.AnyValue) 230 TRANSFORMS.pop(exp.LastDay) 231 TRANSFORMS.pop(exp.SHA2) 232 233 RESERVED_KEYWORDS = { 234 "aes128", 235 "aes256", 236 "all", 237 "allowoverwrite", 238 "analyse", 239 "analyze", 240 "and", 241 "any", 242 "array", 243 "as", 244 "asc", 245 "authorization", 246 "az64", 247 "backup", 248 "between", 249 "binary", 250 "blanksasnull", 251 "both", 252 "bytedict", 253 "bzip2", 254 "case", 255 "cast", 256 "check", 257 "collate", 258 "column", 259 "constraint", 260 "create", 261 "credentials", 262 "cross", 263 "current_date", 264 "current_time", 265 "current_timestamp", 266 "current_user", 267 "current_user_id", 268 "default", 269 "deferrable", 270 "deflate", 271 "defrag", 272 "delta", 273 "delta32k", 274 "desc", 275 "disable", 276 "distinct", 277 "do", 278 "else", 279 "emptyasnull", 280 "enable", 281 "encode", 282 "encrypt ", 283 "encryption", 284 "end", 285 "except", 286 "explicit", 287 "false", 288 "for", 289 "foreign", 290 "freeze", 291 "from", 292 "full", 293 "globaldict256", 294 "globaldict64k", 295 "grant", 296 "group", 297 "gzip", 298 "having", 299 "identity", 300 "ignore", 301 "ilike", 302 "in", 303 "initially", 304 "inner", 305 "intersect", 306 "interval", 307 "into", 308 "is", 309 "isnull", 310 "join", 311 "leading", 312 "left", 313 "like", 314 "limit", 315 "localtime", 316 "localtimestamp", 317 "lun", 318 "luns", 319 "lzo", 320 "lzop", 321 "minus", 322 "mostly16", 323 "mostly32", 324 "mostly8", 325 "natural", 326 "new", 327 "not", 328 "notnull", 329 "null", 330 "nulls", 331 "off", 332 "offline", 333 "offset", 334 "oid", 335 "old", 336 "on", 337 "only", 338 "open", 339 "or", 340 "order", 341 "outer", 342 "overlaps", 343 "parallel", 344 "partition", 345 "percent", 346 "permissions", 347 "pivot", 348 "placing", 349 "primary", 350 "raw", 351 "readratio", 352 "recover", 353 "references", 354 "rejectlog", 355 "resort", 356 "respect", 357 "restore", 358 "right", 359 "select", 360 "session_user", 361 "similar", 362 "snapshot", 363 "some", 364 "sysdate", 365 "system", 366 "table", 367 "tag", 368 "tdes", 369 "text255", 370 "text32k", 371 "then", 372 "timestamp", 373 "to", 374 "top", 375 "trailing", 376 "true", 377 "truncatecolumns", 378 "type", 379 "union", 380 "unique", 381 "unnest", 382 "unpivot", 383 "user", 384 "using", 385 "verbose", 386 "wallet", 387 "when", 388 "where", 389 "with", 390 "without", 391 } 392 393 def unnest_sql(self, expression: exp.Unnest) -> str: 394 args = expression.expressions 395 num_args = len(args) 396 397 if num_args != 1: 398 self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}") 399 return "" 400 401 if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select): 402 self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses") 403 return "" 404 405 arg = self.sql(seq_get(args, 0)) 406 407 alias = self.expressions(expression.args.get("alias"), key="columns", flat=True) 408 return f"{arg} AS {alias}" if alias else arg 409 410 def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: 411 if expression.is_type(exp.DataType.Type.JSON): 412 # Redshift doesn't support a JSON type, so casting to it is treated as a noop 413 return self.sql(expression, "this") 414 415 return super().cast_sql(expression, safe_prefix=safe_prefix) 416 417 def datatype_sql(self, expression: exp.DataType) -> str: 418 """ 419 Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean 420 VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type 421 without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert 422 `TEXT` to `VARCHAR`. 423 """ 424 if expression.is_type("text"): 425 expression.set("this", exp.DataType.Type.VARCHAR) 426 precision = expression.args.get("expressions") 427 428 if not precision: 429 expression.append("expressions", exp.var("MAX")) 430 431 return super().datatype_sql(expression) 432 433 def alterset_sql(self, expression: exp.AlterSet) -> str: 434 exprs = self.expressions(expression, flat=True) 435 exprs = f" TABLE PROPERTIES ({exprs})" if exprs else "" 436 location = self.sql(expression, "location") 437 location = f" LOCATION {location}" if location else "" 438 file_format = self.expressions(expression, key="file_format", flat=True, sep=" ") 439 file_format = f" FILE FORMAT {file_format}" if file_format else "" 440 441 return f"SET{exprs}{location}{file_format}" 442 443 def array_sql(self, expression: exp.Array) -> str: 444 if expression.args.get("bracket_notation"): 445 return super().array_sql(expression) 446 447 return rename_func("ARRAY")(self, expression) 448 449 def explode_sql(self, expression: exp.Explode) -> str: 450 self.unsupported("Unsupported EXPLODE() function") 451 return "" 452 453 def _unix_to_time_sql(self, expression: exp.UnixToTime) -> str: 454 scale = expression.args.get("scale") 455 this = self.sql(expression.this) 456 457 if scale is not None and scale != exp.UnixToTime.SECONDS and scale.is_int: 458 this = f"({this} / POWER(10, {scale.to_py()}))" 459 460 return f"(TIMESTAMP 'epoch' + {this} * INTERVAL '1 SECOND')"
Specifies the strategy according to which identifiers should be normalized.
Whether the ARRAY constructor is context-sensitive, i.e in Redshift ARRAY[1, 2, 3] != ARRAY(1, 2, 3) as the former is of type INT[] vs the latter which is SUPER
Associates this dialect's time formats with their equivalent Python strftime
formats.
Mapping of an escaped sequence (\n
) to its unescaped version (
).
56 class Parser(Postgres.Parser): 57 FUNCTIONS = { 58 **Postgres.Parser.FUNCTIONS, 59 "ADD_MONTHS": lambda args: exp.TsOrDsAdd( 60 this=seq_get(args, 0), 61 expression=seq_get(args, 1), 62 unit=exp.var("month"), 63 return_type=exp.DataType.build("TIMESTAMP"), 64 ), 65 "CONVERT_TIMEZONE": lambda args: build_convert_timezone(args, "UTC"), 66 "DATEADD": _build_date_delta(exp.TsOrDsAdd), 67 "DATE_ADD": _build_date_delta(exp.TsOrDsAdd), 68 "DATEDIFF": _build_date_delta(exp.TsOrDsDiff), 69 "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff), 70 "GETDATE": exp.CurrentTimestamp.from_arg_list, 71 "LISTAGG": exp.GroupConcat.from_arg_list, 72 "SPLIT_TO_ARRAY": lambda args: exp.StringToArray( 73 this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",") 74 ), 75 "STRTOL": exp.FromBase.from_arg_list, 76 } 77 78 NO_PAREN_FUNCTION_PARSERS = { 79 **Postgres.Parser.NO_PAREN_FUNCTION_PARSERS, 80 "APPROXIMATE": lambda self: self._parse_approximate_count(), 81 "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True), 82 } 83 84 SUPPORTS_IMPLICIT_UNNEST = True 85 86 def _parse_table( 87 self, 88 schema: bool = False, 89 joins: bool = False, 90 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 91 parse_bracket: bool = False, 92 is_db_reference: bool = False, 93 parse_partition: bool = False, 94 consume_pipe: bool = False, 95 ) -> t.Optional[exp.Expression]: 96 # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr` 97 unpivot = self._match(TokenType.UNPIVOT) 98 table = super()._parse_table( 99 schema=schema, 100 joins=joins, 101 alias_tokens=alias_tokens, 102 parse_bracket=parse_bracket, 103 is_db_reference=is_db_reference, 104 ) 105 106 return self.expression(exp.Pivot, this=table, unpivot=True) if unpivot else table 107 108 def _parse_convert( 109 self, strict: bool, safe: t.Optional[bool] = None 110 ) -> t.Optional[exp.Expression]: 111 to = self._parse_types() 112 self._match(TokenType.COMMA) 113 this = self._parse_bitwise() 114 return self.expression(exp.TryCast, this=this, to=to, safe=safe) 115 116 def _parse_approximate_count(self) -> t.Optional[exp.ApproxDistinct]: 117 index = self._index - 1 118 func = self._parse_function() 119 120 if isinstance(func, exp.Count) and isinstance(func.this, exp.Distinct): 121 return self.expression(exp.ApproxDistinct, this=seq_get(func.this.expressions, 0)) 122 self._retreat(index) 123 return None
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
Inherited Members
- sqlglot.parser.Parser
- Parser
- STRUCT_TYPE_TOKENS
- NESTED_TYPE_TOKENS
- ENUM_TYPE_TOKENS
- AGGREGATE_TYPE_TOKENS
- TYPE_TOKENS
- SIGNED_TO_UNSIGNED_TYPE_TOKEN
- SUBQUERY_PREDICATES
- RESERVED_TOKENS
- DB_CREATABLES
- CREATABLES
- ALTERABLES
- ALIAS_TOKENS
- COLON_PLACEHOLDER_TOKENS
- ARRAY_CONSTRUCTORS
- COMMENT_TABLE_ALIAS_TOKENS
- UPDATE_ALIAS_TOKENS
- TRIM_TYPES
- FUNC_TOKENS
- CONJUNCTION
- ASSIGNMENT
- DISJUNCTION
- EQUALITY
- COMPARISON
- TERM
- FACTOR
- TIMES
- TIMESTAMPS
- SET_OPERATIONS
- JOIN_METHODS
- JOIN_SIDES
- JOIN_KINDS
- JOIN_HINTS
- LAMBDAS
- EXPRESSION_PARSERS
- UNARY_PARSERS
- STRING_PARSERS
- NUMERIC_PARSERS
- PRIMARY_PARSERS
- PIPE_SYNTAX_TRANSFORM_PARSERS
- CONSTRAINT_PARSERS
- ALTER_PARSERS
- ALTER_ALTER_PARSERS
- SCHEMA_UNNAMED_CONSTRAINTS
- INVALID_FUNC_NAME_TOKENS
- FUNCTIONS_WITH_ALIASED_ARGS
- KEY_VALUE_DEFINITIONS
- 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
- 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
- NULL_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
- ANALYZE_STYLES
- ANALYZE_EXPRESSION_PARSERS
- PARTITION_KEYWORDS
- AMBIGUOUS_ALIAS_TOKENS
- OPERATION_MODIFIERS
- RECURSIVE_CTE_SEARCH_KIND
- MODIFIABLES
- STRICT_CAST
- PREFIXED_PIVOT_COLUMNS
- IDENTIFY_PIVOT_STRINGS
- 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
- COLON_IS_VARIANT_EXTRACT
- VALUES_FOLLOWED_BY_PAREN
- INTERVAL_SPANS
- SUPPORTS_PARTITION_SELECTION
- WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
- OPTIONAL_ALIAS_TOKEN_CTE
- ALTER_RENAME_REQUIRES_COLUMN
- JOINS_HAVE_EQUAL_PRECEDENCE
- ZONE_AWARE_TIMESTAMP_CONSTRUCTOR
- MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS
- JSON_EXTRACT_REQUIRES_JSON_EXPRESSION
- error_level
- error_message_context
- max_errors
- dialect
- reset
- parse
- parse_into
- check_errors
- raise_error
- expression
- validate_expression
- parse_set_operation
- build_cast
- errors
- sql
125 class Tokenizer(Postgres.Tokenizer): 126 BIT_STRINGS = [] 127 HEX_STRINGS = [] 128 STRING_ESCAPES = ["\\", "'"] 129 130 KEYWORDS = { 131 **Postgres.Tokenizer.KEYWORDS, 132 "(+)": TokenType.JOIN_MARKER, 133 "HLLSKETCH": TokenType.HLLSKETCH, 134 "MINUS": TokenType.EXCEPT, 135 "SUPER": TokenType.SUPER, 136 "TOP": TokenType.TOP, 137 "UNLOAD": TokenType.COMMAND, 138 "VARBYTE": TokenType.VARBINARY, 139 "BINARY VARYING": TokenType.VARBINARY, 140 } 141 KEYWORDS.pop("VALUES") 142 143 # Redshift allows # to appear as a table identifier prefix 144 SINGLE_TOKENS = Postgres.Tokenizer.SINGLE_TOKENS.copy() 145 SINGLE_TOKENS.pop("#")
Inherited Members
- sqlglot.tokens.Tokenizer
- Tokenizer
- RAW_STRINGS
- UNICODE_STRINGS
- IDENTIFIERS
- QUOTES
- IDENTIFIER_ESCAPES
- STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS
- NESTED_COMMENTS
- HINT_START
- TOKENS_PRECEDING_HINT
- WHITE_SPACE
- COMMANDS
- COMMAND_PREFIX_TOKENS
- NUMERIC_LITERALS
- COMMENTS
- dialect
- use_rs_tokenizer
- reset
- tokenize
- tokenize_rs
- size
- sql
- tokens
147 class Generator(Postgres.Generator): 148 LOCKING_READS_SUPPORTED = False 149 QUERY_HINTS = False 150 VALUES_AS_TABLE = False 151 TZ_TO_WITH_TIME_ZONE = True 152 NVL2_SUPPORTED = True 153 LAST_DAY_SUPPORTS_DATE_PART = False 154 CAN_IMPLEMENT_ARRAY_ANY = False 155 MULTI_ARG_DISTINCT = True 156 COPY_PARAMS_ARE_WRAPPED = False 157 HEX_FUNC = "TO_HEX" 158 PARSE_JSON_NAME = "JSON_PARSE" 159 ARRAY_CONCAT_IS_VAR_LEN = False 160 SUPPORTS_CONVERT_TIMEZONE = True 161 EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False 162 SUPPORTS_MEDIAN = True 163 ALTER_SET_TYPE = "TYPE" 164 SUPPORTS_DECODE_CASE = True 165 SUPPORTS_BETWEEN_FLAGS = False 166 167 # Redshift doesn't have `WITH` as part of their with_properties so we remove it 168 WITH_PROPERTIES_PREFIX = " " 169 170 TYPE_MAPPING = { 171 **Postgres.Generator.TYPE_MAPPING, 172 exp.DataType.Type.BINARY: "VARBYTE", 173 exp.DataType.Type.BLOB: "VARBYTE", 174 exp.DataType.Type.INT: "INTEGER", 175 exp.DataType.Type.TIMETZ: "TIME", 176 exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP", 177 exp.DataType.Type.VARBINARY: "VARBYTE", 178 exp.DataType.Type.ROWVERSION: "VARBYTE", 179 } 180 181 TRANSFORMS = { 182 **Postgres.Generator.TRANSFORMS, 183 exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CONCAT"), 184 exp.Concat: concat_to_dpipe_sql, 185 exp.ConcatWs: concat_ws_to_dpipe_sql, 186 exp.ApproxDistinct: lambda self, 187 e: f"APPROXIMATE COUNT(DISTINCT {self.sql(e, 'this')})", 188 exp.CurrentTimestamp: lambda self, e: ( 189 "SYSDATE" if e.args.get("sysdate") else "GETDATE()" 190 ), 191 exp.DateAdd: date_delta_sql("DATEADD"), 192 exp.DateDiff: date_delta_sql("DATEDIFF"), 193 exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this), 194 exp.DistStyleProperty: lambda self, e: self.naked_property(e), 195 exp.Explode: lambda self, e: self.explode_sql(e), 196 exp.FromBase: rename_func("STRTOL"), 197 exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql, 198 exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 199 exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"), 200 exp.GroupConcat: rename_func("LISTAGG"), 201 exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))), 202 exp.Select: transforms.preprocess( 203 [ 204 transforms.eliminate_window_clause, 205 transforms.eliminate_distinct_on, 206 transforms.eliminate_semi_and_anti_joins, 207 transforms.unqualify_unnest, 208 transforms.unnest_generate_date_array_using_recursive_cte, 209 ] 210 ), 211 exp.SortKeyProperty: lambda self, 212 e: f"{'COMPOUND ' if e.args['compound'] else ''}SORTKEY({self.format_args(*e.this)})", 213 exp.StartsWith: lambda self, 214 e: f"{self.sql(e.this)} LIKE {self.sql(e.expression)} || '%'", 215 exp.StringToArray: rename_func("SPLIT_TO_ARRAY"), 216 exp.TableSample: no_tablesample_sql, 217 exp.TsOrDsAdd: date_delta_sql("DATEADD"), 218 exp.TsOrDsDiff: date_delta_sql("DATEDIFF"), 219 exp.UnixToTime: lambda self, e: self._unix_to_time_sql(e), 220 } 221 222 # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots 223 TRANSFORMS.pop(exp.Pivot) 224 225 # Postgres doesn't support JSON_PARSE, but Redshift does 226 TRANSFORMS.pop(exp.ParseJSON) 227 228 # Redshift supports these functions 229 TRANSFORMS.pop(exp.AnyValue) 230 TRANSFORMS.pop(exp.LastDay) 231 TRANSFORMS.pop(exp.SHA2) 232 233 RESERVED_KEYWORDS = { 234 "aes128", 235 "aes256", 236 "all", 237 "allowoverwrite", 238 "analyse", 239 "analyze", 240 "and", 241 "any", 242 "array", 243 "as", 244 "asc", 245 "authorization", 246 "az64", 247 "backup", 248 "between", 249 "binary", 250 "blanksasnull", 251 "both", 252 "bytedict", 253 "bzip2", 254 "case", 255 "cast", 256 "check", 257 "collate", 258 "column", 259 "constraint", 260 "create", 261 "credentials", 262 "cross", 263 "current_date", 264 "current_time", 265 "current_timestamp", 266 "current_user", 267 "current_user_id", 268 "default", 269 "deferrable", 270 "deflate", 271 "defrag", 272 "delta", 273 "delta32k", 274 "desc", 275 "disable", 276 "distinct", 277 "do", 278 "else", 279 "emptyasnull", 280 "enable", 281 "encode", 282 "encrypt ", 283 "encryption", 284 "end", 285 "except", 286 "explicit", 287 "false", 288 "for", 289 "foreign", 290 "freeze", 291 "from", 292 "full", 293 "globaldict256", 294 "globaldict64k", 295 "grant", 296 "group", 297 "gzip", 298 "having", 299 "identity", 300 "ignore", 301 "ilike", 302 "in", 303 "initially", 304 "inner", 305 "intersect", 306 "interval", 307 "into", 308 "is", 309 "isnull", 310 "join", 311 "leading", 312 "left", 313 "like", 314 "limit", 315 "localtime", 316 "localtimestamp", 317 "lun", 318 "luns", 319 "lzo", 320 "lzop", 321 "minus", 322 "mostly16", 323 "mostly32", 324 "mostly8", 325 "natural", 326 "new", 327 "not", 328 "notnull", 329 "null", 330 "nulls", 331 "off", 332 "offline", 333 "offset", 334 "oid", 335 "old", 336 "on", 337 "only", 338 "open", 339 "or", 340 "order", 341 "outer", 342 "overlaps", 343 "parallel", 344 "partition", 345 "percent", 346 "permissions", 347 "pivot", 348 "placing", 349 "primary", 350 "raw", 351 "readratio", 352 "recover", 353 "references", 354 "rejectlog", 355 "resort", 356 "respect", 357 "restore", 358 "right", 359 "select", 360 "session_user", 361 "similar", 362 "snapshot", 363 "some", 364 "sysdate", 365 "system", 366 "table", 367 "tag", 368 "tdes", 369 "text255", 370 "text32k", 371 "then", 372 "timestamp", 373 "to", 374 "top", 375 "trailing", 376 "true", 377 "truncatecolumns", 378 "type", 379 "union", 380 "unique", 381 "unnest", 382 "unpivot", 383 "user", 384 "using", 385 "verbose", 386 "wallet", 387 "when", 388 "where", 389 "with", 390 "without", 391 } 392 393 def unnest_sql(self, expression: exp.Unnest) -> str: 394 args = expression.expressions 395 num_args = len(args) 396 397 if num_args != 1: 398 self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}") 399 return "" 400 401 if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select): 402 self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses") 403 return "" 404 405 arg = self.sql(seq_get(args, 0)) 406 407 alias = self.expressions(expression.args.get("alias"), key="columns", flat=True) 408 return f"{arg} AS {alias}" if alias else arg 409 410 def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: 411 if expression.is_type(exp.DataType.Type.JSON): 412 # Redshift doesn't support a JSON type, so casting to it is treated as a noop 413 return self.sql(expression, "this") 414 415 return super().cast_sql(expression, safe_prefix=safe_prefix) 416 417 def datatype_sql(self, expression: exp.DataType) -> str: 418 """ 419 Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean 420 VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type 421 without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert 422 `TEXT` to `VARCHAR`. 423 """ 424 if expression.is_type("text"): 425 expression.set("this", exp.DataType.Type.VARCHAR) 426 precision = expression.args.get("expressions") 427 428 if not precision: 429 expression.append("expressions", exp.var("MAX")) 430 431 return super().datatype_sql(expression) 432 433 def alterset_sql(self, expression: exp.AlterSet) -> str: 434 exprs = self.expressions(expression, flat=True) 435 exprs = f" TABLE PROPERTIES ({exprs})" if exprs else "" 436 location = self.sql(expression, "location") 437 location = f" LOCATION {location}" if location else "" 438 file_format = self.expressions(expression, key="file_format", flat=True, sep=" ") 439 file_format = f" FILE FORMAT {file_format}" if file_format else "" 440 441 return f"SET{exprs}{location}{file_format}" 442 443 def array_sql(self, expression: exp.Array) -> str: 444 if expression.args.get("bracket_notation"): 445 return super().array_sql(expression) 446 447 return rename_func("ARRAY")(self, expression) 448 449 def explode_sql(self, expression: exp.Explode) -> str: 450 self.unsupported("Unsupported EXPLODE() function") 451 return "" 452 453 def _unix_to_time_sql(self, expression: exp.UnixToTime) -> str: 454 scale = expression.args.get("scale") 455 this = self.sql(expression.this) 456 457 if scale is not None and scale != exp.UnixToTime.SECONDS and scale.is_int: 458 this = f"({this} / POWER(10, {scale.to_py()}))" 459 460 return f"(TIMESTAMP 'epoch' + {this} * INTERVAL '1 SECOND')"
Generator converts a given syntax tree to the corresponding SQL string.
Arguments:
- pretty: Whether to format the produced SQL string. Default: False.
- identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
- normalize: Whether to normalize identifiers to lowercase. Default: False.
- pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
- indent: The indentation size in a formatted string. For example, this affects the
indentation of subqueries and filters under a
WHERE
clause. Default: 2. - normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
- unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
- max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
- leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
- max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
- comments: Whether to preserve comments in the output SQL code. Default: True
393 def unnest_sql(self, expression: exp.Unnest) -> str: 394 args = expression.expressions 395 num_args = len(args) 396 397 if num_args != 1: 398 self.unsupported(f"Unsupported number of arguments in UNNEST: {num_args}") 399 return "" 400 401 if isinstance(expression.find_ancestor(exp.From, exp.Join, exp.Select), exp.Select): 402 self.unsupported("Unsupported UNNEST when not used in FROM/JOIN clauses") 403 return "" 404 405 arg = self.sql(seq_get(args, 0)) 406 407 alias = self.expressions(expression.args.get("alias"), key="columns", flat=True) 408 return f"{arg} AS {alias}" if alias else arg
410 def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str: 411 if expression.is_type(exp.DataType.Type.JSON): 412 # Redshift doesn't support a JSON type, so casting to it is treated as a noop 413 return self.sql(expression, "this") 414 415 return super().cast_sql(expression, safe_prefix=safe_prefix)
417 def datatype_sql(self, expression: exp.DataType) -> str: 418 """ 419 Redshift converts the `TEXT` data type to `VARCHAR(255)` by default when people more generally mean 420 VARCHAR of max length which is `VARCHAR(max)` in Redshift. Therefore if we get a `TEXT` data type 421 without precision we convert it to `VARCHAR(max)` and if it does have precision then we just convert 422 `TEXT` to `VARCHAR`. 423 """ 424 if expression.is_type("text"): 425 expression.set("this", exp.DataType.Type.VARCHAR) 426 precision = expression.args.get("expressions") 427 428 if not precision: 429 expression.append("expressions", exp.var("MAX")) 430 431 return super().datatype_sql(expression)
Redshift converts the TEXT
data type to VARCHAR(255)
by default when people more generally mean
VARCHAR of max length which is VARCHAR(max)
in Redshift. Therefore if we get a TEXT
data type
without precision we convert it to VARCHAR(max)
and if it does have precision then we just convert
TEXT
to VARCHAR
.
433 def alterset_sql(self, expression: exp.AlterSet) -> str: 434 exprs = self.expressions(expression, flat=True) 435 exprs = f" TABLE PROPERTIES ({exprs})" if exprs else "" 436 location = self.sql(expression, "location") 437 location = f" LOCATION {location}" if location else "" 438 file_format = self.expressions(expression, key="file_format", flat=True, sep=" ") 439 file_format = f" FILE FORMAT {file_format}" if file_format else "" 440 441 return f"SET{exprs}{location}{file_format}"
Inherited Members
- sqlglot.generator.Generator
- Generator
- NULL_ORDERING_SUPPORTED
- IGNORE_NULLS_IN_FUNC
- WRAP_DERIVED_VALUES
- CREATE_FUNCTION_RETURN_AS
- MATCHED_BY_SOURCE
- INTERVAL_ALLOWS_PLURAL_FORM
- LIMIT_FETCH
- LIMIT_ONLY_LITERALS
- GROUPINGS_SEP
- INDEX_ON
- QUERY_HINT_SEP
- IS_BOOL_ALLOWED
- DUPLICATE_KEY_UPDATE_WITH_SET
- LIMIT_IS_TOP
- RETURNING_END
- EXTRACT_ALLOWS_QUOTES
- ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
- UNNEST_WITH_ORDINALITY
- AGGREGATE_FILTER_SUPPORTED
- SEMI_ANTI_JOIN_WITH_SIDE
- COMPUTED_COLUMN_WITH_TYPE
- SUPPORTS_TABLE_COPY
- TABLESAMPLE_REQUIRES_PARENS
- TABLESAMPLE_KEYWORDS
- TABLESAMPLE_WITH_METHOD
- COLLATE_IS_FUNC
- DATA_TYPE_SPECIFIERS_ALLOWED
- ENSURE_BOOLS
- CTE_RECURSIVE_KEYWORD_REQUIRED
- SUPPORTS_SINGLE_ARG_CONCAT
- SUPPORTS_TABLE_ALIAS_COLUMNS
- UNPIVOT_ALIASES_ARE_IDENTIFIERS
- JSON_KEY_VALUE_PAIR_SEP
- INSERT_OVERWRITE
- SUPPORTS_CREATE_TABLE_LIKE
- JSON_PATH_BRACKETED_KEY_SUPPORTED
- JSON_PATH_SINGLE_QUOTE_ESCAPE
- SUPPORTS_TO_NUMBER
- SET_OP_MODIFIERS
- COPY_PARAMS_EQ_REQUIRED
- STAR_EXCEPT
- QUOTE_JSON_PATH
- PAD_FILL_PATTERN_IS_REQUIRED
- SUPPORTS_EXPLODING_PROJECTIONS
- SUPPORTS_UNIX_SECONDS
- ALTER_SET_WRAPPED
- NORMALIZE_EXTRACT_DATE_PARTS
- ARRAY_SIZE_NAME
- SUPPORTS_LIKE_QUANTIFIERS
- TIME_PART_SINGULARS
- TOKEN_MAPPING
- STRUCT_DELIMITER
- EXPRESSION_PRECEDES_PROPERTIES_CREATABLES
- WITH_SEPARATED_COMMENTS
- EXCLUDE_COMMENTS
- UNWRAPPED_INTERVAL_VALUES
- PARAMETERIZABLE_TEXT_TYPES
- EXPRESSIONS_WITHOUT_NESTED_CTES
- RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS
- SENTINEL_LINE_BREAK
- pretty
- identify
- normalize
- pad
- unsupported_level
- max_unsupported
- leading_comma
- max_text_width
- comments
- dialect
- normalize_functions
- unsupported_messages
- generate
- preprocess
- unsupported
- sep
- seg
- sanitize_comment
- maybe_comment
- wrap
- no_identify
- normalize_func
- indent
- sql
- uncache_sql
- cache_sql
- characterset_sql
- column_parts
- column_sql
- columnposition_sql
- columndef_sql
- columnconstraint_sql
- autoincrementcolumnconstraint_sql
- compresscolumnconstraint_sql
- generatedasidentitycolumnconstraint_sql
- generatedasrowcolumnconstraint_sql
- periodforsystemtimeconstraint_sql
- notnullcolumnconstraint_sql
- primarykeycolumnconstraint_sql
- uniquecolumnconstraint_sql
- createable_sql
- create_sql
- sequenceproperties_sql
- clone_sql
- describe_sql
- heredoc_sql
- prepend_ctes
- with_sql
- cte_sql
- tablealias_sql
- bitstring_sql
- hexstring_sql
- bytestring_sql
- unicodestring_sql
- rawstring_sql
- datatypeparam_sql
- directory_sql
- delete_sql
- drop_sql
- set_operation
- set_operations
- fetch_sql
- limitoptions_sql
- filter_sql
- hint_sql
- indexparameters_sql
- index_sql
- identifier_sql
- hex_sql
- lowerhex_sql
- inputoutputformat_sql
- national_sql
- partition_sql
- properties_sql
- root_properties
- properties
- with_properties
- locate_properties
- property_name
- property_sql
- likeproperty_sql
- fallbackproperty_sql
- journalproperty_sql
- freespaceproperty_sql
- checksumproperty_sql
- mergeblockratioproperty_sql
- datablocksizeproperty_sql
- blockcompressionproperty_sql
- isolatedloadingproperty_sql
- partitionboundspec_sql
- partitionedofproperty_sql
- lockingproperty_sql
- withdataproperty_sql
- withsystemversioningproperty_sql
- insert_sql
- introducer_sql
- kill_sql
- pseudotype_sql
- objectidentifier_sql
- onconflict_sql
- returning_sql
- rowformatdelimitedproperty_sql
- withtablehint_sql
- indextablehint_sql
- historicaldata_sql
- table_parts
- table_sql
- tablefromrows_sql
- tablesample_sql
- pivot_sql
- version_sql
- tuple_sql
- update_sql
- values_sql
- var_sql
- into_sql
- from_sql
- groupingsets_sql
- rollup_sql
- cube_sql
- group_sql
- having_sql
- connect_sql
- prior_sql
- join_sql
- lambda_sql
- lateral_op
- lateral_sql
- limit_sql
- offset_sql
- setitem_sql
- set_sql
- pragma_sql
- lock_sql
- literal_sql
- escape_str
- loaddata_sql
- null_sql
- boolean_sql
- order_sql
- withfill_sql
- cluster_sql
- distribute_sql
- sort_sql
- ordered_sql
- matchrecognizemeasure_sql
- matchrecognize_sql
- query_modifiers
- options_modifier
- for_modifiers
- queryoption_sql
- offset_limit_modifiers
- after_limit_modifiers
- select_sql
- schema_sql
- schema_columns_sql
- star_sql
- parameter_sql
- sessionparameter_sql
- subquery_sql
- qualify_sql
- prewhere_sql
- where_sql
- window_sql
- partition_by_sql
- windowspec_sql
- withingroup_sql
- between_sql
- bracket_offset_expressions
- all_sql
- any_sql
- exists_sql
- case_sql
- constraint_sql
- nextvaluefor_sql
- extract_sql
- trim_sql
- convert_concat_args
- concat_sql
- concatws_sql
- check_sql
- foreignkey_sql
- primarykey_sql
- if_sql
- jsonkeyvalue_sql
- jsonpath_sql
- json_path_part
- formatjson_sql
- formatphrase_sql
- jsonobject_sql
- jsonobjectagg_sql
- jsonarray_sql
- jsonarrayagg_sql
- jsoncolumndef_sql
- jsonschema_sql
- jsontable_sql
- openjsoncolumndef_sql
- openjson_sql
- in_sql
- in_unnest_op
- return_sql
- reference_sql
- anonymous_sql
- paren_sql
- neg_sql
- not_sql
- alias_sql
- pivotalias_sql
- aliases_sql
- atindex_sql
- attimezone_sql
- fromtimezone_sql
- add_sql
- and_sql
- or_sql
- xor_sql
- connector_sql
- bitwiseand_sql
- bitwiseleftshift_sql
- bitwisenot_sql
- bitwiseor_sql
- bitwiserightshift_sql
- bitwisexor_sql
- currentdate_sql
- collate_sql
- command_sql
- comment_sql
- mergetreettlaction_sql
- mergetreettl_sql
- transaction_sql
- commit_sql
- rollback_sql
- altercolumn_sql
- alterindex_sql
- alterdiststyle_sql
- altersortkey_sql
- alterrename_sql
- renamecolumn_sql
- alter_sql
- add_column_sql
- droppartition_sql
- addconstraint_sql
- addpartition_sql
- distinct_sql
- ignorenulls_sql
- respectnulls_sql
- havingmax_sql
- intdiv_sql
- dpipe_sql
- div_sql
- safedivide_sql
- overlaps_sql
- distance_sql
- dot_sql
- eq_sql
- propertyeq_sql
- escape_sql
- glob_sql
- gt_sql
- gte_sql
- is_sql
- like_sql
- ilike_sql
- similarto_sql
- lt_sql
- lte_sql
- mod_sql
- mul_sql
- neq_sql
- nullsafeeq_sql
- nullsafeneq_sql
- slice_sql
- sub_sql
- trycast_sql
- jsoncast_sql
- try_sql
- log_sql
- use_sql
- binary
- ceil_floor
- function_fallback_sql
- func
- format_args
- too_wide
- format_time
- expressions
- op_expressions
- naked_property
- tag_sql
- token_sql
- userdefinedfunction_sql
- joinhint_sql
- kwarg_sql
- when_sql
- whens_sql
- merge_sql
- tochar_sql
- tonumber_sql
- dictproperty_sql
- dictrange_sql
- dictsubproperty_sql
- duplicatekeyproperty_sql
- uniquekeyproperty_sql
- distributedbyproperty_sql
- oncluster_sql
- clusteredbyproperty_sql
- anyvalue_sql
- querytransform_sql
- indexconstraintoption_sql
- checkcolumnconstraint_sql
- indexcolumnconstraint_sql
- nvl2_sql
- comprehension_sql
- columnprefix_sql
- opclass_sql
- predict_sql
- forin_sql
- refresh_sql
- toarray_sql
- tsordstotime_sql
- tsordstotimestamp_sql
- tsordstodatetime_sql
- tsordstodate_sql
- unixdate_sql
- lastday_sql
- dateadd_sql
- arrayany_sql
- struct_sql
- partitionrange_sql
- truncatetable_sql
- convert_sql
- copyparameter_sql
- credentials_sql
- copy_sql
- semicolon_sql
- datadeletionproperty_sql
- maskingpolicycolumnconstraint_sql
- gapfill_sql
- scope_resolution
- scoperesolution_sql
- parsejson_sql
- rand_sql
- changes_sql
- pad_sql
- summarize_sql
- explodinggenerateseries_sql
- arrayconcat_sql
- converttimezone_sql
- json_sql
- jsonvalue_sql
- conditionalinsert_sql
- multitableinserts_sql
- oncondition_sql
- jsonextractquote_sql
- jsonexists_sql
- arrayagg_sql
- apply_sql
- grant_sql
- grantprivilege_sql
- grantprincipal_sql
- columns_sql
- overlay_sql
- todouble_sql
- string_sql
- median_sql
- overflowtruncatebehavior_sql
- unixseconds_sql
- arraysize_sql
- attach_sql
- detach_sql
- attachoption_sql
- featuresattime_sql
- watermarkcolumnconstraint_sql
- encodeproperty_sql
- includeproperty_sql
- xmlelement_sql
- xmlkeyvalueoption_sql
- partitionbyrangeproperty_sql
- partitionbyrangepropertydynamic_sql
- unpivotcolumns_sql
- analyzesample_sql
- analyzestatistics_sql
- analyzehistogram_sql
- analyzedelete_sql
- analyzelistchainedrows_sql
- analyzevalidate_sql
- analyze_sql
- xmltable_sql
- xmlnamespace_sql
- export_sql
- declare_sql
- declareitem_sql
- recursivewithsearch_sql
- parameterizedagg_sql
- anonymousaggfunc_sql
- combinedaggfunc_sql
- combinedparameterizedagg_sql
- show_sql
- get_put_sql
- translatecharacters_sql
- decodecase_sql
- semanticview_sql
- sqlglot.dialects.postgres.Postgres.Generator
- SINGLE_STRING_INTERVAL
- RENAME_TABLE_WITH_DB
- JOIN_HINTS
- TABLE_HINTS
- PARAMETER_TOKEN
- NAMED_PLACEHOLDER_TOKEN
- TABLESAMPLE_SIZE_IS_ROWS
- TABLESAMPLE_SEED_KEYWORD
- SUPPORTS_SELECT_INTO
- JSON_TYPE_REQUIRED_FOR_EXTRACTION
- SUPPORTS_UNLOGGED_TABLES
- LIKE_PROPERTY_INSIDE_SCHEMA
- SUPPORTS_WINDOW_EXCLUDE
- COPY_HAS_INTO_KEYWORD
- ARRAY_SIZE_DIM_REQUIRED
- SUPPORTED_JSON_PATH_PARTS
- PROPERTIES_LOCATION
- round_sql
- schemacommentproperty_sql
- commentcolumnconstraint_sql
- bracket_sql
- matchagainst_sql
- computedcolumnconstraint_sql
- isascii_sql
- currentschema_sql
- interval_sql
- placeholder_sql
- arraycontains_sql