anchor.diff:     */
     Future<Map> data() {
       Map selector = _selectorList.isEmpty ? {} : {AND: _selectorList};
  +    if(selector.containsKey(AND)) {
  +      selector={'age': null};
  +    }
       return collection.find(selector).toList().then((data) {
         var version = data.length == 0 ? 0 :
           data.map((item) => item['__clean_version']).reduce(max);
  
positive.code:   }
  
    Future _get_locks() {
      print(collection.collectionName);
      return _lock.insert({'_id': collection.collectionName}).then(
        (_) => _lock.insert({'_id': _collectionHistory.collectionName}),
        onError: (e) {
  
negative.code:   Future<List<Map>> _diffFromVersion(num version) {
      // if (some case not covered so far) {
      // throw new DiffNotPossibleException('diff not possible');
      // selects records that fulfilled _selector before change
      Map beforeSelector = {QUERY : {}, ORDERBY : {"version" : 1}};
      // selects records that fulfill _selector after change
      Map afterSelector = {QUERY : {}, ORDERBY : {"version" : 1}};
      // selects records that fulfill _selector before or after change
      Map beforeOrAfterSelector = {QUERY : {}, ORDERBY : {"version" : 1}};
  
      // {before: {GT: {}}} to handle selectors like {before.age: null}
      List<Map> _beforeSelector = [{"version" : {GT : version}}, {"before" : {GT: {}}}];
      List<Map> _afterSelector = [{"version" : {GT : version}}, {"after" : {GT: {}}}];
      _selectorList.forEach((item) {
        Map itemB = {};
        Map itemA = {};
        item.forEach((key, val) {
          itemB["before.${key}"] = val;
          itemA["after.${key}"] = val;
        });
        _beforeSelector.add(itemB);
        _afterSelector.add(itemA);
      });
      beforeSelector[QUERY][AND] = _beforeSelector;
      afterSelector[QUERY][AND] = _afterSelector;
      beforeOrAfterSelector[QUERY][OR] = [{AND: _beforeSelector},
                                          {AND: _afterSelector}];
  
      Set before, after;
      List beforeOrAfter, diff;
  