Merge pull request #52 from NickNeck/fix/handle

Fix/handle 0 exception

Author: mjaric

lib/tds/messages.ex

@@ -89,15 +89,15 @@ defmodule Tds.Messages do
       <<170::little-size(8), _::binary>> ->
         [error: error] = decode_tokens(tail, [])
         msg_error(e: error)
-      _ -> 
+      _ ->
         msg_login_ack(type: 4, data: tail)
     end
   end
 
   def parse(:executing, @tds_pack_reply, _header, tail) do
     tokens = []
     tokens = decode_tokens(tail, tokens)
-    
+
     case tokens do
       [error: error] ->
         msg_error(e: error)
@@ -374,7 +374,9 @@ defmodule Tds.Messages do
     p_name = to_little_ucs2(name)
     p_flags = param |> Tds.Parameter.option_flags
     {type_code, type_data, type_attr} = Types.encode_data_type(param)
+
     p_meta_data = <<byte_size(name)>> <> p_name <> p_flags <> type_data
+
     p_meta_data <> Types.encode_data(type_code, param.value, type_attr)
   end
 

lib/tds/protocol.ex

@@ -61,17 +61,17 @@ defmodule Tds.Protocol do
   @spec ping(any) :: {:ok, any} | {:disconnect, Exception.t, any}
   def ping(state) do
     case send_query(~s{SELECT 'pong' as [msg]}, state) do
-      {:ok, _, s} -> 
+      {:ok, _, s} ->
         {:ok, s}
-      {:disconnect, :closed, s} -> 
+      {:disconnect, :closed, s} ->
         {:disconnect, %Tds.Error{message: "Connection closed."}, s}
-      {:error, err, s} -> 
+      {:error, err, s} ->
         err = cond do
           Exception.exception?(err) -> err
           true                      -> %Tds.Error{message: inspect(err)}
         end
         {:disconnect, err, s}
-      any -> 
+      any ->
         any
     end
   end
@@ -162,7 +162,7 @@ defmodule Tds.Protocol do
         # :socket_options.
         {:ok, [sndbuf: sndbuf, recbuf: recbuf, buffer: buffer]} =
           :inet.getopts(sock, [:sndbuf, :recbuf, :buffer])
-        
+
         buffer = buffer
         |> max(sndbuf)
         |> max(recbuf)
@@ -172,7 +172,7 @@ defmodule Tds.Protocol do
           {:error, error, _state} ->
             :gen_tcp.close(sock)
             {:error, error}
-          r -> 
+          r ->
             r
         end
       {:error, error} ->
@@ -274,7 +274,7 @@ defmodule Tds.Protocol do
           1 ->
             #status 1 means last packet of message
             #TODO Messages.parse does not use pak_header
-            
+
             msg = parse(state, type, pak_header, pak_data <> package)
 
             case message(state, msg, s) do
@@ -548,16 +548,18 @@ defmodule Tds.Protocol do
     Enum.each(paks, fn(pak) ->
       mod.send(sock, pak)
     end)
+
     case msg_recv(<<>>, s) do
       {:disconnect, _ex , _s}=res ->
         res
       buffer ->
         new_data(buffer, %{s | state: :executing, pak_header: ""})
     end
-        
+
   end
-  
+
   defp msg_recv(buffer, %{sock: {mod, sock}} = s) do
+    #IO.puts("buffer: #{inspect buffer}")
     case mod.recv(sock, 8) do
       # there is more tds packages after this one
       {:ok, <<_type::int8, 0x00, length::int16, _spid::int16, _package::int8, _window::int8>> = header}  ->
@@ -566,10 +568,11 @@ defmodule Tds.Protocol do
         |> msg_recv(s)
       # this heder belongs to last package
       {:ok, <<_type::int8, 0x01, length::int16, _spid::int16, _package::int8, _window::int8>> = header} ->
+        #IO.puts("header: #{inspect header}")
         buffer <> header
         |> package_recv(s, length - 8)
       {:ok, _} ->
-        raise("Other statuses todo!")    
+        raise("Other statuses todo!")
       {:error, exception} ->
         {:disconnect, exception, s}
     end
@@ -581,13 +584,13 @@ defmodule Tds.Protocol do
         length = length - byte_size(data)
         buffer <> data
         |> package_recv(s, length)
-      {:ok, data} -> 
+      {:ok, data} ->
         buffer <> data
       {:error, exception} ->
         {:disconnect, exception, s}
     end
   end
-  
+
   # defp msg_cast(msg, %{sock: {mod, sock}, env: env} = s) do
   #   :inet.setopts(sock, active: false)
 
@@ -597,7 +600,7 @@ defmodule Tds.Protocol do
   #   end)
   #   # NOTE: this method can not be used since it is not receiving packages from SQL server!
   #   # TODO: add :gen_tcp.recv/flush since it should flush next package if there is such case where we don't care about
-  #   # what package contains. 
+  #   # what package contains.
   #   {:ok, s}
   # end
 

