Ver Fonte

Closes #23349: Avoid per-item queries in M2M table columns (#23727)

The contacts, circuit group assignment and port mapping columns read a
related object per item, so lists and CSV exports issued one query per
item. ManyToManyColumn now takes prefetch_related lookups, which the
table planner applies whenever it plans the column.
Martin Hauser há 20 horas atrás
pai
commit
5b402fe934

+ 2 - 1
netbox/circuits/tables/circuits.py

@@ -84,7 +84,8 @@ class CircuitTable(TenancyColumnsMixin, ContactsColumnMixin, PrimaryModelTable):
     assignments = columns.ManyToManyColumn(
     assignments = columns.ManyToManyColumn(
         accessor='group_assignments',
         accessor='group_assignments',
         verbose_name=_('Assignments'),
         verbose_name=_('Assignments'),
-        linkify_item=True
+        linkify_item=True,
+        prefetch_related=('group_assignments__group',)
     )
     )
 
 
     class Meta(PrimaryModelTable.Meta):
     class Meta(PrimaryModelTable.Meta):

+ 2 - 1
netbox/circuits/tables/virtual_circuits.py

@@ -69,7 +69,8 @@ class VirtualCircuitTable(TenancyColumnsMixin, ContactsColumnMixin, PrimaryModel
     assignments = columns.ManyToManyColumn(
     assignments = columns.ManyToManyColumn(
         accessor='group_assignments',
         accessor='group_assignments',
         verbose_name=_('Assignments'),
         verbose_name=_('Assignments'),
-        linkify_item=True
+        linkify_item=True,
+        prefetch_related=('group_assignments__group',)
     )
     )
 
 
     class Meta(PrimaryModelTable.Meta):
     class Meta(PrimaryModelTable.Meta):

+ 22 - 8
netbox/circuits/tests/test_tables.py

@@ -50,12 +50,15 @@ class CircuitTableTestCase(TableTestCases.StandardTableTestCase):
 
 
     @tag('regression')  # Ref: #23342
     @tag('regression')  # Ref: #23342
     def test_assignments_column(self):
     def test_assignments_column(self):
-        """The assignments column links the group assignments of each circuit."""
+        """The assignments column links the group assignments of each circuit without further queries."""
         url1, url2, url3 = (assignment.get_absolute_url() for assignment in self.assignments)
         url1, url2, url3 = (assignment.get_absolute_url() for assignment in self.assignments)
         self.user.config.set('tables.CircuitTable.columns', ['cid', 'assignments'], commit=True)
         self.user.config.set('tables.CircuitTable.columns', ['cid', 'assignments'], commit=True)
         table = CircuitTable(Circuit.objects.all())
         table = CircuitTable(Circuit.objects.all())
         table.configure(self.get_request())
         table.configure(self.get_request())
-        cells = {row.record.cid: row.get_cell('assignments') for row in table.rows}
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.cid: row.get_cell('assignments') for row in rows}
 
 
         self.assertHTMLEqual(
         self.assertHTMLEqual(
             cells['Circuit 1'],
             cells['Circuit 1'],
@@ -66,12 +69,15 @@ class CircuitTableTestCase(TableTestCases.StandardTableTestCase):
 
 
     @tag('regression')  # Ref: #23342
     @tag('regression')  # Ref: #23342
     def test_assignments_export(self):
     def test_assignments_export(self):
-        """An export lists the group assignments of each circuit."""
+        """An export lists the group assignments of each circuit without further queries."""
         table = CircuitTable(Circuit.objects.all())
         table = CircuitTable(Circuit.objects.all())
         table.configure(self.get_request())
         table.configure(self.get_request())
         # An "All Data" export prefetches for every column, hidden or not
         # An "All Data" export prefetches for every column, hidden or not
         table._apply_prefetching(columns=table.columns.names())
         table._apply_prefetching(columns=table.columns.names())
-        values = {row.record.cid: row.get_cell_value('assignments') for row in table.rows}
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.cid: row.get_cell_value('assignments') for row in rows}
 
 
         self.assertEqual(values, {
         self.assertEqual(values, {
             'Circuit 1': 'Circuit Group 1 (Primary), Circuit Group 2',
             'Circuit 1': 'Circuit Group 1 (Primary), Circuit Group 2',
@@ -140,13 +146,17 @@ class VirtualCircuitTableTestCase(TableTestCases.StandardTableTestCase):
         )
         )
         CircuitGroupAssignment.objects.bulk_create(cls.assignments)
         CircuitGroupAssignment.objects.bulk_create(cls.assignments)
 
 
+    @tag('regression')  # Ref: #23349
     def test_assignments_column(self):
     def test_assignments_column(self):
-        """The assignments column links the group assignments of each virtual circuit."""
+        """The assignments column links the group assignments of each virtual circuit without further queries."""
         url1, url2, url3 = (assignment.get_absolute_url() for assignment in self.assignments)
         url1, url2, url3 = (assignment.get_absolute_url() for assignment in self.assignments)
         self.user.config.set('tables.VirtualCircuitTable.columns', ['cid', 'assignments'], commit=True)
         self.user.config.set('tables.VirtualCircuitTable.columns', ['cid', 'assignments'], commit=True)
         table = VirtualCircuitTable(VirtualCircuit.objects.all())
         table = VirtualCircuitTable(VirtualCircuit.objects.all())
         table.configure(self.get_request())
         table.configure(self.get_request())
-        cells = {row.record.cid: row.get_cell('assignments') for row in table.rows}
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.cid: row.get_cell('assignments') for row in rows}
 
 
         self.assertHTMLEqual(
         self.assertHTMLEqual(
             cells['Virtual Circuit 1'],
             cells['Virtual Circuit 1'],
@@ -155,13 +165,17 @@ class VirtualCircuitTableTestCase(TableTestCases.StandardTableTestCase):
         self.assertHTMLEqual(cells['Virtual Circuit 2'], f'<a href="{url3}">Circuit Group 1 (Secondary)</a>')
         self.assertHTMLEqual(cells['Virtual Circuit 2'], f'<a href="{url3}">Circuit Group 1 (Secondary)</a>')
         self.assertEqual(cells['Virtual Circuit 3'], table.columns['assignments'].default)
         self.assertEqual(cells['Virtual Circuit 3'], table.columns['assignments'].default)
 
 
+    @tag('regression')  # Ref: #23349
     def test_assignments_export(self):
     def test_assignments_export(self):
-        """An export lists the group assignments of each virtual circuit."""
+        """An export lists the group assignments of each virtual circuit without further queries."""
         table = VirtualCircuitTable(VirtualCircuit.objects.all())
         table = VirtualCircuitTable(VirtualCircuit.objects.all())
         table.configure(self.get_request())
         table.configure(self.get_request())
         # An "All Data" export prefetches for every column, hidden or not
         # An "All Data" export prefetches for every column, hidden or not
         table._apply_prefetching(columns=table.columns.names())
         table._apply_prefetching(columns=table.columns.names())
-        values = {row.record.cid: row.get_cell_value('assignments') for row in table.rows}
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.cid: row.get_cell_value('assignments') for row in rows}
 
 
         self.assertEqual(values, {
         self.assertEqual(values, {
             'Virtual Circuit 1': 'Circuit Group 1 (Primary), Circuit Group 2',
             'Virtual Circuit 1': 'Circuit Group 1 (Primary), Circuit Group 2',

+ 4 - 2
netbox/dcim/tables/devices.py

@@ -821,7 +821,8 @@ class FrontPortTable(ModularDeviceComponentTable, CableTerminationTable):
     )
     )
     mappings = columns.ManyToManyColumn(
     mappings = columns.ManyToManyColumn(
         verbose_name=_('Mappings'),
         verbose_name=_('Mappings'),
-        transform=lambda obj: f'{obj.rear_port}:{obj.rear_port_position}'
+        transform=lambda obj: f'{obj.rear_port}:{obj.rear_port_position}',
+        prefetch_related=('mappings__rear_port',)
     )
     )
     tags = columns.TagColumn(
     tags = columns.TagColumn(
         url_name='dcim:frontport_list'
         url_name='dcim:frontport_list'
@@ -874,7 +875,8 @@ class RearPortTable(ModularDeviceComponentTable, CableTerminationTable):
     )
     )
     mappings = columns.ManyToManyColumn(
     mappings = columns.ManyToManyColumn(
         verbose_name=_('Mappings'),
         verbose_name=_('Mappings'),
-        transform=lambda obj: f'{obj.front_port}:{obj.front_port_position}'
+        transform=lambda obj: f'{obj.front_port}:{obj.front_port_position}',
+        prefetch_related=('mappings__front_port',)
     )
     )
     tags = columns.TagColumn(
     tags = columns.TagColumn(
         url_name='dcim:rearport_list'
         url_name='dcim:rearport_list'

+ 4 - 2
netbox/dcim/tables/devicetypes.py

@@ -266,7 +266,8 @@ class FrontPortTemplateTable(ComponentTemplateTable):
     )
     )
     mappings = columns.ManyToManyColumn(
     mappings = columns.ManyToManyColumn(
         verbose_name=_('Mappings'),
         verbose_name=_('Mappings'),
-        transform=lambda obj: f'{obj.rear_port}:{obj.rear_port_position}'
+        transform=lambda obj: f'{obj.rear_port}:{obj.rear_port_position}',
+        prefetch_related=('mappings__rear_port',)
     )
     )
     actions = columns.ActionsColumn(
     actions = columns.ActionsColumn(
         actions=('edit', 'delete'),
         actions=('edit', 'delete'),
@@ -285,7 +286,8 @@ class RearPortTemplateTable(ComponentTemplateTable):
     )
     )
     mappings = columns.ManyToManyColumn(
     mappings = columns.ManyToManyColumn(
         verbose_name=_('Mappings'),
         verbose_name=_('Mappings'),
-        transform=lambda obj: f'{obj.front_port}:{obj.front_port_position}'
+        transform=lambda obj: f'{obj.front_port}:{obj.front_port_position}',
+        prefetch_related=('mappings__front_port',)
     )
     )
     actions = columns.ActionsColumn(
     actions = columns.ActionsColumn(
         actions=('edit', 'delete'),
         actions=('edit', 'delete'),

+ 1 - 1
netbox/dcim/tests/query_counts.json

@@ -31,7 +31,7 @@
   "devicetype:api_list_objects": 13,
   "devicetype:api_list_objects": 13,
   "devicetype:list_objects_with_permission": 17,
   "devicetype:list_objects_with_permission": 17,
   "frontport:api_list_objects": 14,
   "frontport:api_list_objects": 14,
-  "frontport:list_objects_with_permission": 21,
+  "frontport:list_objects_with_permission": 19,
   "frontporttemplate:api_list_objects": 12,
   "frontporttemplate:api_list_objects": 12,
   "interface:api_list_objects": 21,
   "interface:api_list_objects": 21,
   "interface:list_objects_with_permission": 17,
   "interface:list_objects_with_permission": 17,

+ 245 - 1
netbox/dcim/tests/test_tables.py

@@ -1,3 +1,5 @@
+from django.test import tag
+
 from dcim.choices import CableEndChoices, CableProfileChoices, InterfaceTypeChoices
 from dcim.choices import CableEndChoices, CableProfileChoices, InterfaceTypeChoices
 from dcim.models import (
 from dcim.models import (
     Cable,
     Cable,
@@ -5,13 +7,19 @@ from dcim.models import (
     Device,
     Device,
     DeviceRole,
     DeviceRole,
     DeviceType,
     DeviceType,
+    FrontPort,
+    FrontPortTemplate,
     Interface,
     Interface,
     Manufacturer,
     Manufacturer,
+    PortMapping,
+    PortTemplateMapping,
     PowerPort,
     PowerPort,
+    RearPort,
+    RearPortTemplate,
     Site,
     Site,
 )
 )
 from dcim.tables import *
 from dcim.tables import *
-from utilities.testing import TableTestCases
+from utilities.testing import TableTestCases, create_test_device
 
 
 #
 #
 # Sites
 # Sites
@@ -70,6 +78,132 @@ class DeviceTypeTableTestCase(TableTestCases.StandardTableTestCase):
     table = DeviceTypeTable
     table = DeviceTypeTable
 
 
 
 
+class FrontPortTemplateTableTestCase(TableTestCases.StandardTableTestCase):
+    table = FrontPortTemplateTable
+    queryset_sources = [
+        ('DeviceTypeFrontPortsView', FrontPortTemplate.objects.all()),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model='Device Type 1', slug='device-type-1')
+        rear_ports = (
+            RearPortTemplate(device_type=device_type, name='Rear Port 1'),
+            RearPortTemplate(device_type=device_type, name='Rear Port 2'),
+            RearPortTemplate(device_type=device_type, name='Rear Port 3'),
+        )
+        RearPortTemplate.objects.bulk_create(rear_ports)
+        front_ports = (
+            FrontPortTemplate(device_type=device_type, name='Front Port 1'),
+            FrontPortTemplate(device_type=device_type, name='Front Port 2'),
+            FrontPortTemplate(device_type=device_type, name='Front Port 3'),
+        )
+        FrontPortTemplate.objects.bulk_create(front_ports)
+        PortTemplateMapping.objects.bulk_create((
+            PortTemplateMapping(device_type=device_type, front_port=front_ports[0], rear_port=rear_ports[0]),
+            PortTemplateMapping(device_type=device_type, front_port=front_ports[1], rear_port=rear_ports[1]),
+        ))
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_column(self):
+        """The mappings column lists the rear port of each mapping without further queries."""
+        table = FrontPortTemplateTable(FrontPortTemplate.objects.all())
+        table.configure(self.get_request())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.name: row.get_cell('mappings') for row in rows}
+
+        self.assertEqual(cells, {
+            'Front Port 1': 'Rear Port 1:1',
+            'Front Port 2': 'Rear Port 2:1',
+            'Front Port 3': table.columns['mappings'].default,
+        })
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_export(self):
+        """An export lists the rear port of each mapping without further queries."""
+        self.user.config.set('tables.FrontPortTemplateTable.columns', ['name'], commit=True)
+        table = FrontPortTemplateTable(FrontPortTemplate.objects.all())
+        table.configure(self.get_request())
+        # An "All Data" export prefetches for every column, hidden or not
+        table._apply_prefetching(columns=table.columns.names())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.name: row.get_cell_value('mappings') for row in rows}
+
+        self.assertEqual(values, {
+            'Front Port 1': 'Rear Port 1:1',
+            'Front Port 2': 'Rear Port 2:1',
+            'Front Port 3': None,
+        })
+
+
+class RearPortTemplateTableTestCase(TableTestCases.StandardTableTestCase):
+    table = RearPortTemplateTable
+    queryset_sources = [
+        ('DeviceTypeRearPortsView', RearPortTemplate.objects.all()),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model='Device Type 1', slug='device-type-1')
+        rear_ports = (
+            RearPortTemplate(device_type=device_type, name='Rear Port 1'),
+            RearPortTemplate(device_type=device_type, name='Rear Port 2'),
+            RearPortTemplate(device_type=device_type, name='Rear Port 3'),
+        )
+        RearPortTemplate.objects.bulk_create(rear_ports)
+        front_ports = (
+            FrontPortTemplate(device_type=device_type, name='Front Port 1'),
+            FrontPortTemplate(device_type=device_type, name='Front Port 2'),
+            FrontPortTemplate(device_type=device_type, name='Front Port 3'),
+        )
+        FrontPortTemplate.objects.bulk_create(front_ports)
+        PortTemplateMapping.objects.bulk_create((
+            PortTemplateMapping(device_type=device_type, front_port=front_ports[0], rear_port=rear_ports[0]),
+            PortTemplateMapping(device_type=device_type, front_port=front_ports[1], rear_port=rear_ports[1]),
+        ))
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_column(self):
+        """The mappings column lists the front port of each mapping without further queries."""
+        table = RearPortTemplateTable(RearPortTemplate.objects.all())
+        table.configure(self.get_request())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.name: row.get_cell('mappings') for row in rows}
+
+        self.assertEqual(cells, {
+            'Rear Port 1': 'Front Port 1:1',
+            'Rear Port 2': 'Front Port 2:1',
+            'Rear Port 3': table.columns['mappings'].default,
+        })
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_export(self):
+        """An export lists the front port of each mapping without further queries."""
+        self.user.config.set('tables.RearPortTemplateTable.columns', ['name'], commit=True)
+        table = RearPortTemplateTable(RearPortTemplate.objects.all())
+        table.configure(self.get_request())
+        # An "All Data" export prefetches for every column, hidden or not
+        table._apply_prefetching(columns=table.columns.names())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.name: row.get_cell_value('mappings') for row in rows}
+
+        self.assertEqual(values, {
+            'Rear Port 1': 'Front Port 1:1',
+            'Rear Port 2': 'Front Port 2:1',
+            'Rear Port 3': None,
+        })
+
+
 #
 #
 # Module types
 # Module types
 #
 #
@@ -136,10 +270,120 @@ class InterfaceTableTestCase(TableTestCases.StandardTableTestCase):
 class FrontPortTableTestCase(TableTestCases.StandardTableTestCase):
 class FrontPortTableTestCase(TableTestCases.StandardTableTestCase):
     table = FrontPortTable
     table = FrontPortTable
 
 
+    @classmethod
+    def setUpTestData(cls):
+        device = create_test_device('Device 1')
+        rear_ports = (
+            RearPort(device=device, name='Rear Port 1'),
+            RearPort(device=device, name='Rear Port 2'),
+            RearPort(device=device, name='Rear Port 3'),
+        )
+        RearPort.objects.bulk_create(rear_ports)
+        front_ports = (
+            FrontPort(device=device, name='Front Port 1'),
+            FrontPort(device=device, name='Front Port 2'),
+            FrontPort(device=device, name='Front Port 3'),
+        )
+        FrontPort.objects.bulk_create(front_ports)
+        PortMapping.objects.bulk_create((
+            PortMapping(device=device, front_port=front_ports[0], rear_port=rear_ports[0]),
+            PortMapping(device=device, front_port=front_ports[1], rear_port=rear_ports[1]),
+        ))
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_column(self):
+        """The mappings column lists the rear port of each mapping without further queries."""
+        table = FrontPortTable(FrontPort.objects.all())
+        table.configure(self.get_request())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.name: row.get_cell('mappings') for row in rows}
+
+        self.assertEqual(cells, {
+            'Front Port 1': 'Rear Port 1:1',
+            'Front Port 2': 'Rear Port 2:1',
+            'Front Port 3': table.columns['mappings'].default,
+        })
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_export(self):
+        """An export lists the rear port of each mapping without further queries."""
+        self.user.config.set('tables.FrontPortTable.columns', ['name'], commit=True)
+        table = FrontPortTable(FrontPort.objects.all())
+        table.configure(self.get_request())
+        # An "All Data" export prefetches for every column, hidden or not
+        table._apply_prefetching(columns=table.columns.names())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.name: row.get_cell_value('mappings') for row in rows}
+
+        self.assertEqual(values, {
+            'Front Port 1': 'Rear Port 1:1',
+            'Front Port 2': 'Rear Port 2:1',
+            'Front Port 3': None,
+        })
+
 
 
 class RearPortTableTestCase(TableTestCases.StandardTableTestCase):
 class RearPortTableTestCase(TableTestCases.StandardTableTestCase):
     table = RearPortTable
     table = RearPortTable
 
 
+    @classmethod
+    def setUpTestData(cls):
+        device = create_test_device('Device 1')
+        rear_ports = (
+            RearPort(device=device, name='Rear Port 1'),
+            RearPort(device=device, name='Rear Port 2'),
+            RearPort(device=device, name='Rear Port 3'),
+        )
+        RearPort.objects.bulk_create(rear_ports)
+        front_ports = (
+            FrontPort(device=device, name='Front Port 1'),
+            FrontPort(device=device, name='Front Port 2'),
+            FrontPort(device=device, name='Front Port 3'),
+        )
+        FrontPort.objects.bulk_create(front_ports)
+        PortMapping.objects.bulk_create((
+            PortMapping(device=device, front_port=front_ports[0], rear_port=rear_ports[0]),
+            PortMapping(device=device, front_port=front_ports[1], rear_port=rear_ports[1]),
+        ))
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_column(self):
+        """The mappings column lists the front port of each mapping without further queries."""
+        table = RearPortTable(RearPort.objects.all())
+        table.configure(self.get_request())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.name: row.get_cell('mappings') for row in rows}
+
+        self.assertEqual(cells, {
+            'Rear Port 1': 'Front Port 1:1',
+            'Rear Port 2': 'Front Port 2:1',
+            'Rear Port 3': table.columns['mappings'].default,
+        })
+
+    @tag('regression')  # Ref: #23349
+    def test_mappings_export(self):
+        """An export lists the front port of each mapping without further queries."""
+        self.user.config.set('tables.RearPortTable.columns', ['name'], commit=True)
+        table = RearPortTable(RearPort.objects.all())
+        table.configure(self.get_request())
+        # An "All Data" export prefetches for every column, hidden or not
+        table._apply_prefetching(columns=table.columns.names())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.name: row.get_cell_value('mappings') for row in rows}
+
+        self.assertEqual(values, {
+            'Rear Port 1': 'Front Port 1:1',
+            'Rear Port 2': 'Front Port 2:1',
+            'Rear Port 3': None,
+        })
+
 
 
 class ModuleBayTableTestCase(TableTestCases.StandardTableTestCase):
 class ModuleBayTableTestCase(TableTestCases.StandardTableTestCase):
     table = ModuleBayTable
     table = ModuleBayTable

