DictionaryDb: reworked internal reprs; updated gender stats, researcher

gramps/plugins/database/dictionarydb.py

@@ -38,7 +38,8 @@ import logging
 #------------------------------------------------------------------------
 from gramps.gen.const import GRAMPS_LOCALE as glocale
 _ = glocale.translation.gettext
-from gramps.gen.db import DbReadBase, DbWriteBase, DbTxn, KEY_TO_NAME_MAP
+from gramps.gen.db import (DbReadBase, DbWriteBase, DbTxn, 
+                           KEY_TO_NAME_MAP, KEY_TO_CLASS_MAP)
 from gramps.gen.db.undoredo import DbUndo
 from gramps.gen.db.dbconst import *
 from gramps.gen.utils.callback import Callback
@@ -66,6 +67,7 @@ from gramps.gen.lib.place import Place
 from gramps.gen.lib.repo import Repository
 from gramps.gen.lib.note import Note
 from gramps.gen.lib.tag import Tag
+from gramps.gen.lib.genderstats import GenderStats
 
 _LOG = logging.getLogger(DBLOGNAME)
 
@@ -99,8 +101,8 @@ class Table(object):
         """
         return self.funcs["cursor_func"]()
 
-    def put(key, data, txn=None):
+    def put(self, key, data, txn=None):
-        self[key] = data
+        self.funcs["add_func"](data, txn)
 
 class Map(dict):
     """
@@ -137,15 +139,14 @@ class MetaCursor(object):
         pass
 
 class Cursor(object):
-    def __init__(self, map, func):
+    def __init__(self, map):
         self.map = map
-        self.func = func
         self._iter = self.__iter__()
     def __enter__(self):
         return self
     def __iter__(self):
         for item in self.map.keys():
-            yield (bytes(item, "utf-8"), self.func(item))
+            yield (bytes(item, "utf-8"), self.map[item])
     def __next__(self):
         try:
             return self._iter.__next__()
@@ -155,7 +156,7 @@ class Cursor(object):
         pass
     def iter(self):
         for item in self.map.keys():
-            yield (bytes(item, "utf-8"), self.func(item))
+            yield (bytes(item, "utf-8"), self.map[item])
     def first(self):
         self._iter = self.__iter__()
         try:
@@ -383,15 +384,25 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         self.nmap_index = 0
         self.env = Environment(self)
         self.person_map = Map(Table(self._tables["Person"]))
+        self.person_id_map = {}
         self.family_map = Map(Table(self._tables["Family"]))
+        self.family_id_map = {}
         self.place_map  = Map(Table(self._tables["Place"]))
+        self.place_id_map = {}
         self.citation_map = Map(Table(self._tables["Citation"]))
+        self.citation_id_map = {}
         self.source_map = Map(Table(self._tables["Source"]))
+        self.source_id_map = {}
         self.repository_map  = Map(Table(self._tables["Repository"]))
+        self.repository_id_map = {}
         self.note_map = Map(Table(self._tables["Note"]))
+        self.note_id_map = {}
         self.media_map  = Map(Table(self._tables["Media"]))
+        self.media_id_map = {}
         self.event_map  = Map(Table(self._tables["Event"]))
+        self.event_id_map = {}
         self.tag_map  = Map(Table(self._tables["Tag"]))
+        self.tag_id_map = {}
         self.metadata   = Map(Table({"cursor_func": lambda: MetaCursor()}))
         self.name_group = {}
         self.undo_callback = None
@@ -407,6 +418,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         self.full_name = None
         self.path = None
         self.brief_name = None
+        self.genderStats = GenderStats() # can pass in loaded stats as dict
+        self.owner = Researcher()
         if directory:
             self.load(directory)
 
@@ -425,12 +438,15 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return None
 
     def transaction_commit(self, txn):
+        ## FIXME
         pass
 
     def get_undodb(self):
+        ## FIXME
         return None
 
     def transaction_abort(self, txn):
