continue

Author: ruslandoga

lib/ch/row_binary.ex

@@ -596,6 +596,8 @@ defmodule Ch.RowBinary do
   defp decoding_type({:datetime64 = t, p}), do: {t, time_unit(p), _tz = nil}
   defp decoding_type({:datetime64 = t, p, tz}), do: {t, time_unit(p), tz}
 
+  defp decoding_type({:time64 = t, p}), do: {t, time_unit(p)}
+
   defp decoding_type({e, mappings}) when e in [:enum8, :enum16] do
     {e, Map.new(mappings, fn {k, v} -> {v, k} end)}
   end
@@ -885,6 +887,11 @@ defmodule Ch.RowBinary do
         t = Time.from_seconds_after_midnight(s)
         decode_rows(types_rest, bin, [t | row], rows, types)
 
+      {:time64, time_unit} ->
+        <<ticks::64-little-signed, bin::bytes>> = bin
+        t = ticks |> DateTime.from_unix!(time_unit) |> DateTime.to_time()
+        decode_rows(types_rest, bin, [t | row], rows, types)
+
       {:datetime, timezone} ->
         <<s::32-little, bin::bytes>> = bin
 

lib/ch/types.ex

@@ -24,7 +24,7 @@ defmodule Ch.Types do
       {"DateTime64", :datetime64, [:int, :string]},
       {"DateTime", :datetime, [:string]},
       # {"DateTime", :datetime, []},
-      {"Time64", :time64, []},
+      {"Time64", :time64, [:int]},
       {"Time", :time, []},
       {"Date32", :date32, []},
       {"Date", :date, []},
@@ -445,6 +445,7 @@ defmodule Ch.Types do
   defp build_type(:decimal128 = d, [s]), do: {d, s}
   defp build_type(:decimal256 = d, [s]), do: {d, s}
   defp build_type(:decimal = d, [s, p]), do: {d, p, s}
+  defp build_type(:time64 = t, [precision]), do: {t, precision}
 
   defp build_enum_mapping(mapping) do
     mapping |> :lists.reverse() |> Enum.chunk_every(2) |> Enum.map(fn [k, v] -> {k, v} end)

test/ch/query_test.exs

@@ -99,6 +99,60 @@ defmodule Ch.QueryTest do
              ]
     end
 
+    test "decode time64", %{conn: conn} do
+      settings = [enable_time_time64_type: 1]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(0)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(1)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.1]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(2)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.12]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(3)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.123]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(4)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.1234]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(5)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.12345]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(6)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.123456]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(7)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.123456]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(8)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.123456]]
+               ]
+
+      assert Ch.query!(conn, "SELECT '12:34:56.123456789'::time64(9)", [], settings: settings).rows ==
+               [
+                 [~T[12:34:56.123456]]
+               ]
+    end
+
     test "decode arrays", %{conn: conn} do
       assert [[[]]] = Ch.query!(conn, "SELECT []").rows
       assert [[[1]]] = Ch.query!(conn, "SELECT [1]").rows