Merge remote-tracking branch 'origin/master' into ruslandoga-conductor/hardcore-types-ex-tests

# Conflicts:
#	lib/ch/types.ex
#	test/ch/types_test.exs

Author: ruslandoga

CHANGELOG.md

@@ -18,6 +18,7 @@
 - Add explicit request and response compression support through HTTP headers. `zstd` and `gzip` response bodies are decompressed automatically for decoded `RowBinaryWithNamesAndTypes` and error responses; raw successful responses are kept as received in `Ch.Result.data`.
 - Fix `Time64` RowBinary encoding for precisions below microseconds.
 - Fix RowBinary integer encoders to reject out-of-range `Int16`/`UInt16` and wider values instead of silently wrapping, with added property coverage through 256-bit integer types.
+- Fix `Ch.Types.encode/1` to reject empty `Enum8` and `Enum16` mappings instead of producing invalid type strings.
 
 ## 0.8.3 (2026-05-12)
 

README.md

@@ -32,49 +32,45 @@ Start a pool:
 {:ok, pool} = Ch.start_link(url: "http://localhost:8123")
 ```
 
-Run a query with named ClickHouse parameters:
+Run a query:
 
 ```elixir
-%Ch.Result{names: ["number"], rows: [[0], [1] | _rest]} =
+%Ch.Result{names: ["number"], rows: [[0], [1], [2]]} =
   Ch.query!(
     pool,
     "select number from numbers({limit:UInt32})",
-    %{"limit" => 100},
+    %{"limit" => 3},
     headers: [{"accept-encoding", "zstd"}]
   )
 ```
 
-Insert RowBinary data by encoding it explicitly:
+Create a table and insert RowBinaryWithNamesAndTypes data:
 
 ```elixir
-rows = [[1, "one"], [2, "two"]]
-types = ["UInt8", "String"]
-rowbinary = Ch.RowBinary.encode_rows(rows, types)
-
-Ch.query!(pool, [
-  "INSERT INTO events FORMAT RowBinary\n",
-  rowbinary
-])
-```
+session_id = "ch-demo-session"
 
-Compressed inserts use the same shape, with the whole request body compressed:
+Ch.query!(
+  pool,
+  "create temporary table demo(id UInt64, text String) engine Memory",
+  %{},
+  settings: %{"session_id" => session_id}
+)
 
-```elixir
-names = ["id", "name"]
-types = ["UInt8", "String"]
+names = ["id", "text"]
+types = ["UInt64", "String"]
 rows = [[1, "one"], [2, "two"]]
 