+        ## FIXME
         pass
 
     @staticmethod
@@ -687,10 +703,12 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         ## Fixme: implement sort
         return self.person_map.keys()
 
-    def get_family_handles(self):
+    def get_family_handles(self, sort_handles=False):
+        ## Fixme: implement sort
         return self.family_map.keys()
 
     def get_event_handles(self, sort_handles=False):
+        ## Fixme: implement sort
         return self.event_map.keys()
 
     def get_citation_handles(self, sort_handles=False):
@@ -705,78 +723,80 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         ## Fixme: implement sort
         return self.place_map.keys()
 
-    def get_repository_handles(self):
+    def get_repository_handles(self, sort_handles=False):
+        ## Fixme: implement sort
         return self.repository_map.keys()
 
     def get_media_object_handles(self, sort_handles=False):
         ## Fixme: implement sort
         return self.media_map.keys()
 
-    def get_note_handles(self):
+    def get_note_handles(self, sort_handles=False):
+        ## Fixme: implement sort
         return self.note_map.keys()
 
     def get_tag_handles(self, sort_handles=False):
-        # FIXME: sort
+        # FIXME: implement sort
         return self.tag_map.keys()
 
     def get_event_from_handle(self, handle):
         event = None
         if handle in self.event_map:
-            event = self.event_map[handle]
+            event = Event.create(self.event_map[handle])
         return event
 
     def get_family_from_handle(self, handle): 
         family = None
         if handle in self.family_map:
-            family = self.family_map[handle]
+            family = Family.create(self.family_map[handle])
         return family
 
     def get_repository_from_handle(self, handle):
         repository = None
         if handle in self.repository_map:
-            repository = self.repository_map[handle]
+            repository = Repository.create(self.repository_map[handle])
         return repository
 
     def get_person_from_handle(self, handle):
         person = None
         if handle in self.person_map:
-            person = self.person_map[handle]
+            person = Person.create(self.person_map[handle])
         return person
 
     def get_place_from_handle(self, handle):
         place = None
         if handle in self.place_map:
-            place = self.place_map[handle]
+            place = Place.create(self.place_map[handle])
         return place
 
     def get_citation_from_handle(self, handle):
         citation = None
         if handle in self.citation_map:
-            citation = self.citation_map[handle]
+            citation = Citation.create(self.citation_map[handle])
         return citation
 
     def get_source_from_handle(self, handle):
         source = None
         if handle in self.source_map:
-            source = self.source_map[handle]
+            source = Source.create(self.source_map[handle])
         return source
 
     def get_note_from_handle(self, handle):
         note = None
         if handle in self.note_map:
-            note = self.note_map[handle]
+            note = Note.create(self.note_map[handle])
         return note
 
     def get_object_from_handle(self, handle):
         media = None
         if handle in self.media_map:
-            media = self.media_map[handle]
+            media = MediaObject.create(self.media_map[handle])
         return media
 
     def get_tag_from_handle(self, handle):
         tag = None
         if handle in self.tag_map:
-            tag = self.tag_map[handle]
+            tag = Tag.create(self.tag_map[handle])
         return tag
 
     def get_default_person(self):
@@ -787,81 +807,73 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
             return None
 
     def iter_people(self):
-        return (person for person in self.person_map.values())
+        return (Person.create(person) for person in self.person_map.values())
 
     def iter_person_handles(self):
         return (handle for handle in self.person_map.keys())
 
     def iter_families(self):
-        return (family for family in self.family_map.values())
+        return (Family.create(family) for family in self.family_map.values())
 
     def iter_family_handles(self):
         return (handle for handle in self.family_map.keys())
 
     def get_tag_from_name(self, name):
-        for tag in self.tag_map.values():
+        ## Slow, but typically not too many tags:
+        for data in self.tag_map.values():
+            tag = Tag.create(data)
             if tag.name == name:
                 return tag
         return None
 
     def get_person_from_gramps_id(self, gramps_id):
