IdSync: write property flags to JSON only if non-zero #25

Also, add some TODOs to add dicts for faster lookups

Author: greenrobot

example/ollama/objectbox-model.json

@@ -18,8 +18,7 @@
         {
           "id": "2:7160924628219144152",
           "name": "document",
-          "type": 9,
-          "flags": 0
+          "type": 9
         },
         {
           "id": "3:1544317969640594905",

objectbox/model/idsync.py

@@ -10,6 +10,12 @@
 
 
 class IdSync:
+    """
+    Synchronizes a model with the IDs from model JSON file.
+    After syncing, the model will have all IDs assigned.
+    The JSON file is written (from scratch) based on the model.
+    """
+
     def __init__(self, model: Model, model_json_filepath: str):
         self.model = model
 
@@ -63,8 +69,9 @@ def _save_model_json(self):
                     "id": str(prop.iduid),
                     "name": prop.name,
                     "type": prop._ob_type,
-                    "flags": prop._flags
                 }
+                if prop._flags != 0:
+                    prop_json["flags"] = prop._flags
                 if prop.index is not None:
                     prop_json["indexId"] = str(prop.index.iduid)
                 entity_json["properties"].append(prop_json)
@@ -80,6 +87,7 @@ def _find_entity_json_by_uid(self, uid: int) -> Optional[Dict[str, Any]]:
         """ Finds entity JSON by UID. """
         if self.model_json is None:
             return None
+        # TODO put entities in a dict (e.g. while/after loading) for faster lookup
         for entity_json in self.model_json["entities"]:
             if IdUid.from_str(entity_json["id"]).uid == uid:
                 return entity_json