lib/tds/tokens.ex

@@ -48,24 +48,31 @@ defmodule Tds.Tokens do
     raise Tds.Error, "Unknown datatype parsed when decoding return value: #{dec}"
   end
 
-  defp decode_token(<<@tds_token_returnvalue, tail::binary>>, tokens) do
-    <<_ord::little-unsigned-16, length::size(8), rest::binary>> = tail
+  defp decode_value(
+    <<0x26,size::size(8),size::size(8),data::binary>>
+  ) do
+    <<value::little-size(size)-unit(8), data::binary>> = data
+    {value, data}
+  end
 
-    length = length * 2
+  defp decode_token(<<@tds_token_returnvalue, data::binary>>, tokens) do
+    <<
+      _ord::little-unsigned-16,
+      length::size(8),
+      name::binary-size(length)-unit(16),
+      _status::size(8),
+      _usertype::size(32),
+      _flags::size(16),
+      data::binary
+    >> = data
 
-    <<name::binary-size(length)-unit(8), rest::binary>> = rest
     name = ucs2_to_utf(name)
+    {value, data} = decode_value(data)
 
-    <<_status::size(8), _usertype::size(32), _flags::size(16), datatype::size(8), rest::binary>> = rest
-
-    datatype_size = retval_typ_size(datatype)
-
-    <<_garbage::binary-size(2), ret_val::size(datatype_size), _empty::binary-size(3), tail::binary>> = rest
-
-    {[parameters: {name, ret_val}]++tokens, tail}
+    {[parameters: {name, value}] ++ tokens, data}
   end
-  defp decode_token(<<@tds_token_returnstatus, _value::little-size(32), tail::binary>>, tokens) do
-    {tokens, tail}
+  defp decode_token(<<@tds_token_returnstatus, _value::little-size(32), data::binary>>, tokens) do
+    {tokens, data}
   end
   # COLMETADATA
   defp decode_token(<<@tds_token_colmetadata, column_count::little-2*8, tail::binary>>, tokens) do
@@ -172,41 +179,41 @@ defmodule Tds.Tokens do
         <<0x00, value_size::unsigned-8, _old_value::binary-little-size(value_size)-unit(8), rest::binary>> = tail
         {tokens |> Keyword.put(:trans, <<0x00>>), rest}
     end
-    
+
   end
   ## DONE
   defp decode_token(<<@tds_token_done, status::int16, cur_cmd::binary(2), row_count::little-size(8)-unit(8), _tail::binary>>, tokens) do
     case Keyword.get(tokens, :done) do
-      nil -> 
+      nil ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), nil}
       %{rows: rows} when row_count > rows ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), nil}
-      _ -> 
+      _ ->
         {tokens, nil}
     end
   end
   ## DONEPROC
   defp decode_token(<<@tds_token_doneproc, status::int16, cur_cmd::binary(2), row_count::little-size(8)-unit(8), _tail::binary>>, tokens) do
     case Keyword.get(tokens, :done) do
-      nil -> 
+      nil ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), nil}
       %{rows: rows} when row_count > rows ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), nil}
-      _ -> 
+      _ ->
         {tokens, nil}
     end
   end
   ## DONEINPROC
   defp decode_token(<<@tds_token_doneinproc, status::int16, cur_cmd::binary(2), row_count::little-size(8)-unit(8), _something::binary-size(5), tail::binary>>, tokens) do
     case Keyword.get(tokens, :done) do
-      nil -> 
+      nil ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), tail}
       %{rows: rows} when row_count > rows ->
         {Keyword.put(tokens, :done, %{status: status, cmd: cur_cmd, rows: row_count}), nil}
-      _ -> 
+      _ ->
         {tokens, nil}
     end
-    
+
     # case tokens do
     #   [done: done] ->
     #     cond do

lib/tds/types.ex

@@ -146,7 +146,7 @@ defmodule Tds.Types do
         col_info = def_col_info
           |> Map.put(:length, length)
           |> Map.put(:data_reader, :bytelen)