+ 11 - 0
netbox/netbox/tables/columns.py

@@ -133,6 +133,17 @@ class ManyToManyColumn(tables.ManyToManyColumn):
     """
     """
     Overrides django-tables2's stock ManyToManyColumn to ensure that value() returns only plaintext data.
     Overrides django-tables2's stock ManyToManyColumn to ensure that value() returns only plaintext data.
     """
     """
+    def __init__(self, *args, prefetch_related=(), **kwargs):
+        """
+        Args:
+            prefetch_related: Additional lookup strings (one string or an iterable), relative to the table's model,
+                              needed to render or export the items
+        """
+        super().__init__(*args, **kwargs)
+        if isinstance(prefetch_related, str):
+            prefetch_related = (prefetch_related,)
+        self.prefetch_related = tuple(prefetch_related)
+
     def value(self, value):
     def value(self, value):
         items = [self.transform(item) for item in self.filter(value)]
         items = [self.transform(item) for item in self.filter(value)]
         return self.separator.join(items)
         return self.separator.join(items)

+ 1 - 0
netbox/netbox/tables/tables.py

@@ -133,6 +133,7 @@ class BaseTable(tables.Table):
             elif not column.visible:
             elif not column.visible:
                 # Skip hidden columns
                 # Skip hidden columns
                 continue
                 continue