-        for person in self.person_map.values():
+        if gramps_id in self.person_id_map:
-            if person.gramps_id == gramps_id:
+            return Person.create(self.person_id_map[gramps_id])
-                return person
         return None
 
     def get_family_from_gramps_id(self, gramps_id):
-        for family in self.family_map.values():
+        if gramps_id in self.family_id_map:
-            if family.gramps_id == gramps_id:
+            return Family.create(self.family_id_map[gramps_id])
-                return family
         return None
 
     def get_citation_from_gramps_id(self, gramps_id):
-        for citation in self.citation_map.values():
+        if gramps_id in self.citation_id_map:
-            if citation.gramps_id == gramps_id:
+            return Citation.create(self.citation_id_map[gramps_id])
-                return citation
         return None
 
     def get_source_from_gramps_id(self, gramps_id):
-        for source in self.source_map.values():
+        if gramps_id in self.source_id_map:
-            if source.gramps_id == gramps_id:
+            return Source.create(self.source_id_map[gramps_id])
-                return source
         return None
 
     def get_event_from_gramps_id(self, gramps_id):
-        for event in self.event_map.values():
+        if gramps_id in self.event_id_map:
-            if event.gramps_id == gramps_id:
+            return Event.create(self.event_id_map[gramps_id])
-                return event
         return None
 
     def get_media_from_gramps_id(self, gramps_id):
-        for media in self.media_map.values():
+        if gramps_id in self.media_id_map:
-            if media.gramps_id == gramps_id:
+            return MediaObject.create(self.media_id_map[gramps_id])
-                return media
         return None
 
     def get_place_from_gramps_id(self, gramps_id):
-        for place in self.place_map.values():
+        if gramps_id in self.place_id_map:
-            if place.gramps_id == gramps_id:
+            return Place.create(self.place_id_map[gramps_id])
-                return place
         return None
 
     def get_repository_from_gramps_id(self, gramps_id):
-        for repository in self.repository_map.values():
+        if gramps_id in self.repository_id_map:
-            if repository.gramps_id == gramps_id:
+            return Repository.create(self.repository_id_map[gramps_id])
-                return repository
         return None
 
     def get_note_from_gramps_id(self, gramps_id):
-        for note in self.note_map.values():
+        if gramps_id in self.note_id_map:
-            if note.gramps_id == gramps_id:
+            return Note.create(self.note_id_map[gramps_id])
-                return note
         return None
 
     def get_tag_from_gramps_id(self, gramps_id):
-        for tag in self.tag_map.values():
+        if gramps_id in self.tag_id_map:
-            if tag.gramps_id == gramps_id:
+            return Tag.create(self.tag_id_map[gramps_id])
-                return tag
         return None
 
     def get_number_of_people(self):
@@ -874,7 +886,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return len(self.place_map)
 
     def get_number_of_tags(self):
-        return 0 # FIXME
+        return len(self.tag_map)
 
     def get_number_of_families(self):
         return len(self.family_map)
@@ -895,52 +907,48 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return len(self.repository_map)
 
     def get_place_cursor(self):
-        return Cursor(self.place_map, self.get_raw_place_data)
+        return Cursor(self.place_map)
 
     def get_person_cursor(self):
-        return Cursor(self.person_map, self.get_raw_person_data)
+        return Cursor(self.person_map)
 
     def get_family_cursor(self):
-        return Cursor(self.family_map, self.get_raw_family_data)
+        return Cursor(self.family_map)
 
     def get_event_cursor(self):
-        return Cursor(self.event_map, self.get_raw_event_data)
+        return Cursor(self.event_map)
 
     def get_note_cursor(self):
-        return Cursor(self.note_map, self.get_raw_note_data)
+        return Cursor(self.note_map)
 
     def get_tag_cursor(self):
