anchor.diff:  
       case erlcass_prep_utils:does_exist(Identifier) of
           true ->
  -            {reply, already_exist, State};
  +            {reply, {error, already_exist}, State};
           _ ->
               ok = erlcass_nif:cass_session_prepare(State#state.session, Query, {From, Identifier}),
               {noreply, State}
       end;
   
  -handle_call({execute_normal_statements, StatementRef}, From, State) ->
  +handle_call({execute_normal_statements, StmRef}, From, State) ->
       Tag = make_ref(),
       {FromPid, _} = From,
  -    Result = erlcass_nif:cass_session_execute(State#state.session, StatementRef, FromPid, Tag),
  +    Result = erlcass_nif:cass_session_execute(State#state.session, StmRef, FromPid, Tag),
       {reply, {Result, Tag}, State};
   
   handle_call({batch_execute, BatchType, StmList, Options}, From, State) ->
  
positive.code: 
      async_execute_statement(Stm).
  
  -spec(execute(Identifier :: atom() | binary()) ->
      {ok, Result :: list()} | badarg | {error, Reason :: binary()}).
  
  execute(Identifier) ->
      {ok, Tag} = async_execute(Identifier),
      receive_response(Tag).
  
  -spec(execute(Identifier :: atom() | binary(), Params :: list()) ->
      {ok, Result :: list()} | badarg | {error, Reason :: binary()}).
  
  execute(Identifier, Params) ->
      execute(Identifier, ?BIND_BY_INDEX, Params).
  
  -spec(execute(Identifier :: atom() | binary(), BindType :: integer(), Params :: list()) ->
      {ok, Result :: list()} | badarg | {error, Reason :: binary()}).
  
  execute(Identifier, BindType, Params) ->
      {ok, Tag} = async_execute(Identifier, BindType, Params),
      receive_response(Tag).
  
  -spec(batch_async_execute(BatchType :: integer(), StmList :: list(), Options :: list()) ->
      {ok, Tag :: reference()} | badarg | {error, Reason :: binary()}).
  
  batch_async_execute(BatchType, StmList, Options) ->
      gen_server:call(?MODULE, {batch_execute, BatchType, StmList, Options}).
  
  -spec(batch_execute(BatchType :: integer(), StmList :: list(), Options :: list()) ->
      {ok, Result :: list()} | badarg | {error, Reason :: binary()}).
  
  batch_execute(BatchType, StmList, Options) ->
      {ok, Tag} = batch_async_execute(BatchType, StmList, Options),
  
negative.code:         {execute_statement_result, Tag, Result} ->
              Result
  
      after ?RESPONSE_TIMEOUT ->
          timeout
      end.
  
  filter_stm_list(StmList) ->
  