Updated columns to be list of binaries rather than list of char lists…

… per requirements with Repo.load

lib/mssqlex/protocol.ex

@@ -212,7 +212,7 @@ defmodule Mssqlex.Protocol do
       {:error, reason} ->
         {:error, reason, state}
       {:selected, columns, rows} ->
-        {:ok, %Result{columns: columns, rows: rows, num_rows: Enum.count(rows)}, state}
+        {:ok, %Result{columns: Enum.map(columns, &(to_string(&1))), rows: rows, num_rows: Enum.count(rows)}, state}
       {:updated, num_rows} ->
         {:ok, %Result{num_rows: num_rows}, state}
     end

mix.exs

@@ -3,7 +3,7 @@ defmodule Mssqlex.Mixfile do
 
   def project do
     [app: :mssqlex,
-     version: "0.5.3",
+     version: "0.5.4",
      description: "Adapter to Microsoft SQL Server. Using DBConnection and ODBC.",
      elixir: "~> 1.4",
      build_embedded: Mix.env == :prod,

test/mssqlex/query_test.exs

@@ -18,7 +18,7 @@ defmodule Mssqlex.QueryTest do
     assert {:ok, _, %Result{num_rows: 1}} = Mssqlex.query(pid,
       ["INSERT INTO query_test.dbo.simple_select VALUES ('Steven');"], [])
 
-    assert {:ok, _, %Result{columns: ['name'], num_rows: 1, rows: [["Steven"]]}}
+    assert {:ok, _, %Result{columns: ["name"], num_rows: 1, rows: [["Steven"]]}}
       = Mssqlex.query(pid, "SELECT * FROM query_test.dbo.simple_select;", [])
   end
 
@@ -32,7 +32,7 @@ defmodule Mssqlex.QueryTest do
       [1, "Jae", "2017-01-01 12:01:01.3450000"])
 
     assert {:ok, _, %Result{
-               columns: ['id', 'name', 'joined'],
+               columns: ["id", "name", "joined"],
                num_rows: 1,
                rows: [[1, "Jae", _]]}} =
       Mssqlex.query(pid, "SELECT * FROM query_test.dbo.parametrized_query;", [])

test/mssqlex/transaction_test.exs

@@ -20,7 +20,7 @@ defmodule Mssqlex.TransactionTest do
         "INSERT INTO #{table_name} VALUES ('Steven');", [])
       result
     end)
-    assert {:ok, _query, %Result{columns: ['name'], rows: [["Steven"]]}} =
+    assert {:ok, _query, %Result{columns: ["name"], rows: [["Steven"]]}} =
       Mssqlex.query(pid, "SELECT * from #{table_name};", [])
   end
 
@@ -40,7 +40,7 @@ defmodule Mssqlex.TransactionTest do
       end)
       result
     end)
-    assert {:ok, _query, %Result{columns: ['name'],
+    assert {:ok, _query, %Result{columns: ["name"],
       rows: [["Steven"], ["Jae"]]}} = Mssqlex.query(pid,
       "SELECT * from #{table_name};", [])
   end
@@ -119,7 +119,7 @@ defmodule Mssqlex.TransactionTest do
         "INSERT INTO #{table_name} VALUES ('Steven');", [])
       result
     end, [mode: :savepoint])
-    assert {:ok, _query, %Result{columns: ['name'], rows: [["Steven"]]}} =
+    assert {:ok, _query, %Result{columns: ["name"], rows: [["Steven"]]}} =
       Mssqlex.query(pid, "SELECT * from #{table_name};", [])
   end
 
@@ -140,7 +140,7 @@ defmodule Mssqlex.TransactionTest do
       end, [mode: :savepoint])
     end
 
-    assert {:ok, _, %Result{columns: ['name'], rows: [["Jae"]]}} =
+    assert {:ok, _, %Result{columns: ["name"], rows: [["Jae"]]}} =
       Mssqlex.query(pid, "SELECT * from #{table_name};", [])
   end
 end

test/mssqlex/types_test.exs

@@ -12,157 +12,157 @@ defmodule Mssqlex.TypesTest do
   end
 
   test "char", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [["Nathan"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["Nathan"]]}} =
       act(pid, "char(6)", ["Nathan"])
   end
 
   test "nchar", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [["e→øæ"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["e→øæ"]]}} =
       act(pid, "nchar(4)", ["e→øæ"])
   end
 
   test "nchar with preserved encoding", %{pid: pid} do
     expected = :unicode.characters_to_binary("e→ø",
       :unicode, {:utf16, :little})
-    assert {_query, %Result{columns: ['test'], rows: [[ ^expected ]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[ ^expected ]]}} =
       act(pid, "nchar(3)", ["e→ø"], [preserve_encoding: true])
   end
 
   test "varchar", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [["Nathan"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["Nathan"]]}} =
       act(pid, "varchar(6)", ["Nathan"])
   end
 
   test "nvarchar", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [["e→øæ"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["e→øæ"]]}} =
       act(pid, "nvarchar(4)", ["e→øæ"])
   end
 
   test "nvarchar with preserved encoding", %{pid: pid} do
     expected = :unicode.characters_to_binary("e→ø",
       :unicode, {:utf16, :little})
