anchor.diff:                                             entry_datatype(NewEntry),
                                              entry_filters(NewEntry),
                                              entry_retrigger(NewEntry),
  -                                           1+pr:get_r(entry_my_round(NewEntry))}, State)
  +                                           1+pr:get_r(entry_my_round(NewEntry))}, State);
  +                write_through ->
  +                    %% majority replied, we have not a consistent quorum, but we can
  +                    %% skip qread phase and go directly to write through
  +
  +                    % transform reply record to r_replies since that is what WT expects
  +                    RReplies = #r_replies{highest_write_count=NewReplies#rr_replies.highest_write_count,
  +                                         highest_write_round=NewReplies#rr_replies.highest_write_round,
  +                                         read_value=NewReplies#rr_replies.read_value},
  +                    NewEntry2 = entry_set_replies(NewEntry, RReplies),
  +                    ?PDB:delete(ReqId, tablename(State)),
  +                    gen_component:post_op({qread_initiate_write_through, NewEntry2},
  +                                           State)
               end
       end;
   
  
positive.code:             {RF, _, _}   -> RF;
              RF           -> RF
          end,
  
      %% If enough replicas have replied, decide on the next action
      %% to take.
      {Result, R4} =
          case ?REDUNDANCY:quorum_accepted(ReplyCount) of
              true ->
                  case ReplyCount =:= R3#rr_replies.highest_write_count andalso
                       %% If this round request is part of a read, then it does not matter if
                       %% there is a write in progress which has not yet written the majority.
                       %% Since the read and write are concurrent, the read can return the older value.
                       (OpType =:= read orelse ReplyCount =:= R3#rr_replies.highest_read_count) of
                      true ->
                          %% consistent quorum
                          Collected = R3#rr_replies.read_value,
                          ReadValue = ?REDUNDANCY:get_read_value(Collected, ReadFilter),
                          T1 = R3#rr_replies{read_value=ReadValue},
                          {consistent, T1};
                      false ->
                          %% not a consistent quorum
                          %% we do not have to calculate the final value since a
                          %% new read request will be started anyway.
                          {true, R3}
                  end;
              false ->
                  %% no majority yet
  
negative.code:                                     NewReplies#rr_replies.read_value),
                      ?PDB:delete(ReqId, tablename(State)),
                      State;
                  inconsistent ->
                      %% majority replied, but we do not have a consistent quorum ->
                      %% do a qread with highest received read round + 1
                      ?PDB:delete(ReqId, tablename(State)),
  