options list as fouth argument to equery

Makefile

@@ -14,3 +14,7 @@ tests:
 
 ct-clean:
 	rm -rf logs/*
+
+
+d:
+	dialyzer --src -I include src

src/epgsql_pool.erl

@@ -32,13 +32,16 @@ stop(PoolName) ->
 
 -spec equery(pool_name() | pid(), epgsql:sql_query()) -> epgsql:reply().
 equery(PoolNameOrWorker, Stmt) ->
-    equery(PoolNameOrWorker, Stmt, []).
+    equery(PoolNameOrWorker, Stmt, [], []).
 
 
-%% Example
-%% epgsql_pool:equery("my_db_pool", "SELECT NOW() as now", []).
 -spec equery(pool_name() | pid(), epgsql:sql_query(), [epgsql:bind_param()]) -> epgsql:reply().
-equery(Worker, Stmt, Params) when is_pid(Worker) ->
+equery(PoolNameOrWorker, Stmt, Params) ->
+    equery(PoolNameOrWorker, Stmt, Params, []).
+
+
+-spec equery(pool_name() | pid(), epgsql:sql_query(), [epgsql:bind_param()], [proplists:option()]) -> epgsql:reply().
+equery(Worker, Stmt, Params, Options) when is_pid(Worker) ->
     Timeout = epgsql_pool_settings:get(query_timeout),
     % TODO process timeout,
     % try-catch
@@ -47,24 +50,21 @@ equery(Worker, Stmt, Params) when is_pid(Worker) ->
     % reply to client with error
     % reconnect
     % return to pool
-    gen_server:call(Worker, {equery, Stmt, Params}, Timeout);
+    Res = gen_server:call(Worker, {equery, Stmt, Params}, Timeout),
+    ErrorHandler = proplists:get_value(error_handler, Options),
+    case {ErrorHandler, Res} of
+        {undefined, _} -> Res;
+        {Fun, {error, Error}} -> Fun(Worker, Stmt, Params, Error);
+        _ -> Res
+    end;
 
-equery(PoolName, Stmt, Params) ->
+equery(PoolName, Stmt, Params, Options) ->
     transaction(PoolName,
                 fun(Worker) ->
-                        equery(Worker, Stmt, Params)
+                        equery(Worker, Stmt, Params, Options)
                 end).
 
 
--spec equery(pool_name() | pid(), epgsql:sql_query(), [epgsql:bind_param()], fun()) -> epgsql:reply().
-equery(PoolName, Stmt, Params, ErrorHandler) ->
-    Res = equery(PoolName, Stmt, Params),
-    case Res of
-        {error, Error} -> ErrorHandler(PoolName, Stmt, Params, Error);
-        _ -> Res
-    end.
-
-
 -spec transaction(pool_name(), fun()) -> epgsql:reply() | {error, term()}.
 transaction(PoolName0, Fun) ->
     PoolName = epgsql_pool_utils:pool_name_to_atom(PoolName0),
@@ -72,13 +72,13 @@ transaction(PoolName0, Fun) ->
     case pooler:take_member(PoolName, Timeout) of
         Worker when is_pid(Worker) ->
             try
-                equery(Worker, "BEGIN", []),
+                equery(Worker, "BEGIN"),
                 Result = Fun(Worker),
-                equery(Worker, "COMMIT", []),
+                equery(Worker, "COMMIT"),
                 Result
             catch
                 Err:Reason ->
-                    equery(Worker, "ROLLBACK", []),
+                    equery(Worker, "ROLLBACK"),
                     erlang:raise(Err, Reason, erlang:get_stacktrace())
             after
                 pooler:return_member(PoolName, Worker, ok)

test/epgsql_pool_SUITE.erl

@@ -122,7 +122,7 @@ transaction_test(Config) ->
 
 reconnect_test(Config) ->
     Worker = pooler:take_member(my_pool, 1000) ,
-    {state, my_pool, #epgsql_connection{sock = Sock1}} = sys:get_state(Worker),
+    [state, my_pool, #epgsql_connection{sock = Sock1} | _]= tuple_to_list(sys:get_state(Worker)),
     ct:pal("Worker: ~p, sock: ~p", [Worker, Sock1]),
 
     R1 = epgsql_pool:equery(Worker, ?SELECT_ITEMS_QUERY),
@@ -148,7 +148,7 @@ reconnect_test(Config) ->
     ct:pal("fouth query goes after 200 ms ~p", [R4]),
     {ok, _, []} = R4,
 
-    {state, my_pool, #epgsql_connection{sock = Sock2}} = sys:get_state(Worker),
+    [state, my_pool, #epgsql_connection{sock = Sock2} | _]= tuple_to_list(sys:get_state(Worker)),
     ct:pal("Worker: ~p, sock: ~p", [Worker, Sock2]),
 
     ?assertNotEqual(Sock1, Sock2),
@@ -162,15 +162,14 @@ error_handler_test(Config) ->
 
     Query2 = "SELECT some_field FROM item WHERE id = $1",
     ErrorMessage2 = <<"column \"some_field\" does not exist">>,
-    ErrorHandler = fun(PoolName, Stmt, Params, Error2) ->
+    ErrorHandler = fun(_Worker, Stmt, Params, Error2) ->
                            ct:pal("ErrorHandler: ~p", [Error2]),
-                           ?assertEqual(my_pool, PoolName),
                            ?assertEqual(Query2, Stmt),
                            ?assertEqual([1], Params),
                            ?assertMatch(#error{severity = error, message = ErrorMessage2}, Error2),
                            {db_error, Error2#error.message}
                    end,
-    Res = epgsql_pool:equery(my_pool, Query2, [1], ErrorHandler),
+    Res = epgsql_pool:equery(my_pool, Query2, [1], [{error_handler, ErrorHandler}]),
     ct:pal("Res:~p", [Res]),
     ?assertEqual({db_error, ErrorMessage2}, Res),