anchor.diff:  
   handle_call(state, _From, State) ->
       {reply, State, State}.
  +
  +find_list(Type, Include, Cmd, From, Prefix, State, Key) ->
  +    {reply, Res, _} = handle_call(Cmd, From, State#state{cache_enable = false}),
  +    case is_list(Res) of
  +        true ->
  +            DummyRecord		= boss_record_lib:dummy_record(Type),
  +            BelongsToTypes	= DummyRecord:belongs_to_types(),
  +            IncludedRecords     = find_list_records(Include, From, State,
  +                                                       Res, BelongsToTypes),
  +            lists:map(fun(Rec) ->
  +                        boss_cache:set(Prefix, Rec:id(), Rec, State#state.cache_ttl)
  +                      end, IncludedRecords),
  +            boss_cache:set(Prefix, Key, Res, State#state.cache_ttl),
  +            WatchString         = lists:concat([inflector:pluralize(atom_to_list(Type)), 
  +						", ", Type, "-*.*"]),
  +            boss_news:set_watch(Key, WatchString, fun boss_db_cache:handle_collection_news/3,
  +				{Prefix, Key}, State#state.cache_ttl);
  +        _ -> error % log it here?
  +    end,
  +    Res.
  +
  +find_list_records(Include, From, State, Res, BelongsToTypes) ->
  +    lists:foldl(fun
  +		    ({RelationshipName, InnerInclude}, Acc) ->
  +			RelType    = proplists:get_value(RelationshipName, BelongsToTypes),
  +                        RecordList = lookup_rel_records(From, State, Res,
  +					                RelationshipName,
  +					                InnerInclude, RelType),
  +			RecordList ++ Acc
  +                end, [], lists:map(fun({R, I}) -> {R, I}; (R) -> {R, []} end, Include)).
  +
  +lookup_rel_records(From, State, Res, RelationshipName, InnerInclude,
  +		   undefined) -> [];
  +lookup_rel_records(From, State, Res, RelationshipName, InnerInclude,
  +		   RelationshipType) ->
  +
  +    IdList = lists:map(fun(Record) ->
  +			       Record:get(lists:concat([RelationshipType, "_id"]))
  +		       end, Res),
  +    handle_call({find, RelationshipName,
  +		 [{'id', 'in', IdList}],
  +		 all, 0, id, ascending,
  +		 InnerInclude}, From, State).
  +
   
   handle_cast({try_connect, Options}, State) when State#state.connection_state /= connected ->
       Adapter = State#state.adapter,
  
positive.code: 
  init(Options) ->
      AdapterName = proplists:get_value(adapter, Options, mock),
      Adapter = list_to_atom(lists:concat(["boss_db_adapter_", AdapterName])),
      CacheEnable = proplists:get_value(cache_enable, Options, false),
      CacheTTL = proplists:get_value(cache_exp_time, Options, 60),
      CachePrefix = proplists:get_value(cache_prefix, Options, db),
      process_flag(trap_exit, true),
      try_connection(self(), Options),
      {ok, #state{connection_state = connecting,
  		connection_delay = 1,
  		options = Options,
  		adapter = Adapter,
  		cache_enable = CacheEnable,
  		cache_ttl = CacheTTL, cache_prefix = CachePrefix }}.
  
  handle_call(_Anything, _Anyone, State) when State#state.connection_state /= connected ->
      {reply, db_connection_down, State};
  
negative.code: 	    {connection_error, Error}
      end.
  
  setup_reconnect(State =#state{connection_delay = DelayTime}) ->
      Delay = case DelayTime of
  		D when D < ?MAXDELAY ->
  		    D;
  		_ ->
  