-payload =
-  :zstd.compress([
-    "INSERT INTO events FORMAT RowBinaryWithNamesAndTypes\n",
-    Ch.RowBinary.encode_names_and_types(names, types),
-    Ch.RowBinary.encode_rows(rows, types)
-  ])
+insert = [
+  "insert into demo format RowBinaryWithNamesAndTypes\n",
+  Ch.RowBinary.encode_names_and_types(names, types)
+  | Ch.RowBinary.encode_rows(rows, types)
+]
 
 Ch.query!(
   pool,
-  payload,
+  :zstd.compress(insert),
   %{},
+  settings: %{"session_id" => session_id},
   headers: [{"content-encoding", "zstd"}]
 )
 ```

lib/ch/types.ex

@@ -632,10 +632,18 @@ defmodule Ch.Types do
     ["DateTime64(", Integer.to_string(precision), ", '", encode_string(timezone), "')"]
   end
 
+  def encode({:enum8, []}) do
+    raise ArgumentError, "Enum8 requires at least one mapping"
+  end
+
   def encode({:enum8, mapping}) do
     ["Enum8('", encode_mapping(mapping), ?)]
   end
 
+  def encode({:enum16, []}) do
+    raise ArgumentError, "Enum16 requires at least one mapping"
+  end
+
   def encode({:enum16, mapping}) do
     ["Enum16('", encode_mapping(mapping), ?)]
   end
@@ -665,18 +673,14 @@ defmodule Ch.Types do
   defp encode_mapping([] = empty), do: empty
 
   defp encode_string(string) do
-    for <<char::utf8 <- string>> do
-      escape_string_char(char)
-    end
+    string
+    |> String.replace("\\", "\\\\")
+    |> String.replace("'", "\\'")
+    |> String.replace(<<0>>, "\\0")
+    |> String.replace("\b", "\\b")
+    |> String.replace("\f", "\\f")
+    |> String.replace("\n", "\\n")
+    |> String.replace("\r", "\\r")
+    |> String.replace("\t", "\\t")
   end
-
-  defp escape_string_char(?\0), do: "\\0"
-  defp escape_string_char(?\b), do: "\\b"
-  defp escape_string_char(?\f), do: "\\f"
-  defp escape_string_char(?\n), do: "\\n"
-  defp escape_string_char(?\r), do: "\\r"
-  defp escape_string_char(?\t), do: "\\t"
-  defp escape_string_char(?'), do: "\\'"
-  defp escape_string_char(?\\), do: "\\\\"
-  defp escape_string_char(char), do: <<char::utf8>>
 end

test/ch/faults_test.exs

@@ -4,10 +4,9 @@ defmodule Ch.FaultsTest do
   @socket_opts [:binary, {:active, true}, {:packet, :raw}]
 
   setup do
-    {:ok, clickhouse} = :gen_tcp.connect({127, 0, 0, 1}, 8123, @socket_opts)
     {:ok, listen} = :gen_tcp.listen(0, @socket_opts)
     {:ok, port} = :inet.port(listen)
-    {:ok, clickhouse: clickhouse, listen: listen, port: port}
+    {:ok, listen: listen, port: port}
   end
 
   test "returns transport errors when ClickHouse is unreachable", %{listen: listen, port: port} do
@@ -21,17 +20,20 @@ defmodule Ch.FaultsTest do
   end
 
   test "removes a timed out connection and reconnects on the next query", ctx do
-    %{port: port, listen: listen, clickhouse: clickhouse} = ctx
+    %{port: port, listen: listen} = ctx
     {:ok, pool} = Ch.start_link(url: "http://localhost:#{port}")
 
+    clickhouse = connect_clickhouse!()
+
     select =
       Task.async(fn ->
-        Ch.query(pool, "select 1 + 1", %{}, timeout: 100)
+        Ch.query(pool, "select 1 + 1", %{}, timeout: 500)
       end)
 
     {:ok, mint} = :gen_tcp.accept(listen)
     :ok = :gen_tcp.send(clickhouse, read_packets(mint))
     :ok = :gen_tcp.send(mint, first_byte(read_packets(clickhouse)))
+    :ok = :gen_tcp.close(clickhouse)
 
     assert {:error, %Mint.TransportError{reason: :timeout}} = Task.await(select)
 
@@ -40,26 +42,30 @@ defmodule Ch.FaultsTest do
         Ch.query(pool, "select 1 + 1", %{}, timeout: 1_000)
       end)
 
+    clickhouse = connect_clickhouse!()
     {:ok, mint} = :gen_tcp.accept(listen)
     :ok = :gen_tcp.send(clickhouse, read_packets(mint))
     :ok = :gen_tcp.send(mint, read_packets(clickhouse))
+    :ok = :gen_tcp.close(clickhouse)
 
     assert {:ok, %{rows: [[2]]}} = Task.await(select)
   end
 
   test "removes a closed connection and reconnects on the next query", ctx do
-    %{port: port, listen: listen, clickhouse: clickhouse} = ctx
+    %{port: port, listen: listen} = ctx
     {:ok, pool} = Ch.start_link(url: "http://localhost:#{port}")
 
     select =
       Task.async(fn ->
         Ch.query(pool, "select 1 + 1", %{}, timeout: 1_000)
       end)
 
+    clickhouse = connect_clickhouse!()
     {:ok, mint} = :gen_tcp.accept(listen)
     :ok = :gen_tcp.send(clickhouse, read_packets(mint))
     :ok = :gen_tcp.send(mint, first_byte(read_packets(clickhouse)))
     :ok = :gen_tcp.close(mint)
+    :ok = :gen_tcp.close(clickhouse)
 
     assert {:error, %Mint.TransportError{reason: :closed}} = Task.await(select)
 
@@ -68,13 +74,20 @@ defmodule Ch.FaultsTest do
         Ch.query(pool, "select 1 + 1", %{}, timeout: 1_000)
       end)
 
+    clickhouse = connect_clickhouse!()
     {:ok, mint} = :gen_tcp.accept(listen)
     :ok = :gen_tcp.send(clickhouse, read_packets(mint))
     :ok = :gen_tcp.send(mint, read_packets(clickhouse))
+    :ok = :gen_tcp.close(clickhouse)
 
     assert {:ok, %{rows: [[2]]}} = Task.await(select)
   end
 
+  defp connect_clickhouse! do
+    {:ok, clickhouse} = :gen_tcp.connect({127, 0, 0, 1}, 8123, @socket_opts)
+    clickhouse
+  end
+
   defp read_packets(socket) do
     receive do
       {:tcp, ^socket, packet} -> read_packets(socket, packet)
@@ -87,7 +100,7 @@ defmodule Ch.FaultsTest do
       {:tcp, ^socket, packet} -> read_packets(socket, [acc | packet])
       {:tcp_closed, ^socket} -> acc
     after
-      10 -> acc
+      50 -> acc
     end
   end
 

test/ch/http_test.exs

@@ -21,8 +21,7 @@ defmodule Ch.HTTPTest do
       {:deadline, round_tripped_timestamp} =
         deadline |> Ch.HTTP.to_timeout() |> Ch.HTTP.to_deadline()
 
-      assert round_tripped_timestamp <= original_timestamp
-      assert round_tripped_timestamp >= original_timestamp - 50
+      assert_in_delta round_tripped_timestamp, original_timestamp, 50
     end
   end
 end