Support infinite intervals (#759)

Author: greg-rychlewski

lib/postgrex/extensions/interval.ex

@@ -3,15 +3,21 @@ defmodule Postgrex.Extensions.Interval do
   import Postgrex.BinaryUtils, warn: false
   use Postgrex.BinaryExtension, send: "interval_send"
 
+  @int64_max 9_223_372_036_854_775_807
+  @int64_min -9_223_372_036_854_775_808
+  @int32_max 2_147_483_647
+  @int32_min -2_147_483_648
+
   def init(opts) do
-    case Keyword.get(opts, :interval_decode_type, Postgrex.Interval) do
-      type when type in [Postgrex.Interval, Duration] ->
-        type
+    infinity? = Keyword.get(opts, :allow_infinite_intervals, false)
+    type = Keyword.get(opts, :interval_decode_type, Postgrex.Interval)
 
-      other ->
-        raise ArgumentError,
-              "#{inspect(other)} is not valid for `:interval_decode_type`. Please use either `Postgrex.Interval` or `Duration`"
+    if type not in [Postgrex.Interval, Duration] do
+      raise ArgumentError,
+            "#{inspect(type)} is not valid for `:interval_decode_type`. Please use either `Postgrex.Interval` or `Duration`"
     end
+
+    {type, infinity?}
   end
 
   if Code.ensure_loaded?(Duration) do
@@ -22,8 +28,18 @@ defmodule Postgrex.Extensions.Interval do
     # nil: coming from a super type that does not pass modifier for sub-type
     @unspecified_precision [0xFFFF, nil]
 
-    def encode(_) do
+    def encode({_type, infinity?}) do
       quote location: :keep do
+        :inf ->
+          if unquote(infinity?),
+            do: unquote(__MODULE__).infinity_binary(:inf),
+            else: unquote(__MODULE__).raise_encode_infinity(:inf)
+
+        :"-inf" ->
+          if unquote(infinity?),
+            do: unquote(__MODULE__).infinity_binary(:"-inf"),
+            else: unquote(__MODULE__).raise_encode_infinity(:"-inf")
+
         %Postgrex.Interval{months: months, days: days, secs: seconds, microsecs: microseconds} ->
           microseconds = 1_000_000 * seconds + microseconds
           <<16::int32(), microseconds::int64(), days::int32(), months::int32()>>
@@ -49,22 +65,31 @@ defmodule Postgrex.Extensions.Interval do
       end
     end
 
-    def decode(type) do
+    def decode({type, infinity?}) do
       quote location: :keep, generated: true do
         <<16::int32(), microseconds::int64(), days::int32(), months::int32()>> ->
           unquote(__MODULE__).decode_interval(
             microseconds,
             days,
             months,
             var!(mod),
-            unquote(type)
+            unquote(type),
+            unquote(infinity?)
           )
       end
     end
 
     ## Helpers
 
-    def decode_interval(microseconds, days, months, _type_mod, Postgrex.Interval) do
+    def decode_interval(@int64_max, @int32_max, @int32_max, _type_mod, _struct, infinity?) do
+      if infinity?, do: :inf, else: raise_decode_infinity("infinity")
+    end
+
+    def decode_interval(@int64_min, @int32_min, @int32_min, _type_mod, _struct, infinity?) do
+      if infinity?, do: :"-inf", else: raise_decode_infinity("-infinity")
+    end
+
+    def decode_interval(microseconds, days, months, _type_mod, Postgrex.Interval, _infinity?) do
       seconds = div(microseconds, 1_000_000)
       microseconds = rem(microseconds, 1_000_000)
 
@@ -76,7 +101,7 @@ defmodule Postgrex.Extensions.Interval do
       }
     end
 
-    def decode_interval(microseconds, days, months, type_mod, Duration) do
+    def decode_interval(microseconds, days, months, type_mod, Duration, _infinity?) do
       seconds = div(microseconds, 1_000_000)
       microseconds = rem(microseconds, 1_000_000)
       precision = if type_mod, do: type_mod &&& unquote(@precision_mask)
@@ -94,8 +119,18 @@ defmodule Postgrex.Extensions.Interval do
       )
     end
   else
