python/sqlglot
1
0
Fork 0
Code Issues Activity

Adding upstream version 25.16.1.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-13 21:52:21 +01:00
parent a500eebbbb
commit 1341bc6477
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
110 changed files with 75353 additions and 68092 deletions
Download patch file Download diff file Expand all files Collapse all files

40
sqlglot/dialects/postgres.py
View file

@ -166,7 +166,7 @@ def _serial_to_generated(expression: exp.Expression) -> exp.Expression:
return expression
def _build_generate_series(args: t.List) -> exp.GenerateSeries:
def _build_generate_series(args: t.List) -> exp.ExplodingGenerateSeries:
# The goal is to convert step values like '1 day' or INTERVAL '1 day' into INTERVAL '1' day
# Note: postgres allows calls with just two arguments -- the "step" argument defaults to 1
step = seq_get(args, 2)
@ -176,7 +176,7 @@ def _build_generate_series(args: t.List) -> exp.GenerateSeries:
elif isinstance(step, exp.Interval) and not step.args.get("unit"):
args[2] = exp.to_interval(step.this.this)
return exp.GenerateSeries.from_arg_list(args)
return exp.ExplodingGenerateSeries.from_arg_list(args)
def _build_to_timestamp(args: t.List) -> exp.UnixToTime | exp.StrToTime:
@ -440,7 +440,7 @@ class Postgres(Dialect):
self._match(TokenType.COMMA)
value = self._parse_bitwise()
if part and part.is_string:
if part and isinstance(part, (exp.Column, exp.Literal)):
part = exp.var(part.name)
return self.expression(exp.Extract, this=part, expression=value)
@ -466,6 +466,7 @@ class Postgres(Dialect):
MULTI_ARG_DISTINCT = False
CAN_IMPLEMENT_ARRAY_ANY = True
COPY_HAS_INTO_KEYWORD = False
ARRAY_CONCAT_IS_VAR_LEN = False
SUPPORTED_JSON_PATH_PARTS = {
exp.JSONPathKey,
@ -487,12 +488,7 @@ class Postgres(Dialect):
TRANSFORMS = {
**generator.Generator.TRANSFORMS,
exp.AnyValue: any_value_to_max_sql,
exp.Array: lambda self, e: (
f"{self.normalize_func('ARRAY')}({self.sql(e.expressions[0])})"
if isinstance(seq_get(e.expressions, 0), exp.Select)
else f"{self.normalize_func('ARRAY')}[{self.expressions(e, flat=True)}]"
),
exp.ArrayConcat: rename_func("ARRAY_CAT"),
exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CAT"),
exp.ArrayContainsAll: lambda self, e: self.binary(e, "@>"),
exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
exp.ArrayFilter: filter_array_using_unnest,
@ -507,6 +503,7 @@ class Postgres(Dialect):
exp.DateStrToDate: datestrtodate_sql,
exp.DateSub: _date_add_sql("-"),
exp.Explode: rename_func("UNNEST"),
exp.ExplodingGenerateSeries: rename_func("GENERATE_SERIES"),
exp.GroupConcat: _string_agg_sql,
exp.IntDiv: rename_func("DIV"),
exp.JSONExtract: _json_extract_sql("JSON_EXTRACT_PATH", "->"),
@ -587,21 +584,32 @@ class Postgres(Dialect):
def unnest_sql(self, expression: exp.Unnest) -> str:
if len(expression.expressions) == 1:
arg = expression.expressions[0]
if isinstance(arg, exp.GenerateDateArray):
generate_series: exp.Expression = exp.GenerateSeries(**arg.args)
if isinstance(expression.parent, (exp.From, exp.Join)):
generate_series = (
exp.select("value::date")
.from_(generate_series.as_("value"))
.subquery(expression.args.get("alias") or "_unnested_generate_series")
)
return self.sql(generate_series)
from sqlglot.optimizer.annotate_types import annotate_types
this = annotate_types(expression.expressions[0])
this = annotate_types(arg)
if this.is_type("array<json>"):
while isinstance(this, exp.Cast):
this = this.this
arg = self.sql(exp.cast(this, exp.DataType.Type.JSON))
arg_as_json = self.sql(exp.cast(this, exp.DataType.Type.JSON))
alias = self.sql(expression, "alias")
alias = f" AS {alias}" if alias else ""
if expression.args.get("offset"):
self.unsupported("Unsupported JSON_ARRAY_ELEMENTS with offset")
return f"JSON_ARRAY_ELEMENTS({arg}){alias}"
return f"JSON_ARRAY_ELEMENTS({arg_as_json}){alias}"
return super().unnest_sql(expression)
@ -646,3 +654,11 @@ class Postgres(Dialect):
return self.sql(this)
return super().cast_sql(expression, safe_prefix=safe_prefix)
def array_sql(self, expression: exp.Array) -> str:
exprs = expression.expressions
return (
f"{self.normalize_func('ARRAY')}({self.sql(exprs[0])})"
if isinstance(seq_get(exprs, 0), exp.Select)
else f"{self.normalize_func('ARRAY')}[{self.expressions(expression, flat=True)}]"
)