+            prefetch_fields.extend(getattr(column.column, 'prefetch_related', ()))
             model = getattr(self.Meta, 'model')  # Must be called *after* resolving columns
             model = getattr(self.Meta, 'model')  # Must be called *after* resolving columns
             accessor = column.accessor
             accessor = column.accessor
             if accessor.startswith('custom_field_data__'):
             if accessor.startswith('custom_field_data__'):

+ 52 - 0
netbox/netbox/tests/test_tables.py

@@ -22,6 +22,11 @@ class BaseTableTestCase(TestCase):
         create_test_device('Test Device 1')
         create_test_device('Test Device 1')
         cls.user = create_test_user('testuser')
         cls.user = create_test_user('testuser')
 
 
+    def get_table_with_declared_lookup(self, data, **kwargs):
+        """Return a DeviceTable with a column declaring the lookup interfaces__cable."""
+        column = columns.ManyToManyColumn(accessor='interfaces', prefetch_related=('interfaces__cable',))
+        return DeviceTable(data, extra_columns=[('interface_cables', column)], **kwargs)
+
     def test_prefetch_visible_columns(self):
     def test_prefetch_visible_columns(self):
         """
         """
         Verify that the table queryset's prefetch_related lookups correspond to the user's
         Verify that the table queryset's prefetch_related lookups correspond to the user's