-    def encode(_) do
+    def encode({_type, infinity?}) do
       quote location: :keep do
+        :inf ->
+          if unquote(infinity?),
+            do: unquote(__MODULE__).infinity_binary(:inf),
+            else: unquote(__MODULE__).raise_encode_infinity(:inf)
+
+        :"-inf" ->
+          if unquote(infinity?),
+            do: unquote(__MODULE__).infinity_binary(:"-inf"),
+            else: unquote(__MODULE__).raise_encode_infinity(:"-inf")
+
         %Postgrex.Interval{months: months, days: days, secs: seconds, microsecs: microseconds} ->
           microseconds = 1_000_000 * seconds + microseconds
           <<16::int32(), microseconds::int64(), days::int32(), months::int32()>>
@@ -105,16 +140,30 @@ defmodule Postgrex.Extensions.Interval do
       end
     end
 
-    def decode(_) do
+    def decode({_type, infinity?}) do
       quote location: :keep do
         <<16::int32(), microseconds::int64(), days::int32(), months::int32()>> ->
-          unquote(__MODULE__).decode_interval(microseconds, days, months, Postgrex.Interval)
+          unquote(__MODULE__).decode_interval(
+            microseconds,
+            days,
+            months,
+            Postgrex.Interval,
+            unquote(infinity?)
+          )
       end
     end
 
     ## Helpers
 
-    def decode_interval(microseconds, days, months, Postgrex.Interval) do
+    def decode_interval(@int64_max, @int32_max, @int32_max, _struct, infinity?) do
+      if infinity?, do: :inf, else: raise_decode_infinity("infinity")
+    end
+
+    def decode_interval(@int64_min, @int32_min, @int32_min, _struct, infinity?) do
+      if infinity?, do: :"-inf", else: raise_decode_infinity("-infinity")
+    end
+
+    def decode_interval(microseconds, days, months, Postgrex.Interval, _infinity?) do
       seconds = div(microseconds, 1_000_000)
       microseconds = rem(microseconds, 1_000_000)
 
@@ -126,4 +175,38 @@ defmodule Postgrex.Extensions.Interval do
       }
     end
   end
+
+  def infinity_binary(:inf) do
+    <<16::int32(), @int64_max::int64(), @int32_max::int32(), @int32_max::int32()>>
+  end
+
+  def infinity_binary(:"-inf") do
+    <<16::int32(), @int64_min::int64(), @int32_min::int32(), @int32_min::int32()>>
+  end
+
+  def raise_encode_infinity(type) do
+    raise ArgumentError, """
+    got query parameter value of `#{inspect(type)}`. If you want to support infinite intervals \
+    in your application, you can enable them by defining your own types:
+
+        Postgrex.Types.define(MyApp.PostgrexTypes, [], allow_infinite_intervals: true)
+
+    And then configuring your database to use it:
+
+        types: MyApp.PostgrexTypes
+    """
+  end
+
+  defp raise_decode_infinity(type) do
+    raise ArgumentError, """
+    got \"#{type}\" from PostgreSQL. If you want to support infinite intervals \
+    in your application, you can enable them by defining your own types:
+
+        Postgrex.Types.define(MyApp.PostgrexTypes, [], allow_infinite_intervals: true)
+
+    And then configuring your database to use it:
+
+        types: MyApp.PostgrexTypes
+    """
+  end
 end

lib/postgrex/types.ex

@@ -316,7 +316,11 @@ defmodule Postgrex.Types do
 
     * `:allow_infinite_timestamps` - A boolean controlling whether or not
       the built-in extensions `timestamp` and `timestamptz` will allow
-      a value of infinity to be decoded. Defaults to `false`.
+      infinite values (`:inf`/`:"-inf"`) to be decoded. Defaults to `false`.
+
+    * `:allow_infinite_intervals` - A boolean controlling whether or not
+      the built-in extension `interval` will allow infinite values (`:inf`/`:"-inf"`)
+      to be encoded and decoded. Defaults to `false`.
 
     * `:interval_decode_type` - The struct that intervals will be decoded
       into. Either `Postgrex.Interval` or `Duration` (Elixir 1.17.0+ only).