-        return Cursor(self.tag_map, self.get_raw_tag_data)
+        return Cursor(self.tag_map)
 
     def get_repository_cursor(self):
-        return Cursor(self.repository_map, self.get_raw_repository_data)
+        return Cursor(self.repository_map)
 
     def get_media_cursor(self):
-        return Cursor(self.media_map, self.get_raw_object_data)
+        return Cursor(self.media_map)
 
     def get_citation_cursor(self):
-        return Cursor(self.citation_map, self.get_raw_citation_data)
+        return Cursor(self.citation_map)
 
     def get_source_cursor(self):
-        return Cursor(self.source_map, self.get_raw_source_data)
+        return Cursor(self.source_map)
 
     def has_gramps_id(self, obj_key, gramps_id):
         key2table = {
-            PERSON_KEY:     self.person_map, 
+            PERSON_KEY:     self.person_id_map, 
-            FAMILY_KEY:     self.family_map, 
+            FAMILY_KEY:     self.family_id_map, 
-            SOURCE_KEY:     self.source_map, 
+            SOURCE_KEY:     self.source_id_map, 
-            CITATION_KEY:   self.citation_map, 
+            CITATION_KEY:   self.citation_id_map, 
-            EVENT_KEY:      self.event_map, 
+            EVENT_KEY:      self.event_id_map, 
-            MEDIA_KEY:      self.media_map, 
+            MEDIA_KEY:      self.media_id_map, 
-            PLACE_KEY:      self.place_map, 
+            PLACE_KEY:      self.place_id_map, 
-            REPOSITORY_KEY: self.repository_map, 
+            REPOSITORY_KEY: self.repository_id_map, 
-            NOTE_KEY:       self.note_map, 
+            NOTE_KEY:       self.note_id_map, 
             }
-        map = key2table[obj_key]
+        return gramps_id in key2table[obj_key]
-        for item in map.values():
-            if item.gramps_id == gramps_id:
-                return True
-        return False
 
     def has_person_handle(self, handle):
         return handle in self.person_map
@@ -981,59 +989,61 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         pass
 
     def set_default_person_handle(self, handle):
+        ## FIXME
         pass
 
     def set_mediapath(self, mediapath):
+        ## FIXME
         pass
 
     def get_raw_person_data(self, handle):
         if handle in self.person_map:
-            return self.person_map[handle].serialize()
+            return self.person_map[handle]
         return None
 
     def get_raw_family_data(self, handle):
         if handle in self.family_map:
-            return self.family_map[handle].serialize()
+            return self.family_map[handle]
         return None
 
     def get_raw_citation_data(self, handle):
         if handle in self.citation_map:
-            return self.citation_map[handle].serialize()
+            return self.citation_map[handle]
         return None
 
     def get_raw_source_data(self, handle):
         if handle in self.source_map:
-            return self.source_map[handle].serialize()
+            return self.source_map[handle]
         return None
 
     def get_raw_repository_data(self, handle):
         if handle in self.repository_map:
-            return self.repository_map[handle].serialize()
+            return self.repository_map[handle]
         return None
 
     def get_raw_note_data(self, handle):
         if handle in self.note_map:
-            return self.note_map[handle].serialize()
+            return self.note_map[handle]
         return None
 
     def get_raw_place_data(self, handle):
         if handle in self.place_map:
-            return self.place_map[handle].serialize()
+            return self.place_map[handle]
         return None
 
     def get_raw_object_data(self, handle):
         if handle in self.media_map:
-            return self.media_map[handle].serialize()
+            return self.media_map[handle]
         return None
 
     def get_raw_tag_data(self, handle):
         if handle in self.tag_map:
-            return self.tag_map[handle].serialize()
+            return self.tag_map[handle]
         return None
 
     def get_raw_event_data(self, handle):
         if handle in self.event_map:
-            return self.event_map[handle].serialize()
+            return self.event_map[handle]
         return None
 
     def add_person(self, person, trans, set_gid=True):