@@ -93,6 +98,53 @@ class BaseTableTestCase(TestCase):
         table._apply_prefetching(columns=['site_regions'])
         table._apply_prefetching(columns=['site_regions'])
         self.assertEqual(table.data.data._prefetch_related_lookups, ('sites__region',))
         self.assertEqual(table.data.data._prefetch_related_lookups, ('sites__region',))
 
 
+    @tag('regression')  # Ref: #23349
+    def test_prefetch_declared_lookups(self):
+        """A column's declared lookups are prefetched while it is visible or requested for an export."""
+        table = self.get_table_with_declared_lookup(Device.objects.all())
+        table._apply_prefetching()
+        self.assertIn('interfaces__cable', table.data.data._prefetch_related_lookups)
+        self.assertIn('interfaces', table.data.data._prefetch_related_lookups)
+
+        table = self.get_table_with_declared_lookup(Device.objects.all())
+        table.columns.hide('interface_cables')
+        table._apply_prefetching()
+        self.assertNotIn('interfaces__cable', table.data.data._prefetch_related_lookups)
+
+        # An export requests the hidden column
+        table._apply_prefetching(columns=['interface_cables'])
+        self.assertIn('interfaces__cable', table.data.data._prefetch_related_lookups)
+
+    @tag('regression')  # Ref: #23349
+    def test_prefetch_declared_lookups_skipped(self):
+        """A column's declared lookups are skipped when an export omits it or the table excludes it."""
+        table = self.get_table_with_declared_lookup(Device.objects.all())
+        table._apply_prefetching(columns=['name'])
+        self.assertEqual(table.data.data._prefetch_related_lookups, ())
+
+        table = self.get_table_with_declared_lookup(Device.objects.all(), exclude=('interface_cables',))
+        table._apply_prefetching(columns=['interface_cables'])
+        self.assertEqual(table.data.data._prefetch_related_lookups, ())
+
+        # List-backed data has no queryset to prefetch on
+        self.get_table_with_declared_lookup([])._apply_prefetching(columns=['interface_cables'])
+
+    @tag('regression')  # Ref: #23349
+    def test_prefetch_declared_lookup_string(self):
+        """A column can declare a single lookup as a string."""
+        column = columns.ManyToManyColumn(accessor='interfaces', prefetch_related='interfaces__cable')
+        table = DeviceTable(Device.objects.all(), extra_columns=[('interface_cables', column)])
+        table._apply_prefetching(columns=['interface_cables'])
+        self.assertEqual(table.data.data._prefetch_related_lookups, ('interfaces__cable', 'interfaces'))
+
+    @tag('regression')  # Ref: #23349
+    def test_prefetch_declared_lookups_non_field_accessor(self):
+        """A column's declared lookups are prefetched when its accessor is not a model field."""
+        column = columns.ManyToManyColumn(accessor='non_field_attribute', prefetch_related=('interfaces__cable',))
+        table = DeviceTable(Device.objects.all(), extra_columns=[('interface_cables', column)])
+        table._apply_prefetching(columns=['interface_cables'])
+        self.assertEqual(table.data.data._prefetch_related_lookups, ('interfaces__cable',))
+
     def test_configure_anonymous_user_with_ordering(self):
     def test_configure_anonymous_user_with_ordering(self):
         """
         """
         Verify that table.configure() does not raise an error when an anonymous
         Verify that table.configure() does not raise an error when an anonymous