@@ -89,20 +97,23 @@ def _find_entity_json_by_name(self, entity_name: str) -> Optional[Dict[str, Any]
         """ Finds entity JSON by name. """
         if self.model_json is None:
             return None
+        # TODO put entities in a dict (e.g. while/after loading) for faster lookup
         for entity_json in self.model_json["entities"]:
             if entity_json["name"] == entity_name:
                 return entity_json
         return None
 
     def _find_property_json_by_uid(self, entity_json: Dict[str, Any], uid: int) -> Optional[Dict[str, Any]]:
         """ Finds entity property JSON by property UID. """
+        # TODO put properties in a multi-dict (e.g. while/after loading) for faster lookup
         for prop_json in entity_json["properties"]:
             if IdUid.from_str(prop_json["id"]).uid == uid:
                 return prop_json
         return None
 
     def _find_property_json_by_name(self, entity_json: Dict[str, Any], prop_name: str) -> Optional[Dict[str, Any]]:
         """ Finds entity property JSON by property name. """
+        # TODO put properties in a multi-dict (e.g. while/after loading) for faster lookup
         for prop_json in entity_json["properties"]:
             if prop_json["name"] == prop_name:
                 return prop_json
@@ -113,6 +124,7 @@ def _generate_uid() -> int:
         return random.getrandbits(63) + 1  # 0 would be invalid
 
     def _validate_uid_unassigned(self, uid: int):
+        # TODO use a dict/set for all assigned UIDs (for all entities/properties/indexes) for faster lookup
         """ Validates that a user supplied UID is not assigned for any other entity/property/index.
         Raises a ValueError if the UID is already assigned elsewhere.
         """
@@ -141,9 +153,12 @@ def _validate_matching_prop(self, entity: _Entity, prop: Property, prop_json: Di
             #    raise ValueError(f"name {prop.name} != name {prop_json['name']} (in JSON)")
             if prop._ob_type != prop_json["type"]:
                 raise ValueError(f"OBX type {prop._ob_type} != OBX type {prop_json['type']} (in JSON)")
-            elif prop._flags != prop_json["flags"]:
-                raise ValueError(f"flags {prop._flags} != flags {prop_json['flags']} (in JSON)")
-            elif prop.index is None and "indexId" in prop_json:
+
+            json_flags = prop_json.get("flags", 0)
+            if prop._flags != json_flags:
+                raise ValueError(f"flags {prop._flags} != flags {json_flags} (in JSON)")
+
+            if prop.index is None and "indexId" in prop_json:
                 raise ValueError("property hasn't index, but index found in JSON")
             elif prop.index is not None and "indexId" not in prop_json:
                 raise ValueError("property has index, but index not found in JSON")
@@ -169,7 +184,7 @@ def _load_or_assign_index(self, entity: _Entity, prop: Property, prop_json: Opti
 
         if (iduid_json is not None) and (not index.has_uid() or index.iduid.uid == iduid_json.uid):  # Load
             index.iduid = IdUid.from_str(prop_json["indexId"])
-        else:  # Assign
+        else:  # Assign new ID to new index
             index.iduid = IdUid(self.model.last_index_iduid.id + 1, index.uid)
             self.model.last_index_iduid = index.iduid
 
@@ -186,11 +201,11 @@ def _load_or_assign_property(self, entity: _Entity, prop: Property, entity_json:
             if entity_json is not None:
                 prop_json = self._find_property_json_by_name(entity_json, prop.name)
 
-        if prop_json is not None:  # Load
+        if prop_json is not None:  # Load existing IDs from JSON
             # Property was matched with a JSON property (either by UID or by name), make sure they're equal
             self._validate_matching_prop(entity, prop, prop_json)
             prop.iduid = IdUid.from_str(prop_json["id"])
-        else:  # Assign
+        else:  # Assign new ID to new property
             if not prop.has_uid():
                 prop.iduid.uid = self._generate_uid()
             prop.iduid = IdUid(entity.last_property_iduid.id + 1, prop.iduid.uid)
@@ -209,10 +224,10 @@ def _load_or_assign_entity(self, entity: _Entity):
         else:
             entity_json = self._find_entity_json_by_name(entity.name)
 
-        if entity_json is not None:  # Load
+        if entity_json is not None:  # Load existing IDs from JSON
             entity.iduid = IdUid.from_str(entity_json["id"])
             entity.last_property_iduid = IdUid.from_str(entity_json["lastPropertyId"])
-        else:  # Assign
+        else:  # Assign new ID to new entity
             if not entity.has_uid():
                 entity.iduid.uid = self._generate_uid()
             entity.iduid = IdUid(self.model.last_entity_iduid.id + 1, entity.iduid.uid)

tests/test_idsync.py

@@ -64,25 +64,63 @@ def test_empty(env):
     # assert len(doc['retiredRelationUids']) == 0
     # assert len(doc['version']) == 1
 
-def test_basics(env):
+
+def test_json(env):
     @Entity()
     class MyEntity:
         id = Id()
-        name = String()
+        my_string = String()
+        my_string_indexed = String(index=Index())
+
     model = Model()
     model.entity(MyEntity)
     env.sync(model)
     doc = env.json()
-    # debug: pprint(doc) 
+    # debug: pprint(doc)
+
     json_e0 = doc['entities'][0]
     e0_id = json_e0['id']
     assert e0_id == str(MyEntity.iduid)
     assert e0_id.startswith("1:")
     assert json_e0['name'] == "MyEntity"
+
     json_p0 = json_e0['properties'][0]
     p0_id = json_p0['id']
     assert p0_id == str(MyEntity.get_property('id').iduid)
     assert p0_id.startswith("1:")
+    assert json_p0['name'] == "id"
+    assert json_p0['flags'] == 1
+    assert json_p0.get('indexId') is None
+
+    json_p1 = json_e0['properties'][1]
+    assert json_p1['id'] == str(MyEntity.get_property('my_string').iduid)
+    assert json_p1['name'] == "my_string"
+    assert json_p1.get('flags') is None
+    assert json_p1.get('indexId') is None
+
+    json_p2 = json_e0['properties'][2]
+    assert json_p2['id'] == str(MyEntity.get_property('my_string_indexed').iduid)
+    assert json_p2['name'] == "my_string_indexed"
+    assert json_p2['flags'] == 8
+    assert json_p2['indexId'] == str(MyEntity.get_property('my_string_indexed').index.iduid)
+    assert json_e0['lastPropertyId'] == json_p2['id']
+
+    assert doc['lastEntityId'] == e0_id
+    assert doc['lastIndexId'] == json_p2['indexId']
+
+
+def test_basics(env):
+    @Entity()
+    class MyEntity:
+        id = Id()
+        name = String()
+
+    model = Model()
+    model.entity(MyEntity)
+    env.sync(model)
+    assert MyEntity.id == 1
+    assert MyEntity.uid != 0
+    entity_ids = str(MyEntity.iduid)
 
     # create new database and populate with two objects
     store = env.store()
@@ -102,7 +140,7 @@ class MyEntity:
     model.entity(MyEntity)
     assert str(model.entities[0].iduid) == "0:0"
     env.sync(model)
-    assert str(model.entities[0].iduid) == e0_id
+    assert str(model.entities[0].iduid) == entity_ids
 
     # open existing database 
     store = env.store()