anchor.diff:  
   init(Options) ->
       AdapterName = proplists:get_value(adapter, Options, mock),
  -    Adapter = list_to_atom(lists:concat(["boss_db_adapter_", AdapterName])),
  +    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),
  +    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 }}.
  +    {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};
  
positive.code:     Key = {Type, Conditions, Max, Skip, Sort, SortOrder},
      case boss_cache:get(Prefix, Key) of
          undefined ->
              {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 = lists:foldl(fun
                              ({RelationshipName, InnerInclude}, Acc) ->
                                  RecordList = case proplists:get_value(RelationshipName, BelongsToTypes) of
                                      undefined -> [];
                                      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)
                                  end,
                                  RecordList ++ Acc
                          end, [], lists:map(fun({R, I}) -> {R, I}; (R) -> {R, []} end, Include)),
                      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,
              {reply, Res, State};
          CachedValue ->
              boss_news:extend_watch(Key),
  
negative.code: 
  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,
  