anchor.diff:  
   handle_info({{SubQId, QId}, {results, Chunk}}, #state{qid = QId} = State) ->
       {noreply, throttling_spawn_index_fsms(
  -                add_subquery_result(SubQId, Chunk, State))};
  +                estimate_query_size(
  +                  add_subquery_result(SubQId, Chunk, State)))};
   
   handle_info({{SubQId, QId}, {error, Reason} = Error},
               #state{receiver_pid = ReceiverPid,
  
positive.code:     State.
  
  
  
  %%
  add_subquery_result(SubQId, Chunk, #state{sub_qrys = SubQs,
                                            n_running_fsms = NRunning} = State) ->
      case lists:member(SubQId, SubQs) of
          true ->
              try
                  QueryResult2 = run_select_on_chunk(SubQId, Chunk, State),
                  NSubQ = lists:delete(SubQId, SubQs),
                  State#state{result         = QueryResult2,
                              n_running_fsms = NRunning - 1,
                              sub_qrys       = NSubQ}
              catch
                  error:divide_by_zero ->
                      cancel_error_query(divide_by_zero, State)
  
negative.code:           qid           = undefined           :: undefined | {node(), non_neg_integer()},
            sub_qrys      = []                  :: [integer()],
            receiver_pid                        :: pid(),
            %% overload protection:
            %% 1. Maintain a limited number of running fsms (i.e.,
            %%    process at most that many subqueries at a time):
            fsm_queue          = []                   :: [list()],
            n_running_fsms     = 0                    :: non_neg_integer(),
            max_running_fsms   = ?MAX_RUNNING_FSMS    :: pos_integer(),
            %% 2. Estimate query size (wget-style):
            n_subqueries_done  = 0                    :: non_neg_integer(),
            total_query_data   = 0                    :: non_neg_integer(),
            max_query_data     = ?MAX_QUERY_DATA_SIZE :: non_neg_integer(),
            %% For queries not backed by query buffers, results are
            %% accumulated in memory:
            result             = []                   :: rows_acc() | aggregate_acc() | group_by_acc(),
            %% Query buffer support
            qbuf_ref                 :: undefined | riak_kv_qry_buffers:qbuf_ref(),
            orig_qry                 :: undefined | ?SQL_SELECT{}
           }).
  
  %%%===================================================================
  