+ 2 - 1
netbox/tenancy/tables/columns.py

@@ -55,5 +55,6 @@ class ContactsColumnMixin(tables.Table):
     contacts = columns.ManyToManyColumn(
     contacts = columns.ManyToManyColumn(
         verbose_name=_('Contacts'),
         verbose_name=_('Contacts'),
         linkify_item=True,
         linkify_item=True,
-        transform=lambda obj: obj.contact.name
+        transform=lambda obj: obj.contact.name,
+        prefetch_related=('contacts__contact',)
     )
     )

+ 53 - 0
netbox/tenancy/tests/test_tables.py

@@ -1,3 +1,6 @@
+from django.test import tag
+
+from tenancy.models import Contact, ContactAssignment, ContactRole, Tenant
 from tenancy.tables import *
 from tenancy.tables import *
 from utilities.testing import TableTestCases
 from utilities.testing import TableTestCases
 
 
@@ -9,6 +12,56 @@ class TenantGroupTableTestCase(TableTestCases.StandardTableTestCase):
 class TenantTableTestCase(TableTestCases.StandardTableTestCase):
 class TenantTableTestCase(TableTestCases.StandardTableTestCase):
     table = TenantTable
     table = TenantTable
 
 
+    @classmethod
+    def setUpTestData(cls):
+        tenants = (
+            Tenant(name='Tenant 1', slug='tenant-1'),
+            Tenant(name='Tenant 2', slug='tenant-2'),
+            Tenant(name='Tenant 3', slug='tenant-3'),
+        )
+        Tenant.objects.bulk_create(tenants)
+        cls.contacts = (
+            Contact(name='Contact 1'),
+            Contact(name='Contact 2'),
+        )
+        Contact.objects.bulk_create(cls.contacts)
+        role = ContactRole.objects.create(name='Contact Role 1', slug='contact-role-1')
+        ContactAssignment.objects.bulk_create((
+            ContactAssignment(object=tenants[0], contact=cls.contacts[0], role=role),
+            ContactAssignment(object=tenants[0], contact=cls.contacts[1], role=role),
+            ContactAssignment(object=tenants[1], contact=cls.contacts[0], role=role),
+        ))
+
+    @tag('regression')  # Ref: #23349
+    def test_contacts_column(self):
+        """The contacts column links the contacts of each tenant without further queries."""
+        url1, url2 = (contact.get_absolute_url() for contact in self.contacts)
+        self.user.config.set('tables.TenantTable.columns', ['name', 'contacts'], commit=True)
+        table = TenantTable(Tenant.objects.all())
+        table.configure(self.get_request())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            cells = {row.record.name: row.get_cell('contacts') for row in rows}
+
+        self.assertHTMLEqual(cells['Tenant 1'], f'<a href="{url1}">Contact 1</a>, <a href="{url2}">Contact 2</a>')
+        self.assertHTMLEqual(cells['Tenant 2'], f'<a href="{url1}">Contact 1</a>')
+        self.assertEqual(cells['Tenant 3'], table.columns['contacts'].default)
+
+    @tag('regression')  # Ref: #23349
+    def test_contacts_export(self):
+        """An export lists the contacts of each tenant without further queries."""
+        table = TenantTable(Tenant.objects.all())
+        table.configure(self.get_request())
+        # An "All Data" export prefetches for every column, hidden or not
+        table._apply_prefetching(columns=table.columns.names())
+        rows = list(table.rows)
+
+        with self.assertNumQueries(0):
+            values = {row.record.name: row.get_cell_value('contacts') for row in rows}
+
+        self.assertEqual(values, {'Tenant 1': 'Contact 1, Contact 2', 'Tenant 2': 'Contact 1', 'Tenant 3': None})
+
 
 
 class ContactGroupTableTestCase(TableTestCases.StandardTableTestCase):
 class ContactGroupTableTestCase(TableTestCases.StandardTableTestCase):
     table = ContactGroupTable
     table = ContactGroupTable