anchor.diff:      gen_server:start_link(?MODULE, [], []).
   
   connect(C, Host, Username, Password, Opts) ->
  -    gen_server:call(C, {connect, Host, Username, Password, Opts}, infinity).
  +    gen_server:cast(C, {connect, Host, Username, Password, Opts}).
   
   close(C) when is_pid(C) ->
  -    catch gen_server:call(C, stop, infinity),
  +    catch gen_server:cast(C, stop),
       ok.
   
   get_parameter(C, Name) ->
       gen_server:call(C, {get_parameter, to_binary(Name)}).
   
   squery(C, Sql) ->
  -    gen_server:call(C, {squery, Sql}, infinity).
  +    gen_server:cast(C, {squery, Sql}).
  +
  +equery(C, Statement, Parameters) ->
  +    gen_server:cast(C, {equery, Statement, Parameters}).
   
   parse(C, Name, Sql, Types) ->
  -    gen_server:call(C, {parse, Name, Sql, Types}, infinity).
  +    gen_server:cast(C, {parse, Name, Sql, Types}).
   
   bind(C, Statement, PortalName, Parameters) ->
  -    gen_server:call(C, {bind, Statement, PortalName, Parameters}, infinity).
  +    gen_server:cast(C, {bind, Statement, PortalName, Parameters}).
   
   execute(C, Statement, PortalName, MaxRows) ->
  -    gen_server:call(C, {execute, Statement, PortalName, MaxRows}, infinity).
  +    gen_server:cast(C, {execute, Statement, PortalName, MaxRows}).
   
   describe(C, Type, Name) ->
  -    gen_server:call(C, {describe, Type, Name}, infinity).
  +    gen_server:cast(C, {describe, Type, Name}).
   
   close(C, Type, Name) ->
  -    gen_server:call(C, {close, Type, Name}, infinity).
  +    gen_server:cast(C, {close, Type, Name}).
   
   sync(C) ->
  -    gen_server:call(C, sync, infinity).
  +    gen_server:cast(C, sync).
   
   cancel(S) ->
       gen_server:cast(S, cancel).
  
positive.code:     end,
      {stop, normal, gen_reply(State, {error, Why})};
  
  auth(timeout, State) ->
      {stop, normal, gen_reply(State, {error, timeout})};
  
  auth(Other, State) ->
      #state{timeout = Timeout} = State,
      {noreply, State2} = on_message(Other, State),
      {noreply, State2, Timeout}.
  
  %% BackendKeyData
  initializing({$K, <<Pid:?int32, Key:?int32>>}, State) ->
      #state{timeout = Timeout} = State,
      State2 = State#state{backend = {Pid, Key}},
      {noreply, State2, Timeout};
  
  initializing(timeout, State) ->
      {stop, normal, gen_reply(State, {error, timeout})};
  
  %% ReadyForQuery
  initializing({$Z, <<Status:8>>}, State) ->
  
negative.code: handle_call({connect, Host, Username, Password, Opts},
              From,
              #state{queue = Queue} = State) ->
      Timeout = proplists:get_value(timeout, Opts, 5000),
      Port = proplists:get_value(port, Opts, 5432),
      SockOpts = [{active, false}, {packet, raw}, binary, {nodelay, true}],
  