@@ -1127,7 +1137,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "person-update"
             else:
                 emit = "person-add"
-        self.person_map[person.handle] = person
+        self.person_map[person.handle] = person.serialize()
+        self.person_id_map[person.gramps_id] = self.person_map[person.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([person.handle],))
@@ -1139,7 +1150,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "family-update"
             else:
                 emit = "family-add"
-        self.family_map[family.handle] = family
+        self.family_map[family.handle] = family.serialize()
+        self.family_id_map[family.gramps_id] = self.family_map[family.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([family.handle],))
@@ -1151,7 +1163,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "citation-update"
             else:
                 emit = "citation-add"
-        self.citation_map[citation.handle] = citation
+        self.citation_map[citation.handle] = citation.serialize()
+        self.citation_id_map[citation.gramps_id] = self.citation_map[citation.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([citation.handle],))
@@ -1163,7 +1176,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "source-update"
             else:
                 emit = "source-add"
-        self.source_map[source.handle] = source
+        self.source_map[source.handle] = source.serialize()
+        self.source_id_map[source.gramps_id] = self.source_map[source.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([source.handle],))
@@ -1175,7 +1189,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "repository-update"
             else:
                 emit = "repository-add"
-        self.repository_map[repository.handle] = repository
+        self.repository_map[repository.handle] = repository.serialize()
+        self.repository_id_map[repository.gramps_id] = self.repository_map[repository.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([repository.handle],))
@@ -1187,7 +1202,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "note-update"
             else:
                 emit = "note-add"
-        self.note_map[note.handle] = note
+        self.note_map[note.handle] = note.serialize()
+        self.note_id_map[note.gramps_id] = self.note_map[note.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([note.handle],))
@@ -1199,7 +1215,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "place-update"
             else:
                 emit = "place-add"
-        self.place_map[place.handle] = place
+        self.place_map[place.handle] = place.serialize()
+        self.place_id_map[place.gramps_id] = self.place_map[place.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([place.handle],))
@@ -1211,7 +1228,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "event-update"
             else:
                 emit = "event-add"
-        self.event_map[event.handle] = event
+        self.event_map[event.handle] = event.serialize()
+        self.event_id_map[event.gramps_id] = self.event_map[event.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([event.handle],))
@@ -1223,7 +1241,8 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "tag-update"
             else:
                 emit = "tag-add"
-        self.tag_map[tag.handle] = tag
+        self.tag_map[tag.handle] = tag.serialize()
+        self.tag_id_map[tag.gramps_id] = self.tag_map[tag.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([tag.handle],))
@@ -1235,34 +1254,35 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 emit = "media-update"
             else:
                 emit = "media-add"
-        self.media_map[media.handle] = media
+        self.media_map[media.handle] = media.serialize()
+        self.media_id_map[media.gramps_id] = self.media_map[media.handle]
         # Emit after added:
         if emit:
             self.emit(emit, ([media.handle],))
 
     def get_gramps_ids(self, obj_key):
         key2table = {
-            PERSON_KEY:     self.person_map, 
+            PERSON_KEY:     self.person_id_map, 
-            FAMILY_KEY:     self.family_map, 
+            FAMILY_KEY:     self.family_id_map, 
-            CITATION_KEY:   self.citation_map, 
+            CITATION_KEY:   self.citation_id_map, 
-            SOURCE_KEY:     self.source_map, 
+            SOURCE_KEY:     self.source_id_map, 
-            EVENT_KEY:      self.event_map, 
+            EVENT_KEY:      self.event_id_map, 
-            MEDIA_KEY:      self.media_map, 
+            MEDIA_KEY:      self.media_id_map, 
-            PLACE_KEY:      self.place_map, 
+            PLACE_KEY:      self.place_id_map, 
-            REPOSITORY_KEY: self.repository_map, 
+            REPOSITORY_KEY: self.repository_id_map, 
-            NOTE_KEY:       self.note_map, 
+            NOTE_KEY:       self.note_id_map, 
             }