-        {col_info, tail}    
+        {col_info, tail}
       data_type_code in [
         @tds_data_type_timen,
         @tds_data_type_datetime2n,
@@ -182,7 +182,7 @@ defmodule Tds.Types do
           |> Map.put(:scale, scale)
           |> Map.put(:length, length)
           |> Map.put(:data_reader, :bytelen)
-        {col_info, rest}    
+        {col_info, rest}
       data_type_code in [
         @tds_data_type_uniqueidentifier,
         @tds_data_type_intn,
@@ -201,7 +201,7 @@ defmodule Tds.Types do
         col_info = def_col_info
           |> Map.put(:length, length)
           |> Map.put(:data_reader, :bytelen)
-        {col_info, rest}    
+        {col_info, rest}
       data_type_code == @tds_data_type_xml ->
         <<schema::unsigned-8, rest::binary>> = tail
         if schema == 1 do
@@ -235,10 +235,10 @@ defmodule Tds.Types do
           |> Map.put(:data_reader, if(length == 0xFFFF, do: :plp, else: :shortlen))
           |> Map.put(:length, length)
         {col_info, rest}
-      
+
       data_type_code in [@tds_data_type_text, @tds_data_type_ntext] ->
         <<length::signed-32, collation::binary-5, numparts::signed-8, rest::binary>> = tail
-        
+
         col_info = def_col_info
           |> Map.put(:collation, collation)
           |> Map.put(:data_reader, :longlen)
@@ -247,7 +247,7 @@ defmodule Tds.Types do
         rest = Enum.reduce([1..numparts], rest, fn
           (_, <<tsize::little-unsigned-16, _table_name::binary-size(tsize)-unit(16), next_rest::binary>>) -> next_rest
         end)
-        {col_info, rest} 
+        {col_info, rest}
       data_type_code == @tds_data_type_image ->
         # TODO NumBarts Reader
         <<length::signed-32, numparts::signed-8, rest::binary>> = tail
@@ -264,7 +264,7 @@ defmodule Tds.Types do
           |> Map.put(:length, length)
           |> Map.put(:data_reader, :variant)
         {col_info, rest}
-    
+
     end
   end
 
@@ -962,15 +962,15 @@ defmodule Tds.Types do
   def encode_data(@tds_data_type_bigvarbinary = data_type, value, attr)
   when is_integer(value),
     do: encode_data(data_type, <<value>>, attr)
-  def encode_data(@tds_data_type_bigvarbinary, nil, _), 
+  def encode_data(@tds_data_type_bigvarbinary, nil, _),
     do: <<@tds_plp_null::little-unsigned-64>>
-  def encode_data(@tds_data_type_bigvarbinary, value, _), 
+  def encode_data(@tds_data_type_bigvarbinary, value, _),
     do: <<byte_size(value)::little-unsigned-16>> <> value
 
   @doc """
   Data Encoding String Types
   """
-  def encode_data(@tds_data_type_nvarchar, nil, _), 
+  def encode_data(@tds_data_type_nvarchar, nil, _),
     do: <<@tds_plp_null::little-unsigned-64>>
   def encode_data(@tds_data_type_nvarchar, value, _) do
     value = to_little_ucs2(value)
@@ -1025,8 +1025,8 @@ defmodule Tds.Types do
       <<0x04, value::little-float-32>>
     else
       # up to 15 digits of precision https://docs.microsoft.com/en-us/sql/t-sql/data-types/float-and-real-transact-sql
-      <<0x08, value::little-float-64>>      
-    end  
+      <<0x08, value::little-float-64>>
+    end
   end
 
   @doc """
@@ -1061,7 +1061,7 @@ defmodule Tds.Types do
     value_binary = value_binary <> <<0::size(padding)-unit(8)>>
     <<byte_len>> <> <<sign>> <> value_binary
   end
-  def encode_data(@tds_data_type_decimaln, nil, _), 
+  def encode_data(@tds_data_type_decimaln, nil, _),
     do: <<0x00::little-unsigned-32>> # <<0, 0, 0, 0>
   def encode_data(@tds_data_type_decimaln = data_type, value, attr) do
     encode_data(data_type, Decimal.new(value), attr)
@@ -1152,7 +1152,7 @@ defmodule Tds.Types do
 
   defp int_type_size(int) when int == nil, do: 4
   defp int_type_size(int) when int in 0..255, do: 4
-  defp int_type_size(int) when int in -32768..32767, do: 2
+  defp int_type_size(int) when int in -32768..32767, do: 4
   defp int_type_size(int) when int in -2147483648..2147483647, do: 4
   defp int_type_size(int) when int in -9223372036854775808..9223372036854775807, do: 8
 
@@ -1365,7 +1365,4 @@ defmodule Tds.Types do
     data = <<type, 0x07>>
     {type, data, scale: 7}
   end
-
-
-
 end

test/handle0_test.exs

@@ -0,0 +1,43 @@
+defmodule Handle0Test do
+
+  use ExUnit.Case, async: true
+
+  import Tds.TestHelper
+
+  alias Tds
+
+  @tag timeout: 50000
+  @table "foo"
+
+  setup do
+    opts = Application.fetch_env!(:tds, :opts)
+    {:ok, pid} = Tds.start_link(opts)
+
+    {:ok, [pid: pid]}
+  end
+
+  test "Could not find prepared statement with handle 0.", %{pid: pid} = context do
+    query("DROP TABLE #{@table}", [])
+
+    query(
+      """
+      CREATE TABLE #{@table}(
+        [id] int identity(1,1) not null primary key
+      )
+      """,
+      []
+    )
+
+    n = 300
+    for _ <- 1..n do
+      result =
+        Tds.query(pid, "SELECT * FROM #{@table} WHERE id = @id", [
+          %Tds.Parameter{name: "@id", value: "7", type: :int}
+        ])
+
+      assert {:ok,_} = result
+    end
+
+    query("DROP TABLE #{@table}", [])
+  end
+end