anchor.diff:  
   
   handle_call({latest, Period, Bucket}, _From, State) ->
  -    Reply = try mnesia:transaction(
  +    Reply = try mnesia:activity(
  +                  async_dirty,
                     fun () ->
                             Tab = table(Bucket, Period),
                             Key = mnesia:last(Tab),
                             hd(mnesia:read(Tab, Key))
  -                  end, ?RETRIES) of
  -                {atomic, Result} ->
  -                    {ok, Result};
  -                Err ->
  -                    {error, Err}
  +                  end, []) of
  +                Result ->
  +                    {ok, Result}
               catch
                   Type:Err -> {error, {Type, Err}}
               end,
       {reply, Reply, State};
   handle_call({latest, Period, Bucket, N}, _From, State) ->
  -    Reply = try walk(table(Bucket, Period), N) of
  -                Result -> {ok, Result}
  -            catch
  -                Type:Err -> {error, {Type, Err}}
  -            end,
  +    Reply = fetch_latest(Bucket, Period, N),
       {reply, Reply, State};
   handle_call({latest, Period, Bucket, Step, N}, _From, State) ->
  -    Reply = try resample(table(Bucket, Period), Step, N) of
  -                Result -> {ok, Result}
  -            catch
  -                Type:Err -> {error, {Type, Err}}
  -            end,
  +    Reply = resample(Bucket, Period, Step, N),
       {reply, Reply, State}.
   
   
  
positive.code: -module(stats_archiver).
  
  -include_lib("eunit/include/eunit.hrl").
  
  -include("ns_common.hrl").
  -include("ns_stats.hrl").
  
negative.code: 
  
  %% @doc Resample the stats in a table. Only reads the necessary number of rows.
  resample(Bucket, Period, Step, N) ->
      case lists:keyfind(Period, 1, archives()) of
          false ->
              {error, bad_period, Period};
          {_, Interval, _} ->
              Seconds = N * Interval * Step,
              Tab = table(Bucket, Period),
              case mnesia:dirty_last(Tab) of
                  '$end_of_table' ->
                      {ok, []};
                  Key ->
                      Oldest = Key - Seconds * 1000 - 500,
                      Handle = qlc:q([Sample || #stat_entry{timestamp=TS} = Sample
                                                    <- mnesia:table(Tab), TS > Oldest]),
                      F = fun (#stat_entry{timestamp = T} = Sample,
                               {T1, Acc, Chunk}) ->
                                  case T1 of
                                      undefined ->
                                          {T, Acc, [Sample]};
                                      T ->
                                          {T1, Acc, [Sample|Chunk]};
                                      _ ->
                                          {T1, [avg(T, Chunk)|Acc], [Sample]}
                                  end
                          end,
                      case mnesia:activity(async_dirty, fun qlc:fold/3,
                                           [F, {undefined, [], []},
                                            Handle]) of
                          {error, _, _} = Error ->
                              Error;
                          {undefined, [], []} ->
                              {ok, []};
                          {T, Acc, LastChunk} ->
                              {ok, lists:reverse([avg(T, LastChunk)|Acc])}
                      end
              end
      end.
  
  
  