-        table = key2table[obj_key]
+        return list(key2table[obj_key].keys())
-        return [item.gramps_id for item in table.values()]
 
     def transaction_begin(self, transaction):
+        ## FIXME
         return 
 
-    def disable_signals(self):
-        pass
-
     def set_researcher(self, owner):
-        pass
+        self.owner.set_from(owner)
+
+    def get_researcher(self):
+        return self.owner
 
     def request_rebuild(self):
         self.emit('person-rebuild')
@@ -1332,7 +1352,9 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         if self.readonly or not handle:
             return
         if handle in self.person_map:
+            person = Person.create(self.person_map[handle])
             del self.person_map[handle]
+            del self.person_id_map[person.gramps_id]
             self.emit("person-delete", ([handle],))
 
     def remove_source(self, handle, transaction):
@@ -1341,7 +1363,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.source_map, 
-                              SOURCE_KEY)
+                         self.source_id_map, SOURCE_KEY)
 
     def remove_citation(self, handle, transaction):
         """
@@ -1349,7 +1371,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.citation_map, 
-                              CITATION_KEY)
+                         self.citation_id_map, CITATION_KEY)
 
     def remove_event(self, handle, transaction):
         """
@@ -1357,7 +1379,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.event_map, 
-                              EVENT_KEY)
+                         self.event_id_map, EVENT_KEY)
 
     def remove_object(self, handle, transaction):
         """
@@ -1365,7 +1387,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.media_map, 
-                              MEDIA_KEY)
+                         self.media_id_map, MEDIA_KEY)
 
     def remove_place(self, handle, transaction):
         """
@@ -1373,7 +1395,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.place_map, 
-                              PLACE_KEY)
+                         self.place_id_map, PLACE_KEY)
 
     def remove_family(self, handle, transaction):
         """
@@ -1381,7 +1403,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.family_map, 
-                              FAMILY_KEY)
+                         self.family_id_map, FAMILY_KEY)
 
     def remove_repository(self, handle, transaction):
         """
@@ -1389,7 +1411,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.repository_map, 
-                              REPOSITORY_KEY)
+                         self.repository_id_map, REPOSITORY_KEY)
 
     def remove_note(self, handle, transaction):
         """
@@ -1397,7 +1419,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.note_map, 
-                              NOTE_KEY)
+                         self.note_id_map, NOTE_KEY)
 
     def remove_tag(self, handle, transaction):
         """
@@ -1405,7 +1427,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         database, preserving the change in the passed transaction. 
         """
         self.__do_remove(handle, transaction, self.tag_map, 
-                              TAG_KEY)
+                         self.tag_id_map, TAG_KEY)
 
     def is_empty(self):
         """
@@ -1416,13 +1438,13 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
                 return False
         return True
 
-    def __do_remove(self, handle, transaction, data_map, key):
+    def __do_remove(self, handle, transaction, data_map, data_id_map, key):
         if self.readonly or not handle:
             return
-        if isinstance(handle, str):
-            handle = handle.encode('utf-8')
         if handle in data_map:
+            obj = self._tables[KEY_TO_CLASS_MAP[key]]["class_func"].create(data_map[handle])
             del data_map[handle]
+            del data_id_map[obj.gramps_id]
             self.emit(KEY_TO_NAME_MAP[key] + "-delete", ([handle],))
 
     def delete_primary_from_reference_map(self, handle, transaction, txn=None):
@@ -1486,6 +1508,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
     ## Missing:
 
     def backup(self):
+        ## FIXME
         pass
 
     def close(self):
@@ -1499,6 +1522,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
             touch(filename)
 
     def find_backlink_handles(self, handle, include_classes=None):
+        ## FIXME
         return []
 
     def find_initial_person(self):
@@ -1508,22 +1532,30 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return None
 
     def find_place_child_handles(self, handle):
