Customizable pgh_data pgh_diff for child objects

[Dufran]

Hi, encountered case when items in pgh_data and in pgh_diff should be not plain ids, but an object to give user context of what this event actually change.
Is there any way to change pgh_data and pgh_diff in case when field is foreign key or related object to return that model data?

[wesleykendall]

It sounds like you want to join on foreign keys that are in those dictionaries?

At the moment, there is no way to easily accomplish this. You would have to write some custom SQL.

We do have a way to do this with the unstructured context data, but unfortunately not on the Events proxy model like you're mentioning

[Dufran]

Yeah, i'm not sure this is possible on that method that forms this data.
I ended up doing inside of serializer to show related objects as their string representation, not ideal but gets thing done.

def lookup_obj_data_related_fields(obj, data) -> None:
    """Get the related fields of an object.
    Args:
        obj: The object to get the related fields from.
        data: The data to get the related fields from.
    """
    model_str = obj.pk.split(":")[0] if obj.pk else None
    model_class = None
    if model_str:
        app_label, model_name = model_str.split(".")
        model_class = apps.get_model(app_label, model_name)
    data = getattr(obj, "data", {})
    fields = data.keys()
    if model_class:
        for field in fields:
            try:
                model_field = model_class._meta.get_field(field)  # noqa: SLF001
                if model_field.is_relation and field in data:
                    related_model = model_field.related_model
                    related_id = data[field]
                    # If it's a M2M or reverse relation, skip (not a direct FK/OneToOne)
                    if model_field.many_to_many or model_field.one_to_many:
                        continue
                    # Replace the ID with the related object (serialized as dict)
                    related_obj = related_model.objects.filter(pk=related_id).first()
                    if related_obj:
                        # Use a simple serializer or __str__ if no serializer exists
                        data[field] = str(related_obj)
            except Exception as e:
                logger.exception(f"An error occurred while processing field: {e}")
                continue


def lookup_obj_diff_related_fields(obj, data) -> None:
    """Get the related fields of an object.
    Args:
        obj: The object to get the related fields from.
        data: The data to get the related fields from.
    """
    model_str = obj.pk.split(":")[0] if obj.pk else None
    model_class = None
    if model_str:
        app_label, model_name = model_str.split(".")
        model_class = apps.get_model(app_label, model_name)
    fields = data.keys()
    for field in fields:
        if model_class:
            try:
                model_field = model_class._meta.get_field(field)  # noqa: SLF001
                if model_field.is_relation and field in data:
                    related_model = model_field.related_model
                    start, end = data[field]
                    # If it's a M2M or reverse relation, skip (not a direct FK/OneToOne)
                    if model_field.many_to_many or model_field.one_to_many:
                        continue
                    # Replace the ID with the related object (serialized as dict)
                    start_obj = related_model.objects.filter(pk=start).first()
                    end_obj = related_model.objects.filter(pk=end).first()
                    data[field] = [str(start_obj) if start_obj else None, str(end_obj) if end_obj else None]
            except Exception as e:
                logger.exception(f"An error occurred while processing field: {e}")
                continue

then in serializer i just call this methods (diff and data are just annotations from pgh_data and pgh_diff fields, and done on ORM before serializer)

    @extend_schema_field(serializers.DictField())
    def get_diff(self, obj):
        data = getattr(obj, "diff", {}) or {}
        lookup_obj_diff_related_fields(obj, data)
        return data

    @extend_schema_field(serializers.DictField())
    def get_data(self, obj):
        data = getattr(obj, "data", {}) or {}
        lookup_obj_data_related_fields(obj, data)
        return data

[wesleykendall]

I see, so you are returning this information in an API?

The Events proxy model does a pretty large amount of work across potentially many history tables. Although it may perform well for small amounts of events, you may notice that it gets slower as your app grows. If you're only filtering for events in one table, for example, would definitely recommend filtering it down by that in your API.

I originally wrote it with the purpose of showing raw data in the admin. Interested to hear more about your use case though or if there are other interfaces we could expose in pghistory