test/query_test.exs

@@ -4,7 +4,10 @@ defmodule QueryTest do
   import ExUnit.CaptureLog
   alias Postgrex, as: P
 
-  Postgrex.Types.define(Postgrex.ElixirDurationTypes, [], interval_decode_type: Duration)
+  Postgrex.Types.define(Postgrex.ElixirDurationTypes, [],
+    interval_decode_type: Duration,
+    allow_infinite_intervals: true
+  )
 
   setup context do
     opts = [
@@ -141,6 +144,29 @@ defmodule QueryTest do
              query("SELECT interval '10240000 microseconds'", [])
   end
 
+  @tag min_pg_version: "17.0"
+  test "decode infinite interval" do
+    opts = [database: "postgrex_test", backoff_type: :stop, types: Postgrex.ElixirDurationTypes]
+    {:ok, pid} = P.start_link(opts)
+
+    assert P.query!(pid, "SELECT 'infinity'::interval", []).rows == [[:inf]]
+    assert P.query!(pid, "SELECT '-infinity'::interval", []).rows == [[:"-inf"]]
+  end
+
+  @tag min_pg_version: "17.0"
+  test "decode infinite interval raise when option not specified" do
+    opts = [database: "postgrex_test", backoff_type: :stop]
+    {:ok, pid} = P.start_link(opts)
+
+    assert_raise ArgumentError, ~r/got "infinity" from PostgreSQL/, fn ->
+      P.query(pid, "SELECT 'infinity'::interval", [])
+    end
+
+    assert_raise ArgumentError, ~r/got "-infinity" from PostgreSQL/, fn ->
+      P.query(pid, "SELECT '-infinity'::interval", [])
+    end
+  end
+
   if Version.match?(System.version(), ">= 1.17.0") do
     test "decode interval with Elixir Duration" do
       opts = [database: "postgrex_test", backoff_type: :stop, types: Postgrex.ElixirDurationTypes]
@@ -1009,6 +1035,29 @@ defmodule QueryTest do
              ])
   end
 
+  @tag min_pg_version: "17.0"
+  test "encode infinite interval" do
+    opts = [database: "postgrex_test", backoff_type: :stop, types: Postgrex.ElixirDurationTypes]
+    {:ok, pid} = P.start_link(opts)
+
+    assert P.query!(pid, "SELECT $1::interval", [:inf]).rows == [[:inf]]
+    assert P.query!(pid, "SELECT $1::interval", [:"-inf"]).rows == [[:"-inf"]]
+  end
+
+  @tag min_pg_version: "17.0"
+  test "encode infinite interval raise when option not specified" do
+    opts = [database: "postgrex_test", backoff_type: :stop]
+    {:ok, pid} = P.start_link(opts)
+
+    assert_raise ArgumentError, ~r/got query parameter value of `:inf`/, fn ->
+      P.query(pid, "SELECT $1::interval", [:inf])
+    end
+
+    assert_raise ArgumentError, ~r/got query parameter value of `:"-inf"`/, fn ->
+      P.query(pid, "SELECT $1::interval", [:"-inf"])
+    end
+  end
+
   if Version.match?(System.version(), ">= 1.17.0") do
     test "encode interval with Elixir duration", context do
       assert [[%Postgrex.Interval{months: 0, days: 0, secs: 0, microsecs: 0}]] =

test/test_helper.exs

@@ -72,7 +72,7 @@ replication_exclude =
   end
 
 version_exclude =
-  [{8, 4}, {9, 0}, {9, 1}, {9, 2}, {9, 3}, {9, 4}, {9, 5}, {10, 0}, {13, 0}, {14, 0}]
+  [{8, 4}, {9, 0}, {9, 1}, {9, 2}, {9, 3}, {9, 4}, {9, 5}, {10, 0}, {13, 0}, {14, 0}, {17, 0}]
   |> Enum.filter(fn x -> x > pg_version end)
   |> Enum.map(fn {major, minor} -> {:min_pg_version, "#{major}.#{minor}"} end)