+        ## FIXME
         return []
 
     def get_bookmarks(self):
         return self.bookmarks
 
     def get_child_reference_types(self):
+        ## FIXME
         return []
 
     def get_citation_bookmarks(self):
         return self.citation_bookmarks
 
     def get_cursor(self, table, txn=None, update=False, commit=False):
+        ## FIXME
+        ## called from a complete find_back_ref
         pass
 
-    def get_dbname(self):
+    # cursors for lookups in the reference_map for back reference
-        return "DictionaryDb"
+    # lookups. The reference_map has three indexes:
+    # the main index: a tuple of (primary_handle, referenced_handle)
+    # the primary_handle index: the primary_handle
+    # the referenced_handle index: the referenced_handle
+    # the main index is unique, the others allow duplicate entries.
 
     def get_default_handle(self):
         items = self.person_map.keys()
@@ -1532,124 +1564,141 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return None
 
     def get_event_attribute_types(self):
+        ## FIXME
         return []
 
     def get_event_bookmarks(self):
         return self.event_bookmarks
 
     def get_event_roles(self):
+        ## FIXME
         return []
 
     def get_event_types(self):
+        ## FIXME
         return []
 
     def get_family_attribute_types(self):
+        ## FIXME
         return []
 
     def get_family_bookmarks(self):
         return self.family_bookmarks
 
     def get_family_event_types(self):
+        ## FIXME
         return []
 
     def get_family_relation_types(self):
+        ## FIXME
         return []
 
     def get_media_attribute_types(self):
+        ## FIXME
         return []
 
     def get_media_bookmarks(self):
         return self.media_bookmarks
 
     def get_name_types(self):
+        ## FIXME
         return []
 
     def get_note_bookmarks(self):
         return self.note_bookmarks
 
     def get_note_types(self):
+        ## FIXME
         return []
 
-    def get_number_of_records(self, table):
-        return 0
-
     def get_origin_types(self):
+        ## FIXME
         return []
 
     def get_person_attribute_types(self):
+        ## FIXME
         return []
 
     def get_person_event_types(self):
+        ## FIXME
         return []
 
     def get_place_bookmarks(self):
         return self.place_bookmarks
 
     def get_place_tree_cursor(self):
+        ## FIXME
         return []
 
     def get_place_types(self):
+        ## FIXME
         return []
 
     def get_repo_bookmarks(self):
         return self.repo_bookmarks
 
     def get_repository_types(self):
+        ## FIXME
         return []
 
     def get_save_path(self):
         return self._directory
 
     def get_source_attribute_types(self):
+        ## FIXME
         return []
 
     def get_source_bookmarks(self):
         return self.source_bookmarks
 
     def get_source_media_types(self):
+        ## FIXME
         return []
 
     def get_surname_list(self):
+        ## FIXME
         return []
 
     def get_url_types(self):
+        ## FIXME
         return []
 
     def has_changed(self):
+        ## FIXME
         return True
 
     def is_open(self):
-        return True
+        return self._directory is not None
 
     def iter_citation_handles(self):
         return (key for key in self.citation_map.keys())
 
     def iter_citations(self):
-        return (key for key in self.citation_map.values())
+        return (Citation.create(key) for key in self.citation_map.values())
 
     def iter_event_handles(self):
         return (key for key in self.event_map.keys())
 
     def iter_events(self):
-        return (key for key in self.event_map.values())
+        return (Events.create(key) for key in self.event_map.values())
 
     def iter_media_objects(self):
-        return (key for key in self.media_map.values())
+        return (MediaObject.create(key) for key in self.media_map.values())
 
     def iter_note_handles(self):
         return (key for key in self.note_map.keys())
 
     def iter_notes(self):
-        return (key for key in self.note_map.values())
+        return (Note.create(key) for key in self.note_map.values())
 
     def iter_place_handles(self):
         return (key for key in self.place_map.keys())
 
     def iter_places(self):
