Changes between Version 15 and Version 16 of new_meta_api

Timestamp:

Jul 11, 2014, 8:32:45 AM (11 years ago)

Author:

pirosb3

Comment:

--

new_meta_api

@@ -257 +257 @@
 The downsides if this aspect is that we cache a bit more naively (there are less layers of caching) but benchmarks show this does not
 decrease performance.
+
+==== Used internal caching instead of lru_cache
+Our first approach to caching was to use functools.lru_cache. lru_cache is a simple decorator that provides cache and an expiry function
+built-it. It worked correctly with the new API but cProfile quickly showed how a lot of computing time was done inside lru_cache itself.
+
+The decision taken was to do very caching with simple try / catch and a dictionary for memoizing. This is also because we really don't need
+the 'lru' part of 'lru_caching': there are only a finite number of combinations that can be called.
+
+==== Used internal caching instead of lru_cache
+Our first approach to caching was to use functools.lru_cache. lru_cache is a simple decorator that provides cache and an expiry function
+built-it. It worked correctly with the new API but cProfile quickly showed how a lot of computing time was done inside lru_cache itself.
+
+The decision taken was to do very caching with simple try / catch and a dictionary for memoizing. This is also because we really don't need
+the 'lru' part of 'lru_caching': there are only a finite number of combinations that can be called.
+
+==== Use cached_properties when possible
+Function calls are expensive in Python, All sensible attributes with no arguments have been transformed into cached_properties.
+A cached property is a read-only property that is calculated on demand and automatically cached. If the value has already been calculated,
+the cached value is returned. Cached properties avoid a new stack and are used for fast-access to fields, concrete_fields,
+local_concrete_fields, many_to_many, field_names
+
+==== enabled m2m fields by default on get_field
+The old get_field API was defined as follows:
+
+{{{
+    def get_fields(self, field_name, many_to_many=True)
+}}}
+
+Our first iteration of the API was to refactor this as
+
+{{{
+    def get_fields(self, field_name, include_related=True)
+}}}
+
+This was done for 2 reasons:
+1) We managed to squash 2 functions (get_field and get_field_by_name) in 1 single call
+2) I could not find any reason for the many_to_many flag to exist! there can never be data and m2m fields with the same name. So this looked
+like a legacy parameter that didn't have any effect (because turning it off did not break any tests)
+
+Finally, the reason the many_to_many flag existed was for a special validation case that was not documented anywhere. Russell helped me in
+looking for edge cases and finally I came up with a failing test case: https://github.com/django/django/pull/2893. The test case would fail on the
+new API but succeed on master.
+
+Our final iteration was to add all the field types as flags to get_field. By making m2m as first parameter, we avoid breaking existing implementations
+and maintain a similarity with the 'get_fields' API.