add :as option to Ch ecto type

lib/ch.ex

@@ -89,7 +89,18 @@ defmodule Ch do
         opts[:raw] || opts[:type] ||
           raise ArgumentError, "keys :raw or :type not found in: #{inspect(opts)}"
 
-      Ch.Types.decode(clickhouse_type)
+      if as = opts[:as] do
+        as =
+          if is_binary(as) do
+            Ch.Types.decode(as)
+          else
+            as
+          end
+
+        {:as, clickhouse_type, as}
+      else
+        Ch.Types.decode(clickhouse_type)
+      end
     end
 
     @impl true
@@ -100,6 +111,7 @@ defmodule Ch do
       def load(value, _loader, unquote(type)), do: {:ok, value}
     end
 
+    def load(value, loader, {:as, _name, params}), do: load(value, loader, params)
     def load(value, _loader, params), do: Ecto.Type.load(base_type(params), value)
 
     @impl true
@@ -135,6 +147,7 @@ defmodule Ch do
       end
     end
 
+    def dump(value, dumper, {:as, _name, params}), do: dump(value, dumper, params)
     def dump(value, _dumper, params), do: Ecto.Type.dump(base_type(params), value)
 
     @impl true
@@ -178,6 +191,7 @@ defmodule Ch do
       end
     end
 
+    def cast(value, {:as, _name, params}), do: cast(value, params)
     def cast(value, params), do: Ecto.Type.cast(base_type(params), value)
 
     @doc false
@@ -220,6 +234,7 @@ defmodule Ch do
     def base_type(:polygon), do: {:array, base_type(:ring)}
     def base_type(:multipolygon), do: {:array, base_type(:polygon)}
 
+    def base_type({:as, _name, params}), do: base_type(params)
     def base_type({:parameterized, Ch, params}), do: base_type(params)
 
     defp process_tuple(types, values, mapper) when is_tuple(values) do

test/ch/ecto_type_test.exs

@@ -384,4 +384,38 @@ defmodule Ch.EctoTypeTest do
       assert {:ok, %Decimal{}} = Ecto.Type.load(type, 1.0)
     end
   end
+
+  describe "as" do
+    test "UInt8 as :boolean" do
+      assert {:parameterized, Ch, {:as, "UInt8", :boolean}} =
+               type = Ecto.ParameterizedType.init(Ch, type: "UInt8", as: :boolean)
+
+      assert Ecto.Type.type(type) == type
+      assert Ch.base_type(type) == :boolean
+
+      assert {:ok, true} = Ecto.Type.cast(type, true)
+      assert {:ok, false} = Ecto.Type.cast(type, false)
+      assert {:ok, true} = Ecto.Type.dump(type, true)
+      assert {:ok, false} = Ecto.Type.dump(type, false)
+      assert {:ok, true} = Ecto.Type.load(type, true)
+      assert {:ok, false} = Ecto.Type.load(type, false)
+    end
+
+    test "AggregateFunction as Decimal" do
+      assert {:parameterized, Ch,
+              {:as, "AggregateFunction(argMin, Decimal(18, 4), DateTime)", {:decimal, 18, 4}}} =
+               type =
+               Ecto.ParameterizedType.init(Ch,
+                 type: "AggregateFunction(argMin, Decimal(18, 4), DateTime)",
+                 as: "Decimal(18, 4)"
+               )
+
+      assert Ecto.Type.type(type) == type
+      assert Ch.base_type(type) == :decimal
+
+      assert {:ok, %Decimal{}} = Ecto.Type.cast(type, 1.0)
+      assert {:ok, %Decimal{}} = Ecto.Type.dump(type, 1.0)
+      assert {:ok, %Decimal{}} = Ecto.Type.load(type, 1.0)
+    end
+  end
 end