fix: Improve performance up to 50%

Author: n0nSmoker

sqlalchemy_serializer/lib/fields.py

@@ -1,8 +1,25 @@
-import functools
 import inspect
 
 from sqlalchemy import inspect as sql_inspect
 
+# Cache for get_serializable_keys results,
+# keyed by (class, serializable_keys_tuple, auto_serialize_properties)
+_serializable_keys_cache: dict[tuple[type, tuple | None, bool], set[str]] = {}
+
+
+def _get_cache_key(model_instance) -> tuple[type, tuple | None, bool]:
+    """Generate cache key from model instance configuration.
+
+    :param model_instance: Model instance to extract cache key from
+    :return: Tuple of (class, serializable_keys_tuple, auto_serialize_properties)
+    """
+    cls = model_instance.__class__
+    serializable_keys = (
+        tuple(model_instance.serializable_keys) if model_instance.serializable_keys else None
+    )
+    auto_serialize_properties = bool(model_instance.auto_serialize_properties)
+    return (cls, serializable_keys, auto_serialize_properties)
+
 
 def get_sql_field_names(model_instance) -> set[str]:
     """:return:  set of sql fields names
@@ -18,18 +35,27 @@ def get_property_field_names(model_instance) -> set[str]:
     return {name for name, member in inspect.getmembers(cls) if isinstance(member, property)}
 
 
-@functools.lru_cache
 def get_serializable_keys(model_instance) -> set[str]:
     """:return: set of keys available for serialization
     :raise:  sqlalchemy.exc.NoInspectionAvailable if model_instance is not an sqlalchemy mapper
+
+    Results are cached by class and configuration
+    (serializable_keys, auto_serialize_properties)
+    rather than by instance, improving cache efficiency
+    for collections of the same model type.
     """
+    cache_key = _get_cache_key(model_instance)
+
+    if cache_key in _serializable_keys_cache:
+        return _serializable_keys_cache[cache_key]
+
     if model_instance.serializable_keys:
         result = set(model_instance.serializable_keys)
-
     else:
         result = get_sql_field_names(model_instance)
 
         if model_instance.auto_serialize_properties:
             result.update(get_property_field_names(model_instance))
 
+    _serializable_keys_cache[cache_key] = result
     return result

tests/test_complex_nested_models.py

@@ -622,9 +622,7 @@ def test_serialize_columns_nested_model_fields(get_instance):
         serialize_columns={
             "string": lambda v: v.lower() if v else None,
             "model": (
-                lambda v: {"custom_id": v.id, "custom_string": v.string.upper()}
-                if v
-                else None
+                lambda v: {"custom_id": v.id, "custom_string": v.string.upper()} if v else None
             ),
         }
     )

tests/test_performance.py

@@ -199,3 +199,23 @@ def serialize():
     assert isinstance(result, dict)
     assert "date" in result
     assert "money" in result
+
+
+def test_benchmark_large_collection_serialization(benchmark, get_instance):
+    """Benchmark serialization of a large collection to measure cache efficiency.
+
+    This test demonstrates the performance benefit of class-based caching:
+    - Serializing 1000 instances of the same model class should benefit from
+      a single cache entry for get_serializable_keys() instead of 1000 entries.
+    """
+    # Create a large collection of the same model type
+    models = [get_instance(FlatModel) for _ in range(1000)]
+
+    def serialize():
+        return serialize_collection(models, only=("id", "string", "bool", "datetime"))
+
+    result = benchmark(serialize)
+    assert isinstance(result, list)
+    assert len(result) == 1000
+    assert all(isinstance(item, dict) for item in result)
+    assert all("id" in item for item in result)