Support postgres omitted interval span unit

Author: treysp

sqlglot/dialects/postgres.py

@@ -375,6 +375,8 @@ class Tokenizer(tokens.Tokenizer):
         VAR_SINGLE_TOKENS = {"$"}
 
     class Parser(parser.Parser):
+        SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT = True
+
         PROPERTY_PARSERS = {
             **parser.Parser.PROPERTY_PARSERS,
             "SET": lambda self: self.expression(exp.SetConfigProperty, this=self._parse_set()),

sqlglot/expressions.py

@@ -8561,6 +8561,10 @@ def parse_identifier(name: str | Identifier, dialect: DialectType = None) -> Ide
 
 INTERVAL_STRING_RE = re.compile(r"\s*(-?[0-9]+(?:\.[0-9]+)?)\s*([a-zA-Z]+)\s*")
 
+# Matches day-time interval strings that contain a number of days, a space,
+# and a time component in the format hh:[mm:[ss[.ff]]]
+INTERVAL_DAY_TIME_RE = re.compile(r"^\s*(-?[0-9]+)\s+(\d{1,2}:\d{0,2}(?::\d{0,2}(?:\.\d+)?)?)\s*$")
+
 
 def to_interval(interval: str | Literal) -> Interval:
     """Builds an interval expression from a string like '1 day' or '5 months'."""

sqlglot/generator.py

@@ -3275,14 +3275,19 @@ def in_unnest_op(self, unnest: exp.Unnest) -> str:
         return f"(SELECT {self.sql(unnest)})"
 
     def interval_sql(self, expression: exp.Interval) -> str:
-        unit = self.sql(expression, "unit")
+        unit_expression = expression.args.get("unit")
+        unit = self.sql(unit_expression) if unit_expression else ""
         if not self.INTERVAL_ALLOWS_PLURAL_FORM:
             unit = self.TIME_PART_SINGULARS.get(unit, unit)
         unit = f" {unit}" if unit else ""
 
         if self.SINGLE_STRING_INTERVAL:
             this = expression.this.name if expression.this else ""
-            return f"INTERVAL '{this}{unit}'" if this else f"INTERVAL{unit}"
+            if this:
+                if unit and isinstance(unit_expression, exp.IntervalSpan):
+                    return f"INTERVAL '{this}'{unit}"
+                return f"INTERVAL '{this}{unit}'"
+            return f"INTERVAL{unit}"
 
         this = self.sql(expression, "this")
         if this:

sqlglot/parser.py

@@ -1561,6 +1561,10 @@ def _parse_partitioned_by_bucket_or_truncate(self) -> t.Optional[exp.Expression]
     # Adding an ON TRUE, makes transpilation semantically correct for other dialects
     ADD_JOIN_ON_TRUE = False
 
+    # Whether INTERVAL spans with literal format '\d+ hh:[mm:[ss[.ff]]]'
+    # can omit the span unit `DAY TO MINUTE` or `DAY TO SECOND`
+    SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT = False
+
     __slots__ = (
         "error_level",
         "error_message_context",
@@ -5105,9 +5109,38 @@ def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Add | e
             self._retreat(index)
             return None
 
-        unit = self._parse_function() or (
-            not self._match(TokenType.ALIAS, advance=False)
-            and self._parse_var(any_token=True, upper=True)
+        # detect day-time interval span with omitted units:
+        #   INTERVAL '<days> <time with colon>' [maybe explicit span `unit TO unit`]
+        infer_interval_span_units = False
+        if (
+            this
+            and this.is_string
+            and self.INTERVAL_SPANS
+            and self.SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT
+        ):
+            day_time_format_literal = exp.INTERVAL_DAY_TIME_RE.match(this.name)
+            if day_time_format_literal:
+                index = self._index
+
+                # Var "TO" Var
+                first_unit = self._parse_var(any_token=True, upper=True)
+                second_unit = None
+                if first_unit and self._match_text_seq("TO"):
+                    second_unit = self._parse_var(any_token=True, upper=True)
+
+                self._retreat(index)
+                infer_interval_span_units = not (first_unit and second_unit)
+
+        unit = (
+            None
+            if infer_interval_span_units
+            else (
+                self._parse_function()
+                or (
+                    not self._match(TokenType.ALIAS, advance=False)
+                    and self._parse_var(any_token=True, upper=True)
+                )
+            )
         )
 
         # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
@@ -5124,7 +5157,27 @@ def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Add | e
             if len(parts) == 1:
                 this = exp.Literal.string(parts[0][0])
                 unit = self.expression(exp.Var, this=parts[0][1].upper())
-        if self.INTERVAL_SPANS and self._match_text_seq("TO"):
+
+            # infer DAY TO MINUTE/SECOND omitted span units
+            if (
+                self.INTERVAL_SPANS
+                and self.SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT
+                and day_time_format_literal
+            ):
+                time_part = day_time_format_literal.group(2)
+
+                if infer_interval_span_units:
+                    seconds_present = time_part.count(":") >= 2 or "." in time_part
+                    unit = self.expression(
+                        exp.IntervalSpan,
+                        this=exp.var("DAY"),
+                        expression=exp.var("SECOND" if seconds_present else "MINUTE"),
+                    )
+        if (
+            self.INTERVAL_SPANS
+            and self._match_text_seq("TO")
+            and not isinstance(unit, exp.IntervalSpan)
+        ):
             unit = self.expression(
                 exp.IntervalSpan, this=unit, expression=self._parse_var(any_token=True, upper=True)
             )

tests/dialects/test_postgres.py

@@ -1637,3 +1637,19 @@ def test_begin_transaction(self):
                     self.validate_identity(
                         f"BEGIN {keyword} {level}, {level}", f"BEGIN {level}, {level}"
                     ).assert_is(exp.Transaction)
+
+    def test_interval_span(self):
+        for time_str in ["1 01:", "1 01:", "1 01:00", "1 01:00"]:
+            self.validate_identity(f"INTERVAL '{time_str}'", f"INTERVAL '{time_str}' DAY TO MINUTE")
+            # explicit SECOND overrides inference to MINUTE
+            self.validate_identity(f"INTERVAL '{time_str}' DAY TO SECOND")
+
+        for time_str in ["1 01:01:", "1 01:01:", "1 01:01:01", "1 01:01:01.01"]:
+            self.validate_identity(f"INTERVAL '{time_str}'", f"INTERVAL '{time_str}' DAY TO SECOND")
+            # explicit MINUTE overrides inference to SECOND
+            self.validate_identity(f"INTERVAL '{time_str}' DAY TO MINUTE")
+
+        # Ensure AND is not consumed as a unit following an omitted-span interval
+        day_time_str = "a > INTERVAL '1 00:00' AND TRUE"
+        self.validate_identity(day_time_str, "a > INTERVAL '1 00:00' DAY TO MINUTE AND TRUE")
+        self.assertIsInstance(self.parse_one(day_time_str), exp.And)