-        return (key for key in self.place_map.values())
+        return (Place.create(key) for key in self.place_map.values())
 
     def iter_repositories(self):
-        return (key for key in self.repositories_map.values())
+        return (Repository.create(key) for key in self.repositories_map.values())
 
     def iter_repository_handles(self):
         return (key for key in self.repositories_map.keys())
@@ -1658,13 +1707,13 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return (key for key in self.source_map.keys())
 
     def iter_sources(self):
-        return (key for key in self.source_map.values())
+        return (Source.create(key) for key in self.source_map.values())
 
     def iter_tag_handles(self):
         return (key for key in self.tag_map.keys())
 
     def iter_tags(self):
-        return (key for key in self.tag_map.values())
+        return (Tag.create(key) for key in self.tag_map.values())
 
     def load(self, directory, pulse_progress=None, mode=None, 
              force_schema_upgrade=False, 
@@ -1682,16 +1731,20 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
             importData(self, filename, User())
 
     def prepare_import(self):
+        ## FIXME
         pass
 
     def redo(self, update_history=True):
+        ## FIXME
         pass
 
     def restore(self):
+        ## FIXME
         pass
 
     def set_prefixes(self, person, media, family, source, citation, 
                      place, event, repository, note):
+        ## FIXME
         pass
 
     def set_save_path(self, directory):
@@ -1701,6 +1754,7 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         self.brief_name = os.path.basename(self._directory)
 
     def undo(self, update_history=True):
+        ## FIXME
         pass
 
     def write_version(self, directory):
@@ -1749,3 +1803,10 @@ class DictionaryDb(DbWriteBase, DbReadBase, UpdateCallback, Callback):
             name = None
         return name
 
+    def reindex_reference_map(self):
+        ## FIXME
+        pass
+
+    def rebuild_secondary(self, update):
+        ## FIXME
+        pass

gramps/plugins/database/djangodb.py

@@ -44,7 +44,7 @@ from gramps.gen.const import GRAMPS_LOCALE as glocale
 _ = glocale.translation.gettext
 from gramps.gen.lib import (Person, Family, Event, Place, Repository, 
                             Citation, Source, Note, MediaObject, Tag, 
-                            Researcher)
+                            Researcher, GenderStats)
 from gramps.gen.db import DbReadBase, DbWriteBase, DbTxn
 from gramps.gen.db.undoredo import DbUndo
 from gramps.gen.utils.callback import Callback
@@ -352,6 +352,8 @@ class DbDjango(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         self.full_name = None
         self.path = None
         self.brief_name = None
+        self.genderStats = GenderStats() # can pass in loaded stats as dict
+        self.owner = Researcher()
         if directory:
             self.load(directory)
 
@@ -788,8 +790,7 @@ class DbDjango(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return None
 
     def get_researcher(self):
-        obj = Researcher()
+        return self.owner
-        return obj
 
     def get_tag_handles(self, sort_handles=False):
         if sort_handles:
@@ -1704,7 +1705,7 @@ class DbDjango(DbWriteBase, DbReadBase, UpdateCallback, Callback):
         return 
 
     def set_researcher(self, owner):
-        pass
+        self.owner.set_from(owner)
 
     def copy_from_db(self, db):
         """
@@ -2037,9 +2038,10 @@ class DbDjango(DbWriteBase, DbReadBase, UpdateCallback, Callback):
 
     def remove_from_surname_list(self, person):
         ## FIXME
+        ## called by a complete commit_person
         pass
     
-    ## missing
+    ## was missing
 
     def find_place_child_handles(self, handle):
         pass
@@ -2146,3 +2148,8 @@ class DbDjango(DbWriteBase, DbReadBase, UpdateCallback, Callback):
             name = None
         return name
 
+    def reindex_reference_map(self):
+        pass
+
+    def rebuild_secondary(self, update):
+        pass