Fix encoding for decimals in scientific notation (#165)

* Add support for decimals using scientific notation

* Use actual sign value to be more explicit

* Extract into function

* Create schema before using it

* Raise error with invalid sign value

* Add test cases

* Fix typo

Author: kevinkoltz

lib/tds/types.ex

@@ -687,16 +687,15 @@ defmodule Tds.Types do
 
   # Decimal
   def decode_decimal(precision, scale, <<sign::int8(), value::binary>>) do
+    set_decimal_precision(precision)
+
     size = byte_size(value)
     <<value::little-size(size)-unit(8)>> = value
 
-    Decimal.Context.get()
-    |> Map.put(:precision, precision)
-    |> Decimal.Context.set()
-
     case sign do
       0 -> Decimal.new(-1, value, -scale)
-      _ -> Decimal.new(1, value, -scale)
+      1 -> Decimal.new(1, value, -scale)
+      _ -> raise ArgumentError, "Sign value out of range. Expected 0 or 1, got #{inspect(sign)}"
     end
   end
 
@@ -878,9 +877,7 @@ defmodule Tds.Types do
   end
 
   def encode_decimal_type(%Parameter{value: value}) do
-    d_ctx = Decimal.Context.get()
-    d_ctx = %{d_ctx | precision: 38}
-    Decimal.Context.set(d_ctx)
+    set_decimal_precision(38)
 
     value_list =
       value
@@ -933,9 +930,7 @@ defmodule Tds.Types do
   end
 
   def encode_float_type(%Parameter{value: %Decimal{} = value}) do
-    d_ctx = Decimal.Context.get()
-    d_ctx = %{d_ctx | precision: 38}
-    Decimal.Context.set(d_ctx)
+    set_decimal_precision(38)
 
     value_list =
       value
@@ -1124,9 +1119,7 @@ defmodule Tds.Types do
   end
 
   def encode_decimal_descriptor(%Parameter{value: %Decimal{} = dec}) do
-    d_ctx = Decimal.Context.get()
-    d_ctx = %{d_ctx | precision: 38}
-    Decimal.Context.set(d_ctx)
+    set_decimal_precision(38)
 
     value_list =
       dec
@@ -1284,9 +1277,7 @@ defmodule Tds.Types do
 
   # decimal
   def encode_data(@tds_data_type_decimaln, %Decimal{} = value, attr) do
-    d_ctx = Decimal.Context.get()
-    d_ctx = %{d_ctx | precision: 38}
-    Decimal.Context.set(d_ctx)
+    set_decimal_precision(38)
     precision = attr[:precision]
 
     d =
@@ -1300,12 +1291,12 @@ defmodule Tds.Types do
         -1 -> 0
       end
 
-    d_abs = Decimal.abs(d)
-
-    value = d_abs.coef
-
     value_binary =
       value
+      |> Decimal.abs()
+      |> Decimal.to_string(:normal)
+      |> String.replace(".", "")
+      |> String.to_integer()
       |> :binary.encode_unsigned(:little)
 
     value_size = byte_size(value_binary)
@@ -1318,8 +1309,8 @@ defmodule Tds.Types do
         precision <= 38 -> 16
       end
 
-    {byte_len, padding} = {len, len - value_size}
-    byte_len = byte_len + 1
+    padding = len - value_size
+    byte_len = len + 1
     value_binary = value_binary <> <<0::size(padding)-unit(8)>>
     <<byte_len>> <> <<sign>> <> value_binary
   end
@@ -1883,4 +1874,10 @@ defmodule Tds.Types do
     data = <<type, 0x07>>
     {type, data, scale: 7}
   end
+
+  defp set_decimal_precision(precision) do
+    Decimal.Context.get()
+    |> Map.put(:precision, precision)
+    |> Decimal.Context.set()
+  end
 end

test/test_helper.exs

@@ -131,13 +131,14 @@ end
   CREATE TABLE [uniques] ([id] int NOT NULL, CONSTRAINT UIX_uniques_id UNIQUE([id]))
   """)
 
-{"Changed database context to 'test'." <> _, 0} =
+{"", 0} =
   Tds.TestHelper.sqlcmd(opts, """
-  USE test
-  GO
-  CREATE SCHEMA test;
+  IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'test')
+  EXEC('CREATE SCHEMA [test]')
   """)
 
+{"Changed database context to 'test'." <> _, 0} = Tds.TestHelper.sqlcmd(opts, "USE test;")
+
 # :dbg.start()
 # :dbg.tracer()
 # :dbg.p(:all,:c)

test/types/types_test.exs

@@ -0,0 +1,236 @@
+defmodule Tds.TypesTest do
+  use ExUnit.Case, async: false
+
+  alias Tds.Parameter
+
+  import Tds.TestHelper
+
+  require Logger
+
+  @tds_data_type_decimaln 0x6A
+
+  setup do
+    {:ok, pid} = Tds.start_link(opts())
+
+    {:ok, [pid: pid]}
+  end
+
+  defp create_table(context) do
+    precision = context[:precision] || 10
+    scale = context[:scale] || 4
+
+    if not is_integer(precision) do
+      raise ArgumentError, "precision must be an integer"
+    end
+
+    if not is_integer(scale) do
+      raise ArgumentError, "scale must be an integer"
+    end
+
+    query("DROP TABLE IF EXISTS foo", [])
+    query("CREATE TABLE foo (col DECIMAL(#{precision}, #{scale}) NULL)", [])
+  end
+
+  @spec insert_decimal(Decimal.t() | nil, map) :: Decimal.t()
+  defp insert_decimal(value, context) do
+    query("TRUNCATE TABLE foo", [])
+
+    :ok =
+      query("INSERT INTO foo (col) VALUES (@1)", [
+        %Parameter{name: "@1", value: value, type: :decimal}
+      ])
+
+    {:ok, result} = Tds.query(context[:pid], "SELECT col FROM foo", [])
+    %Tds.Result{rows: [[value]]} = result
+    value
+  end
+
+  describe "encode_data/3" do
+    test "encodes decimal type", _context do
+      value = Decimal.new("1000")
+      attr = [precision: 8, scale: 4]
+
+      # assert <<5, 1, 128, 150, 152, 0>> =
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 1
+      assert <<232, 3, 0, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 1000
+    end
+
+    test "encodes decimal type with scientific notation", _context do
+      value = Decimal.new("1E+3")
+      attr = [precision: 8, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 1
+      assert <<232, 3, 0, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 1000
+    end
+
+    # Decimal.new("-1E+3")
+    test "encodes negative decimal with scientific notation", _context do
+      value = Decimal.new("-1E+3")
+      attr = [precision: 8, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 0
+      assert <<232, 3, 0, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 1000
+    end
+
+    test "encodes decimal type with precision", _context do
+      value = Decimal.new("1000.0000")
+      attr = [precision: 8, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 1
+      assert <<128, 150, 152, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 10_000_000
+    end
+
+    test "encodes negative decimal", _context do
+      value = Decimal.new("-1000.0000")
+      attr = [precision: 8, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 0
+      assert <<128, 150, 152, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 10_000_000
+    end
+
+    test "encodes decimal type for 1000.1234", _context do
+      value = Decimal.new("1000.1234")
+      attr = [precision: 8, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 1
+      assert <<82, 155, 152, 0>> = value_binary
+      assert :binary.decode_unsigned(value_binary, :little) == 10_001_234
+    end
+
+    test "encodes very large decimal", _context do
+      value = Decimal.new("9999999999.9999")
+      attr = [precision: 14, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 9
+      assert sign == 1
+      assert :binary.decode_unsigned(value_binary, :little) == 99_999_999_999_999
+    end
+
+    test "encodes very small decimal", _context do
+      value = Decimal.new("0.0001")
+      attr = [precision: 5, scale: 4]
+
+      assert <<byte_len>> <> <<sign>> <> value_binary =
+               Tds.Types.encode_data(@tds_data_type_decimaln, value, attr)
+
+      assert byte_len == 5
+      assert sign == 1
+      assert :binary.decode_unsigned(value_binary, :little) == 1
+    end
+  end
+
+  describe "inserting decimal values into the database" do
+    setup :create_table
+
+    @tag precision: 10, scale: 4
+    test "inserts various decimal values", context do
+      assert insert_decimal(Decimal.new("1000"), context) == Decimal.new("1000.0000")
+      assert insert_decimal(Decimal.new("1000.0000"), context) == Decimal.new("1000.0000")
+      assert insert_decimal(Decimal.new("1000.1234"), context) == Decimal.new("1000.1234")
+      assert insert_decimal(Decimal.new("-1000.0000"), context) == Decimal.new("-1000.0000")
+
+      # Decimals can be scientific notation when converted from float:
+      # iex> Decimal.from_float(1000.0)
+      # Decimal.new("1E+3")
+      assert insert_decimal(Decimal.new("1E+3"), context) == Decimal.new("1000.0000")
+      assert insert_decimal(Decimal.new("-1E+3"), context) == Decimal.new("-1000.0000")
+    end
+
+    @tag precision: 5, scale: 2
+    test "decodes decimal type with precision 5 and scale 2", context do
+      assert insert_decimal(Decimal.new("123.45"), context) == Decimal.new("123.45")
+      assert insert_decimal(Decimal.new("-123.45"), context) == Decimal.new("-123.45")
+    end
+
+    @tag precision: 10, scale: 5
+    test "decodes decimal type to 99999.99999", context do
+      assert insert_decimal(Decimal.new("99999.99999"), context) == Decimal.new("99999.99999")
+    end
+
+    @tag precision: 2, scale: 1
+    test "decodes decimal type to 9.9", context do
+      assert insert_decimal(Decimal.new("9.9"), context) == Decimal.new("9.9")
+    end
+
+    @tag precision: 38, scale: 0
+    test "decodes to exact value with 0 scale", context do
+      value = Decimal.new("99999999999999999999999999999999999999")
+      assert insert_decimal(value, context) == value
+    end
+
+    @tag precision: 5, scale: 2
+    test "decodes to NULL", context do
+      assert insert_decimal(nil, context) == nil
+    end
+
+    @tag precision: 5, scale: 2
+    test "rounds up fractional parts", context do
+      assert insert_decimal(Decimal.new("123.456"), context) == Decimal.new("123.46")
+      assert insert_decimal(Decimal.new("123.454"), context) == Decimal.new("123.45")
+      assert insert_decimal(Decimal.new("-0.00001"), context) == Decimal.new("0.00")
+    end
+
+    @tag precision: 2, scale: 1, capture_log: true
+    test "raises an error with truncated value (cannot round non-fractional parts)", context do
+      value = Decimal.new("9.99")
+      # %Tds.Error{message: nil, mssql: %{state: 8, number: 8115, line_number:
+      # 1, msg_text: \"Arithmetic overflow error converting numeric to data type numeric.\",
+      # server_name: \"04e0392f6c76\", class: 16, proc_name: \"\"}}
+      message = ~r/Arithmetic overflow error converting numeric to data type numeric/
+      assert_raise MatchError, message, fn -> insert_decimal(value, context) end
+    end
+
+    # Maximum precision and scale for SQL Server
+    # https://learn.microsoft.com/en-us/sql/t-sql/data-types/precision-scale-and-length-transact-sql?view=sql-server-ver16#remarks
+    @tag precision: 38, scale: 18
+    test "inserts very large decimal", context do
+      # 38 digits
+      value = Decimal.new("99999999999999999999.999999999999999999")
+      assert insert_decimal(value, context) == value
+    end
+
+    @tag precision: 38, scale: 18, capture_log: true
+    test "raises an error with value larger than SQL Server maximum", context do
+      # 39 digits
+      value = Decimal.new("999999999999999999999.9999999999999999999")
+      message = ~r/size \(39\) given to the type 'decimal' exceeds the maximum allowed \(38\)/
+      assert_raise(MatchError, message, fn -> insert_decimal(value, context) end)
+    end
+
+    test "inserts very small decimal", context do
+      assert insert_decimal(Decimal.new("0.0001"), context) == Decimal.new("0.0001")
+    end
+  end
+end