-    assert {_query, %Result{columns: ['test'], rows: [[ ^expected ]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[ ^expected ]]}} =
       act(pid, "nvarchar(3)", ["e→ø"], [preserve_encoding: true])
   end
 
   test "numeric(9, 0) as integer", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [[123456789]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[123456789]]}} =
       act(pid, "numeric(9)", [123456789])
   end
 
   test "numeric(8, 0) as decimal", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [[12345678]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[12345678]]}} =
       act(pid, "numeric(8)", [Decimal.new(12345678)])
   end
 
   test "numeric(15, 0) as decimal", %{pid: pid} do
     number = Decimal.new("123456789012345")
-    assert {_query, %Result{columns: ['test'], rows: [[%Decimal{} = value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[%Decimal{} = value]]}} =
       act(pid, "numeric(15)", [number])
     assert Decimal.equal?(number, value)
   end
 
   test "numeric(38, 0) as decimal", %{pid: pid} do
     number = "12345678901234567890123456789012345678"
-    assert {_query, %Result{columns: ['test'], rows: [[^number]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[^number]]}} =
       act(pid, "numeric(38)", [Decimal.new(number)])
   end
 
   test "numeric(36, 0) as string", %{pid: pid} do
     number = "123456789012345678901234567890123456"
-    assert {_query, %Result{columns: ['test'], rows: [[^number]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[^number]]}} =
       act(pid, "numeric(36)", [number])
   end
 
   test "numeric(5, 2) as decimal", %{pid: pid} do
     number = Decimal.new("123.45")
-    assert {_query, %Result{columns: ['test'], rows: [[value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[value]]}} =
       act(pid, "numeric(5,2)", [number])
     assert Decimal.equal?(number, value)
   end
 
   test "numeric(6, 3) as float", %{pid: pid} do
     number = Decimal.new("123.456")
-    assert {_query, %Result{columns: ['test'], rows: [[value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[value]]}} =
       act(pid, "numeric(6,3)", [123.456])
     assert Decimal.equal?(number, value)
   end
 
   test "real as decimal", %{pid: pid} do
     number = Decimal.new("123.45")
-    assert {_query, %Result{columns: ['test'], rows: [[%Decimal{} = value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[%Decimal{} = value]]}} =
       act(pid, "real", [number])
     assert Decimal.equal?(number, Decimal.round(value, 2))
   end
 
   test "float as decimal", %{pid: pid} do
     number = Decimal.new("123.45")
-    assert {_query, %Result{columns: ['test'], rows: [[%Decimal{} = value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[%Decimal{} = value]]}} =
       act(pid, "float", [number])
     assert Decimal.equal?(number, Decimal.round(value, 2))
   end
 
   test "double as decimal", %{pid: pid} do
     number = Decimal.new("1.12345678901234")
-    assert {_query, %Result{columns: ['test'], rows: [[%Decimal{} = value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[%Decimal{} = value]]}} =
       act(pid, "double precision", [number])
     assert Decimal.equal?(number, value)
   end
 
   test "money as decimal", %{pid: pid} do
     number = Decimal.new("1000000.45")
-    assert {_query, %Result{columns: ['test'], rows: [["1000000.4500"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["1000000.4500"]]}} =
       act(pid, "money", [number])
   end
 
   test "smallmoney as decimal", %{pid: pid} do
     number = Decimal.new("123.45")
-    assert {_query, %Result{columns: ['test'], rows: [[value]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[value]]}} =
       act(pid, "smallmoney", [number])
     assert Decimal.equal?(number, value)
   end
 
   test "bigint", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'],
+    assert {_query, %Result{columns: ["test"],
       rows: [["-9223372036854775808"]]}} = act(pid,
       "bigint", [-9223372036854775808])
   end
 
   test "int", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [[2_147_483_647]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[2_147_483_647]]}} =
       act(pid, "int", [2_147_483_647])
   end
 
   test "smallint", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [[32_767]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[32_767]]}} =
       act(pid, "smallint", [32_767])
   end
 
   test "tinyint", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [[255]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [[255]]}} =
       act(pid, "tinyint", [255])
   end
 
   test "smalldatetime as tuple", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'],
+    assert {_query, %Result{columns: ["test"],
       rows: [[{{2017, 1, 1}, {12, 10, 0, 0}}]]}} = act(pid, "smalldatetime",
       [{{2017, 1, 1}, {12, 10, 0, 0}}])
   end
 
   test "datetime as tuple", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'],
+    assert {_query, %Result{columns: ["test"],
       rows: [[{{2017, 1, 1}, {12, 10, 0, 0}}]]}} = act(pid, "datetime",
       [{{2017, 1, 1}, {12, 10, 0, 0}}])
   end
 
   test "datetime2 as tuple", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'],
+    assert {_query, %Result{columns: ["test"],
       rows: [[{{2017, 1, 1}, {12, 10, 0, 0}}]]}} = act(pid, "datetime2",
       [{{2017, 1, 1}, {12, 10, 0, 0}}])
   end
 
   test "date as tuple", %{pid: pid} do
-    assert {_query, %Result{columns: ['test'], rows: [["2017-01-01"]]}} =
+    assert {_query, %Result{columns: ["test"], rows: [["2017-01-01"]]}} =
       act(pid, "date", [{2017, 1, 1}])
   end