Merge pull request #23393 from netbox-community/23337-generatedfield

Closes #23337: Employ GeneratedField to store normalized unit values

netbox/circuits/migrations/0061_generated_fields.py

@@ -0,0 +1,110 @@
+# Generated by Django 6.1.2 on 2026-10-14 00:11
+
+from decimal import Decimal
+
+import django.core.validators
+import django.db.models.expressions
+import django.db.models.functions.comparison
+from django.db import migrations, models
+
+import utilities.fields
+
+
+# PostgreSQL cannot convert an existing column to a generated column in place, so each normalized
+# column is dropped and re-added. The database computes the values for all existing rows.
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("circuits", "0060_denormalization_triggers"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="circuit",
+            name="_abs_distance",
+        ),
+        migrations.AddField(
+            model_name="circuit",
+            name="_abs_distance",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        distance_unit="km",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1000")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="m",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.01")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="mi",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1609.344")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="ft",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.3048")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.0254")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=14, null=True
+                ),
+            ),
+        ),
+        migrations.AlterField(
+            model_name="circuit",
+            name="distance",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+    ]

netbox/circuits/tests/test_models.py

@@ -11,8 +11,11 @@ from core.models import ObjectChange
 from dcim.models import Location, Region, Site, SiteGroup
 from extras.choices import CustomFieldStatusChoices, CustomFieldTypeChoices
 from extras.models import CustomField
+from netbox.choices import DistanceUnitChoices
 from netbox.context_managers import event_tracking
 from users.models import User
+from utilities.conversion import to_meters
+from utilities.testing.mixins import NormalizedMeasurementTestMixin
 
 
 class CircuitTerminationTestCase(TestCase):
@@ -625,3 +628,25 @@ class CircuitTerminationChangeLoggingTestCase(TestCase):
         circuit.refresh_from_db()
         self.assertIsNone(circuit.termination_a_id)
         self.assertEqual(circuit.custom_field_data, {'probe_field': 'concurrent'})
+
+
+class CircuitDistanceTestCase(NormalizedMeasurementTestMixin, TestCase):
+    model = Circuit
+    value_field = 'distance'
+    unit_field = 'distance_unit'
+    normalized_field = '_abs_distance'
+    unit_choices = DistanceUnitChoices
+    converter = staticmethod(to_meters)
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.provider = Provider.objects.create(name='Provider 1', slug='provider-1')
+        cls.circuit_type = CircuitType.objects.create(name='Circuit Type 1', slug='circuit-type-1')
+
+    def create_instance(self, **attrs):
+        return Circuit(
+            provider=self.provider,
+            type=self.circuit_type,
+            cid=f'Circuit {next(self.sequence)}',
+            **attrs
+        )

netbox/dcim/migrations/0252_generated_fields.py

@@ -0,0 +1,868 @@
+# Generated by Django 6.1.2 on 2026-10-14 00:11
+
+from decimal import Decimal
+
+import django.core.validators
+import django.db.models.expressions
+import django.db.models.functions.comparison
+import django.db.models.functions.math
+from django.db import migrations, models
+
+import utilities.fields
+
+
+# PostgreSQL cannot convert an existing column to a generated column in place, so each normalized
+# column is dropped and re-added. The database computes the values for all existing rows.
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("dcim", "0251_fix_ltree_cascade_triggers"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="cable",
+            name="_abs_length",
+        ),
+        migrations.AddField(
+            model_name="cable",
+            name="_abs_length",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        length_unit="km",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1000")),
+                        ),
+                    ),
+                    models.When(
+                        length_unit="m",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        length_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.01")),
+                        ),
+                    ),
+                    models.When(
+                        length_unit="mi",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1609.344")),
+                        ),
+                    ),
+                    models.When(
+                        length_unit="ft",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.3048")),
+                        ),
+                    ),
+                    models.When(
+                        length_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("length"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.0254")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=14, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingfeed",
+            name="_abs_max_flow",
+        ),
+        migrations.AddField(
+            model_name="coolingfeed",
+            name="_abs_max_flow",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        max_flow_unit="lpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="m3ph",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("16.66666666666666666666666667")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="gpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("3.785411784")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingintake",
+            name="_abs_diameter",
+        ),
+        migrations.AddField(
+            model_name="coolingintake",
+            name="_abs_diameter",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        diameter_unit="mm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("10")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("25.4")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingintake",
+            name="_abs_max_flow",
+        ),
+        migrations.AddField(
+            model_name="coolingintake",
+            name="_abs_max_flow",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        max_flow_unit="lpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="m3ph",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("16.66666666666666666666666667")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="gpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("3.785411784")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingintaketemplate",
+            name="_abs_diameter",
+        ),
+        migrations.AddField(
+            model_name="coolingintaketemplate",
+            name="_abs_diameter",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        diameter_unit="mm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("10")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("25.4")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingintaketemplate",
+            name="_abs_max_flow",
+        ),
+        migrations.AddField(
+            model_name="coolingintaketemplate",
+            name="_abs_max_flow",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        max_flow_unit="lpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="m3ph",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("16.66666666666666666666666667")),
+                        ),
+                    ),
+                    models.When(
+                        max_flow_unit="gpm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("max_flow"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("3.785411784")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingoutflow",
+            name="_abs_diameter",
+        ),
+        migrations.AddField(
+            model_name="coolingoutflow",
+            name="_abs_diameter",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        diameter_unit="mm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("10")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("25.4")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="coolingoutflowtemplate",
+            name="_abs_diameter",
+        ),
+        migrations.AddField(
+            model_name="coolingoutflowtemplate",
+            name="_abs_diameter",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        diameter_unit="mm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("10")),
+                        ),
+                    ),
+                    models.When(
+                        diameter_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("diameter"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("25.4")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=13, null=True
+                ),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="devicetype",
+            name="_abs_weight",
+        ),
+        migrations.AddField(
+            model_name="devicetype",
+            name="_abs_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="moduletype",
+            name="_abs_weight",
+        ),
+        migrations.AddField(
+            model_name="moduletype",
+            name="_abs_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="rack",
+            name="_abs_max_weight",
+        ),
+        migrations.AddField(
+            model_name="rack",
+            name="_abs_max_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="rack",
+            name="_abs_weight",
+        ),
+        migrations.AddField(
+            model_name="rack",
+            name="_abs_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="racktype",
+            name="_abs_max_weight",
+        ),
+        migrations.AddField(
+            model_name="racktype",
+            name="_abs_max_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("max_weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="racktype",
+            name="_abs_weight",
+        ),
+        migrations.AddField(
+            model_name="racktype",
+            name="_abs_weight",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Cast(
+                    django.db.models.functions.math.Floor(
+                        models.Case(
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1000")),
+                                ),
+                                weight_unit="kg",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("1")),
+                                ),
+                                weight_unit="g",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("453.592")),
+                                ),
+                                weight_unit="lb",
+                            ),
+                            models.When(
+                                then=django.db.models.expressions.CombinedExpression(
+                                    django.db.models.functions.comparison.Cast(
+                                        models.F("weight"),
+                                        output_field=models.DecimalField(),
+                                    ),
+                                    "*",
+                                    models.Value(Decimal("28.3495")),
+                                ),
+                                weight_unit="oz",
+                            ),
+                        )
+                    ),
+                    output_field=models.BigIntegerField(),
+                ),
+                null=True,
+                output_field=models.BigIntegerField(blank=True, null=True),
+            ),
+        ),
+        migrations.AlterField(
+            model_name="cable",
+            name="length",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+        migrations.AlterField(
+            model_name="devicetype",
+            name="weight",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+        migrations.AlterField(
+            model_name="moduletype",
+            name="weight",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+        migrations.AlterField(
+            model_name="rack",
+            name="weight",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+        migrations.AlterField(
+            model_name="racktype",
+            name="weight",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+    ]

netbox/dcim/models/cables.py

@@ -22,10 +22,10 @@ from dcim.fields import PathField
 from dcim.utils import decompile_path_node, object_to_path_node, rebuild_cable_paths
 from netbox.choices import ColorChoices
 from netbox.models import ChangeLoggedModel, PrimaryModel
-from utilities.conversion import to_meters
+from utilities.conversion import LENGTH_TO_METERS, normalized_unit_expression
 from utilities.data import normalize_update_fields
 from utilities.exceptions import AbortRequest
-from utilities.fields import ColorField, GenericArrayForeignKey
+from utilities.fields import ColorField, GenericArrayForeignKey, NonNegativeGeneratedField
 from utilities.querysets import RestrictedQuerySet, chunked_update
 from utilities.serialization import deserialize_object, serialize_object
 from wireless.models import WirelessLink
@@ -141,7 +141,8 @@ class Cable(PrimaryModel):
         max_digits=8,
         decimal_places=2,
         blank=True,
-        null=True
+        null=True,
+        validators=[MinValueValidator(0)],
     )
     length_unit = models.CharField(
         verbose_name=_('length unit'),
@@ -150,12 +151,12 @@ class Cable(PrimaryModel):
         blank=True,
         null=True
     )
-    # Stores the normalized length (in meters) for database ordering
-    _abs_length = models.DecimalField(
-        max_digits=14,
-        decimal_places=4,
-        blank=True,
-        null=True
+    # Normalized length (in meters), computed by the database for ordering and path tracing
+    _abs_length = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('length', 'length_unit', LENGTH_TO_METERS),
+        output_field=models.DecimalField(max_digits=14, decimal_places=4, blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
     bundle = models.ForeignKey(
         to='dcim.CableBundle',
@@ -353,33 +354,17 @@ class Cable(PrimaryModel):
         }
         update_fields = normalize_update_fields(save_kwargs)
 
-        length_written = update_fields is None or 'length' in update_fields
-        length_unit_written = update_fields is None or 'length_unit' in update_fields
-
-        if length_written or length_unit_written:
-            if length_written and length_unit_written:
-                stored = {}
+        # Clear length_unit if no length is defined. A save writing only the unit must check the stored length,
+        # reading from the database this save will write so a router cannot split the two.
+        if update_fields is None or 'length_unit' in update_fields:
+            if update_fields is None or 'length' in update_fields:
+                length = self.length
             else:
-                # Read from the database this save will write, so a router cannot split the two
                 db = using or router.db_for_write(Cable, instance=self)
-                stored = Cable.objects.using(db).filter(pk=self.pk).values('length', 'length_unit').first() or {}
-            length = self.length if length_written else stored.get('length')
-            length_unit = self.length_unit if length_unit_written else stored.get('length_unit')
-
-            # Clear length_unit if no length is defined
-            if length is None and length_unit_written:
+                length = Cable.objects.using(db).filter(pk=self.pk).values_list('length', flat=True).first()
+            if length is None:
                 self.length_unit = None
 
-            # Store the given length (if any) in meters for use in database ordering
-            if length is not None and length_unit:
-                self._abs_length = to_meters(length, length_unit)
-            else:
-                self._abs_length = None
-
-            # _abs_length is a denormalized cache of length and length_unit, so persist them together
-            if update_fields is not None:
-                save_kwargs['update_fields'] = update_fields | {'_abs_length'}
-
         # A field counts as changed only when this save actually writes it
         status_written = update_fields is None or 'status' in update_fields
         profile_written = update_fields is None or 'profile' in update_fields

netbox/dcim/models/device_component_templates.py

@@ -473,7 +473,7 @@ class CoolingIntakeTemplate(DiameterMixin, MaxFlowMixin, ModularComponentTemplat
             max_flow_unit=self.max_flow_unit,
             **kwargs
         )
-        # bulk_create bypasses save(), so populate the normalized _abs_* fields here
+        # bulk_create() bypasses save(), so clear any unit lacking a value here
         component.normalize_diameter()
         component.normalize_max_flow()
         return component
@@ -551,7 +551,7 @@ class CoolingOutflowTemplate(DiameterMixin, ModularComponentTemplateModel):
             cooling_intake=cooling_intake,
             **kwargs
         )
-        # bulk_create bypasses save(), so populate the normalized _abs_diameter here
+        # bulk_create() bypasses save(), so clear any unit lacking a value here
         component.normalize_diameter()
         return component
     instantiate.do_not_call_in_templates = True

netbox/dcim/models/mixins.py

@@ -11,10 +11,12 @@ from dcim.choices import InterfaceTypeChoices
 from dcim.constants import NONCONNECTABLE_IFACE_TYPES, VIRTUAL_IFACE_TYPES, WIRELESS_IFACE_TYPES
 from netbox.choices import *
 from utilities.conversion import (
-    to_liters_per_minute,
-    to_millimeters,
+    DIAMETER_TO_MILLIMETERS,
+    FLOW_RATE_TO_LITERS_PER_MINUTE,
+    normalized_unit_expression,
 )
 from utilities.data import normalize_update_fields
+from utilities.fields import NonNegativeGeneratedField
 
 __all__ = (
     'CachedScopeMixin',
@@ -406,12 +408,12 @@ class DiameterMixin(models.Model):
         blank=True,
         null=True,
     )
-    # Stores the normalized diameter (in millimeters) for database ordering
-    _abs_diameter = models.DecimalField(
-        max_digits=13,
-        decimal_places=4,
-        blank=True,
-        null=True
+    # Normalized diameter (in millimeters), computed by the database for ordering
+    _abs_diameter = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('diameter', 'diameter_unit', DIAMETER_TO_MILLIMETERS),
+        output_field=models.DecimalField(max_digits=13, decimal_places=4, blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
 
     class Meta:
@@ -424,13 +426,8 @@ class DiameterMixin(models.Model):
 
     def normalize_diameter(self):
         """
-        Store the given diameter (if any) in millimeters for use in database ordering. Called by save(), and
-        directly by component instantiation, which bypasses save() via bulk_create().
+        Clear diameter_unit if no diameter is defined.
         """
-        if self.diameter is not None and self.diameter_unit:
-            self._abs_diameter = to_millimeters(self.diameter, self.diameter_unit)
-        else:
-            self._abs_diameter = None
         if self.diameter is None:
             self.diameter_unit = None
     normalize_diameter.alters_data = True
@@ -468,12 +465,12 @@ class MaxFlowMixin(models.Model):
         blank=True,
         null=True,
     )
-    # Stores the normalized max flow (in liters per minute) for database ordering
-    _abs_max_flow = models.DecimalField(
-        max_digits=13,
-        decimal_places=4,
-        blank=True,
-        null=True
+    # Normalized max flow (in liters per minute), computed by the database for ordering
+    _abs_max_flow = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('max_flow', 'max_flow_unit', FLOW_RATE_TO_LITERS_PER_MINUTE),
+        output_field=models.DecimalField(max_digits=13, decimal_places=4, blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
 
     class Meta:
@@ -486,13 +483,8 @@ class MaxFlowMixin(models.Model):
 
     def normalize_max_flow(self):
         """
-        Store the given max flow (if any) in liters per minute for use in database ordering. Called by save(),
-        and directly by component instantiation, which bypasses save() via bulk_create().
+        Clear max_flow_unit if no max flow is defined.
         """
-        if self.max_flow is not None and self.max_flow_unit:
-            self._abs_max_flow = to_liters_per_minute(self.max_flow, self.max_flow_unit)
-        else:
-            self._abs_max_flow = None
         if self.max_flow is None:
             self.max_flow_unit = None
     normalize_max_flow.alters_data = True

netbox/dcim/models/racks.py

@@ -17,9 +17,9 @@ from netbox.choices import ColorChoices
 from netbox.models import OrganizationalModel, PrimaryModel
 from netbox.models.features import ContactsMixin, ImageAttachmentsMixin
 from netbox.models.mixins import WeightMixin
-from utilities.conversion import to_grams
+from utilities.conversion import WEIGHT_TO_GRAMS, normalized_unit_expression
 from utilities.data import array_to_string, drange
-from utilities.fields import ColorField, CounterCacheField
+from utilities.fields import ColorField, CounterCacheField, NonNegativeGeneratedField
 from utilities.tracking import TrackingModelMixin
 
 from .device_components import PowerPort
@@ -129,10 +129,12 @@ class RackBase(WeightMixin, PrimaryModel):
         null=True,
         help_text=_('Maximum load capacity for the rack')
     )
-    # Stores the normalized max weight (in grams) for database ordering
-    _abs_max_weight = models.PositiveBigIntegerField(
-        blank=True,
-        null=True
+    # Normalized max weight (in grams), computed by the database for ordering
+    _abs_max_weight = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('max_weight', 'weight_unit', WEIGHT_TO_GRAMS, integer=True),
+        output_field=models.BigIntegerField(blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
 
     # Cooling
@@ -236,12 +238,6 @@ class RackType(ImageAttachmentsMixin, RackBase):
             raise ValidationError(_("Must specify a unit when setting a maximum weight"))
 
     def save(self, *args, **kwargs):
-        # Store the given max weight (if any) in grams for use in database ordering
-        if self.max_weight and self.weight_unit:
-            self._abs_max_weight = to_grams(self.max_weight, self.weight_unit)
-        else:
-            self._abs_max_weight = None
-
         # Clear unit if outer width & depth are not set
         if not any([self.outer_width, self.outer_depth, self.outer_height]):
             self.outer_unit = None
@@ -475,12 +471,6 @@ class Rack(ContactsMixin, ImageAttachmentsMixin, TrackingModelMixin, RackBase):
     def save(self, *args, **kwargs):
         self.copy_racktype_attrs()
 
-        # Store the given max weight (if any) in grams for use in database ordering
-        if self.max_weight and self.weight_unit:
-            self._abs_max_weight = to_grams(self.max_weight, self.weight_unit)
-        else:
-            self._abs_max_weight = None
-
         # Clear unit if outer width & depth are not set
         if not any([self.outer_width, self.outer_depth, self.outer_height]):
             self.outer_unit = None

netbox/dcim/tests/test_models.py

@@ -5,7 +5,7 @@ from decimal import Decimal
 from unittest.mock import patch
 
 from django.core.exceptions import ValidationError
-from django.db import connection, transaction
+from django.db import IntegrityError, connection, transaction
 from django.db.models import ProtectedError
 from django.db.models.signals import post_save
 from django.test import RequestFactory, TestCase, override_settings, tag
@@ -3313,9 +3313,20 @@ class CableTestCase(TestCase):
         self.assertIsNone(cable.length_unit)
         self.assertIsNone(cable._abs_length)
 
-    def test_partial_save_reads_the_stored_pair_only_for_an_excluded_field(self):
+    def test_negative_length_rejected_by_database(self):
         """
-        A save writing both source fields must normalize without reading the row back.
+        A negative length must not reach the database, even through a write which skips validation.
+        """
+        cable = Cable.objects.first()
+        with self.assertRaises(IntegrityError), transaction.atomic():
+            Cable.objects.filter(pk=cable.pk).update(
+                length=Decimal('-1'), length_unit=CableLengthUnitChoices.UNIT_METER
+            )
+
+    def test_partial_save_reads_the_stored_length_only_for_an_unwritten_length(self):
+        """
+        Only a save writing length_unit without length must read the row back, to decide whether to clear the
+        unit; the database computes the normalized length itself.
         """
         cable = Cable.objects.first()
         cable.length = Decimal('1')
@@ -3324,14 +3335,17 @@ class CableTestCase(TestCase):
 
         with CaptureQueriesContext(connection) as both_written:
             cable.save(update_fields=['length', 'length_unit'])
-        with CaptureQueriesContext(connection) as one_written:
+        with CaptureQueriesContext(connection) as length_written:
             cable.save(update_fields=['length'])
+        with CaptureQueriesContext(connection) as unit_written:
+            cable.save(update_fields=['length_unit'])
 
         def cable_reads(queries):
             return [q for q in queries if q['sql'].startswith('SELECT') and 'FROM "dcim_cable"' in q['sql']]
 
         self.assertEqual(cable_reads(both_written), [])
-        self.assertEqual(len(cable_reads(one_written)), 1)
+        self.assertEqual(cable_reads(length_written), [])
+        self.assertEqual(len(cable_reads(unit_written)), 1)
 
 
 class CableTerminationTestCase(TestCase):
@@ -4677,3 +4691,69 @@ class CoolingComponentTestCase(TestCase):
         cooling_outflow.cooling_intake = cooling_intake
         with self.assertRaises(ValidationError):
             cooling_outflow.full_clean()
+
+    def test_instantiate_clears_unit_without_value(self):
+        """
+        bulk_create() bypasses save(), so instantiate() must itself clear a unit whose value is unset.
+        """
+        device_type = DeviceType.objects.create(
+            manufacturer=self.manufacturer, model='Device Type 8', slug='device-type-8'
+        )
+        intake_template = CoolingIntakeTemplate.objects.create(
+            device_type=device_type,
+            name='Cooling Port 1',
+            diameter=Decimal('10'),
+            diameter_unit=DiameterUnitChoices.UNIT_MILLIMETER,
+            max_flow=Decimal('5'),
+            max_flow_unit=FlowRateUnitChoices.UNIT_LITERS_PER_MINUTE,
+        )
+        outflow_template = CoolingOutflowTemplate.objects.create(
+            device_type=device_type,
+            name='Cooling Outlet 1',
+            diameter=Decimal('10'),
+            diameter_unit=DiameterUnitChoices.UNIT_MILLIMETER,
+        )
+        # Leave the units dangling without passing through save()
+        CoolingIntakeTemplate.objects.filter(pk=intake_template.pk).update(diameter=None, max_flow=None)
+        CoolingOutflowTemplate.objects.filter(pk=outflow_template.pk).update(diameter=None)
+
+        device = Device.objects.create(
+            site=self.site, device_type=device_type, role=self.role, name='Device F'
+        )
+        cooling_intake = CoolingIntake.objects.get(device=device, name='Cooling Port 1')
+        self.assertIsNone(cooling_intake.diameter)
+        self.assertIsNone(cooling_intake.diameter_unit)
+        self.assertIsNone(cooling_intake.max_flow)
+        self.assertIsNone(cooling_intake.max_flow_unit)
+        cooling_outflow = CoolingOutflow.objects.get(device=device, name='Cooling Outlet 1')
+        self.assertIsNone(cooling_outflow.diameter)
+        self.assertIsNone(cooling_outflow.diameter_unit)
+
+    def test_negative_measurements_rejected_by_database(self):
+        """
+        A negative diameter or max flow must not reach the database, even through a write which skips validation.
+        """
+        device_type = DeviceType.objects.create(
+            manufacturer=self.manufacturer, model='Device Type 9', slug='device-type-9'
+        )
+        device = Device.objects.create(
+            site=self.site, device_type=device_type, role=self.role, name='Device G'
+        )
+        writes = {
+            CoolingIntakeTemplate: CoolingIntakeTemplate.objects.create(device_type=device_type, name='Intake 1'),
+            CoolingOutflowTemplate: CoolingOutflowTemplate.objects.create(device_type=device_type, name='Outflow 1'),
+            CoolingIntake: CoolingIntake.objects.create(device=device, name='Intake 1'),
+            CoolingOutflow: CoolingOutflow.objects.create(device=device, name='Outflow 1'),
+        }
+        for model, instance in writes.items():
+            with self.subTest(model=model.__name__, field='diameter'):
+                with self.assertRaises(IntegrityError), transaction.atomic():
+                    model.objects.filter(pk=instance.pk).update(
+                        diameter=Decimal('-1'), diameter_unit=DiameterUnitChoices.UNIT_MILLIMETER
+                    )
+        for model in (CoolingIntakeTemplate, CoolingIntake):
+            with self.subTest(model=model.__name__, field='max_flow'):
+                with self.assertRaises(IntegrityError), transaction.atomic():
+                    model.objects.filter(pk=writes[model].pk).update(
+                        max_flow=Decimal('-1'), max_flow_unit=FlowRateUnitChoices.UNIT_LITERS_PER_MINUTE
+                    )

netbox/dcim/tests/test_normalization.py

@@ -0,0 +1,201 @@
+from django.test import TestCase
+
+from dcim.choices import CableLengthUnitChoices, CoolingSourceTypeChoices, RackFormFactorChoices
+from dcim.models import *
+from netbox.choices import DiameterUnitChoices, FlowRateUnitChoices, WeightUnitChoices
+from utilities.conversion import to_grams, to_liters_per_minute, to_meters, to_millimeters
+from utilities.testing import create_test_device
+from utilities.testing.mixins import NormalizedMeasurementTestMixin
+
+#
+# Per-measurement mixins
+#
+
+
+class WeightTestMixin(NormalizedMeasurementTestMixin):
+    value_field = 'weight'
+    unit_field = 'weight_unit'
+    normalized_field = '_abs_weight'
+    unit_choices = WeightUnitChoices
+    converter = staticmethod(to_grams)
+
+
+class MaxWeightTestMixin(WeightTestMixin):
+    value_field = 'max_weight'
+    normalized_field = '_abs_max_weight'
+    value = 123  # max_weight is an integer field
+
+
+class DiameterTestMixin(NormalizedMeasurementTestMixin):
+    value_field = 'diameter'
+    unit_field = 'diameter_unit'
+    normalized_field = '_abs_diameter'
+    unit_choices = DiameterUnitChoices
+    converter = staticmethod(to_millimeters)
+
+
+class MaxFlowTestMixin(NormalizedMeasurementTestMixin):
+    value_field = 'max_flow'
+    unit_field = 'max_flow_unit'
+    normalized_field = '_abs_max_flow'
+    unit_choices = FlowRateUnitChoices
+    converter = staticmethod(to_liters_per_minute)
+
+
+#
+# Weight
+#
+
+class DeviceTypeWeightTestCase(WeightTestMixin, TestCase):
+    model = DeviceType
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+
+    def create_instance(self, **attrs):
+        index = next(self.sequence)
+        return DeviceType(
+            manufacturer=self.manufacturer, model=f'Device Type {index}', slug=f'device-type-{index}', **attrs
+        )
+
+
+class ModuleTypeWeightTestCase(WeightTestMixin, TestCase):
+    model = ModuleType
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+
+    def create_instance(self, **attrs):
+        return ModuleType(manufacturer=self.manufacturer, model=f'Module Type {next(self.sequence)}', **attrs)
+
+
+class RackTypeTestMixin:
+    model = RackType
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+
+    def create_instance(self, **attrs):
+        index = next(self.sequence)
+        return RackType(
+            manufacturer=self.manufacturer,
+            model=f'Rack Type {index}',
+            slug=f'rack-type-{index}',
+            form_factor=RackFormFactorChoices.TYPE_CABINET,
+            **attrs
+        )
+
+
+class RackTypeWeightTestCase(RackTypeTestMixin, WeightTestMixin, TestCase):
+    pass
+
+
+class RackTypeMaxWeightTestCase(RackTypeTestMixin, MaxWeightTestMixin, TestCase):
+    pass
+
+
+class RackTestMixin:
+    model = Rack
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.site = Site.objects.create(name='Site 1', slug='site-1')
+
+    def create_instance(self, **attrs):
+        return Rack(site=self.site, name=f'Rack {next(self.sequence)}', **attrs)
+
+
+class RackWeightTestCase(RackTestMixin, WeightTestMixin, TestCase):
+    pass
+
+
+class RackMaxWeightTestCase(RackTestMixin, MaxWeightTestMixin, TestCase):
+    pass
+
+
+#
+# Length
+#
+
+class CableLengthTestCase(NormalizedMeasurementTestMixin, TestCase):
+    model = Cable
+    value_field = 'length'
+    unit_field = 'length_unit'
+    normalized_field = '_abs_length'
+    unit_choices = CableLengthUnitChoices
+    converter = staticmethod(to_meters)
+
+    def create_instance(self, **attrs):
+        return Cable(**attrs)
+
+
+#
+# Cooling
+#
+
+class CoolingComponentTestMixin:
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.device = create_test_device('Device 1')
+
+    def create_instance(self, **attrs):
+        return self.model(device=self.device, name=f'Cooling Component {next(self.sequence)}', **attrs)
+
+
+class CoolingIntakeDiameterTestCase(CoolingComponentTestMixin, DiameterTestMixin, TestCase):
+    model = CoolingIntake
+
+
+class CoolingIntakeMaxFlowTestCase(CoolingComponentTestMixin, MaxFlowTestMixin, TestCase):
+    model = CoolingIntake
+
+
+class CoolingOutflowDiameterTestCase(CoolingComponentTestMixin, DiameterTestMixin, TestCase):
+    model = CoolingOutflow
+
+
+class CoolingComponentTemplateTestMixin:
+
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name='Manufacturer 1', slug='manufacturer-1')
+        cls.device_type = DeviceType.objects.create(
+            manufacturer=manufacturer, model='Device Type 1', slug='device-type-1'
+        )
+
+    def create_instance(self, **attrs):
+        return self.model(
+            device_type=self.device_type, name=f'Cooling Component {next(self.sequence)}', **attrs
+        )
+
+
+class CoolingIntakeTemplateDiameterTestCase(CoolingComponentTemplateTestMixin, DiameterTestMixin, TestCase):
+    model = CoolingIntakeTemplate
+
+
+class CoolingIntakeTemplateMaxFlowTestCase(CoolingComponentTemplateTestMixin, MaxFlowTestMixin, TestCase):
+    model = CoolingIntakeTemplate
+
+
+class CoolingOutflowTemplateDiameterTestCase(CoolingComponentTemplateTestMixin, DiameterTestMixin, TestCase):
+    model = CoolingOutflowTemplate
+
+
+class CoolingFeedMaxFlowTestCase(MaxFlowTestMixin, TestCase):
+    model = CoolingFeed
+
+    @classmethod
+    def setUpTestData(cls):
+        site = Site.objects.create(name='Site 1', slug='site-1')
+        cls.cooling_source = CoolingSource.objects.create(
+            site=site, name='Cooling Source 1', type=CoolingSourceTypeChoices.TYPE_CHILLER
+        )
+
+    def create_instance(self, **attrs):
+        return CoolingFeed(
+            cooling_source=self.cooling_source, name=f'Cooling Feed {next(self.sequence)}', **attrs
+        )

netbox/netbox/models/mixins.py

@@ -1,9 +1,11 @@
 from django.core.exceptions import ValidationError
+from django.core.validators import MinValueValidator
 from django.db import models
 from django.utils.translation import gettext_lazy as _
 
 from netbox.choices import *
-from utilities.conversion import to_grams, to_meters
+from utilities.conversion import LENGTH_TO_METERS, WEIGHT_TO_GRAMS, normalized_unit_expression
+from utilities.fields import NonNegativeGeneratedField
 
 __all__ = (
     'DistanceMixin',
@@ -34,7 +36,8 @@ class WeightMixin(models.Model):
         max_digits=8,
         decimal_places=2,
         blank=True,
-        null=True
+        null=True,
+        validators=[MinValueValidator(0)],
     )
     weight_unit = models.CharField(
         verbose_name=_('weight unit'),
@@ -43,10 +46,12 @@ class WeightMixin(models.Model):
         blank=True,
         null=True,
     )
-    # Stores the normalized weight (in grams) for database ordering
-    _abs_weight = models.PositiveBigIntegerField(
-        blank=True,
-        null=True
+    # Normalized weight (in grams), computed by the database for ordering
+    _abs_weight = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('weight', 'weight_unit', WEIGHT_TO_GRAMS, integer=True),
+        output_field=models.BigIntegerField(blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
 
     class Meta:
@@ -57,16 +62,6 @@ class WeightMixin(models.Model):
         # Public alias for _abs_weight; Django templates cannot access underscore-prefixed attributes.
         return self._abs_weight
 
-    def save(self, *args, **kwargs):
-
-        # Store the given weight (if any) in grams for use in database ordering
-        if self.weight and self.weight_unit:
-            self._abs_weight = to_grams(self.weight, self.weight_unit)
-        else:
-            self._abs_weight = None
-
-        super().save(*args, **kwargs)
-
     def clean(self):
         super().clean()
 
@@ -82,6 +77,7 @@ class DistanceMixin(models.Model):
         decimal_places=2,
         blank=True,
         null=True,
+        validators=[MinValueValidator(0)],
     )
     distance_unit = models.CharField(
         verbose_name=_('distance unit'),
@@ -90,12 +86,12 @@ class DistanceMixin(models.Model):
         blank=True,
         null=True,
     )
-    # Stores the normalized distance (in meters) for database ordering
-    _abs_distance = models.DecimalField(
-        max_digits=13,
-        decimal_places=4,
-        blank=True,
-        null=True
+    # Normalized distance (in meters), computed by the database for ordering
+    _abs_distance = NonNegativeGeneratedField(
+        expression=normalized_unit_expression('distance', 'distance_unit', LENGTH_TO_METERS),
+        output_field=models.DecimalField(max_digits=14, decimal_places=4, blank=True, null=True),
+        db_persist=True,
+        null=True,
     )
 
     class Meta:
@@ -107,12 +103,6 @@ class DistanceMixin(models.Model):
         return self._abs_distance
 
     def save(self, *args, **kwargs):
-        # Store the given distance (if any) in meters for use in database ordering
-        if self.distance is not None and self.distance_unit:
-            self._abs_distance = to_meters(self.distance, self.distance_unit)
-        else:
-            self._abs_distance = None
-
         # Clear distance_unit if no distance is defined
         if self.distance is None:
             self.distance_unit = None

netbox/utilities/conversion.py

@@ -1,5 +1,7 @@
-from decimal import Decimal, InvalidOperation
+from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
 
+from django.db.models import BigIntegerField, Case, DecimalField, F, Value, When
+from django.db.models.functions import Cast, Floor
 from django.utils.translation import gettext as _
 
 from dcim.choices import CableLengthUnitChoices
@@ -10,6 +12,11 @@ from netbox.choices import (
 )
 
 __all__ = (
+    'DIAMETER_TO_MILLIMETERS',
+    'FLOW_RATE_TO_LITERS_PER_MINUTE',
+    'LENGTH_TO_METERS',
+    'WEIGHT_TO_GRAMS',
+    'normalized_unit_expression',
     'to_grams',
     'to_liters_per_minute',
     'to_meters',
@@ -17,12 +24,75 @@ __all__ = (
 )
 
 
-def _normalized_measurement(value, unit, converters, quantity, precision=4) -> Decimal:
+#
+# Conversion factors
+#
+
+# Each mapping gives the multiplier from a unit to its base unit as a Decimal literal. The to_*() helpers and the
+# GeneratedField expressions built by normalized_unit_expression() both read these, so changing a factor (or adding
+# a unit) requires a migration to drop and re-add the affected generated columns.
+WEIGHT_TO_GRAMS = {
+    WeightUnitChoices.UNIT_KILOGRAM: Decimal('1000'),
+    WeightUnitChoices.UNIT_GRAM: Decimal('1'),
+    WeightUnitChoices.UNIT_POUND: Decimal('453.592'),
+    WeightUnitChoices.UNIT_OUNCE: Decimal('28.3495'),
+}
+
+# Shared by cable lengths and distances; DistanceUnitChoices is a subset of CableLengthUnitChoices
+LENGTH_TO_METERS = {
+    CableLengthUnitChoices.UNIT_KILOMETER: Decimal('1000'),
+    CableLengthUnitChoices.UNIT_METER: Decimal('1'),
+    CableLengthUnitChoices.UNIT_CENTIMETER: Decimal('0.01'),
+    CableLengthUnitChoices.UNIT_MILE: Decimal('1609.344'),
+    CableLengthUnitChoices.UNIT_FOOT: Decimal('0.3048'),
+    CableLengthUnitChoices.UNIT_INCH: Decimal('0.0254'),
+}
+
+DIAMETER_TO_MILLIMETERS = {
+    DiameterUnitChoices.UNIT_MILLIMETER: Decimal('1'),
+    DiameterUnitChoices.UNIT_CENTIMETER: Decimal('10'),
+    DiameterUnitChoices.UNIT_INCH: Decimal('25.4'),
+}
+
+FLOW_RATE_TO_LITERS_PER_MINUTE = {
+    FlowRateUnitChoices.UNIT_LITERS_PER_MINUTE: Decimal('1'),
+    FlowRateUnitChoices.UNIT_CUBIC_METERS_PER_HOUR: Decimal('16.66666666666666666666666667'),  # 1000 / 60
+    FlowRateUnitChoices.UNIT_GALLONS_PER_MINUTE: Decimal('3.785411784'),
+}
+
+
+#
+# Database expressions
+#
+
+def normalized_unit_expression(value_field, unit_field, factors, integer=False):
+    """
+    Return a database expression converting `value_field` to its base unit according to the value of `unit_field`,
+    per the given mapping of unit to factor. Evaluates to NULL if either field is NULL or the unit is unrecognized.
+    With `integer=True`, the result is truncated to a whole number (as to_grams() does) and cast to a bigint.
+    """
+    # Cast to numeric so that an integer source column cannot overflow integer arithmetic
+    value = Cast(F(value_field), output_field=DecimalField())
+    expression = Case(*[
+        When(**{unit_field: unit}, then=value * Value(factor))
+        for unit, factor in factors.items()
+    ])
+    if integer:
+        expression = Cast(Floor(expression), output_field=BigIntegerField())
+    return expression
+
+
+#
+# Python conversions
+#
+
+def _normalized_measurement(value, unit, factors, quantity, precision=4) -> Decimal:
     """
     Shared implementation for the unit-normalization helpers below. Coerce `value` to a non-negative
-    Decimal, apply the matching per-unit converter, and round the result to `precision` decimal places.
-    `converters` maps each valid unit to a callable receiving the Decimal value; `quantity` labels the
-    value in error messages. Pass `precision=None` to return the unrounded result.
+    Decimal, multiply by the factor for `unit`, and round the result to `precision` decimal places.
+    `factors` maps each valid unit to its multiplier; `quantity` labels the value in error messages.
+    Pass `precision=None` to return the unrounded result. Rounding is half away from zero, matching how
+    PostgreSQL stores the same result in a generated numeric column.
     """
     try:
         value = Decimal(value)
@@ -32,15 +102,17 @@ def _normalized_measurement(value, unit, converters, quantity, precision=4) -> D
         )
     if value < 0:
         raise ValueError(_("Invalid value for {quantity}: must be a positive number").format(quantity=quantity))
-    if unit not in converters:
+    if unit not in factors:
         raise ValueError(
             _("Unknown unit {unit}. Must be one of the following: {valid_units}").format(
                 unit=unit,
-                valid_units=', '.join(converters)
+                valid_units=', '.join(factors)
             )
         )
-    result = converters[unit](value)
-    return result if precision is None else round(result, precision)
+    result = value * factors[unit]
+    if precision is None:
+        return result
+    return result.quantize(Decimal(1).scaleb(-precision), rounding=ROUND_HALF_UP)
 
 
 def to_grams(weight, unit) -> int:
@@ -49,45 +121,25 @@ def to_grams(weight, unit) -> int:
     """
     # Rounding is suppressed so that the result is truncated exactly as the caller's int() expects; rounding
     # first could nudge a value across an integer boundary.
-    return int(_normalized_measurement(weight, unit, {
-        WeightUnitChoices.UNIT_KILOGRAM: lambda v: v * 1000,
-        WeightUnitChoices.UNIT_GRAM: lambda v: v,
-        WeightUnitChoices.UNIT_POUND: lambda v: v * Decimal(453.592),
-        WeightUnitChoices.UNIT_OUNCE: lambda v: v * Decimal(28.3495),
-    }, _('weight'), precision=None))
+    return int(_normalized_measurement(weight, unit, WEIGHT_TO_GRAMS, _('weight'), precision=None))
 
 
 def to_meters(length, unit) -> Decimal:
     """
     Convert the given length to meters, returning a Decimal value.
     """
-    return _normalized_measurement(length, unit, {
-        CableLengthUnitChoices.UNIT_KILOMETER: lambda v: v * 1000,
-        CableLengthUnitChoices.UNIT_METER: lambda v: v,
-        CableLengthUnitChoices.UNIT_CENTIMETER: lambda v: v / 100,
-        CableLengthUnitChoices.UNIT_MILE: lambda v: v * Decimal(1609.344),
-        CableLengthUnitChoices.UNIT_FOOT: lambda v: v * Decimal(0.3048),
-        CableLengthUnitChoices.UNIT_INCH: lambda v: v * Decimal(0.0254),
-    }, _('length'))
+    return _normalized_measurement(length, unit, LENGTH_TO_METERS, _('length'))
 
 
 def to_millimeters(diameter, unit) -> Decimal:
     """
     Convert the given diameter to millimeters, returning a Decimal value.
     """
-    return _normalized_measurement(diameter, unit, {
-        DiameterUnitChoices.UNIT_MILLIMETER: lambda v: v,
-        DiameterUnitChoices.UNIT_CENTIMETER: lambda v: v * 10,
-        DiameterUnitChoices.UNIT_INCH: lambda v: v * Decimal('25.4'),
-    }, _('diameter'))
+    return _normalized_measurement(diameter, unit, DIAMETER_TO_MILLIMETERS, _('diameter'))
 
 
 def to_liters_per_minute(flow_rate, unit) -> Decimal:
     """
     Convert the given flow rate to liters per minute, returning a Decimal value.
     """
-    return _normalized_measurement(flow_rate, unit, {
-        FlowRateUnitChoices.UNIT_LITERS_PER_MINUTE: lambda v: v,
-        FlowRateUnitChoices.UNIT_CUBIC_METERS_PER_HOUR: lambda v: v * Decimal(1000) / Decimal(60),
-        FlowRateUnitChoices.UNIT_GALLONS_PER_MINUTE: lambda v: v * Decimal('3.785411784'),
-    }, _('flow rate'))
+    return _normalized_measurement(flow_rate, unit, FLOW_RATE_TO_LITERS_PER_MINUTE, _('flow rate'))

netbox/utilities/fields.py

@@ -8,7 +8,6 @@ from django.db.models.fields.mixins import FieldCacheMixin
 from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 
-from .forms.widgets import ColorSelect
 from .validators import ColorValidator
 
 __all__ = (
@@ -16,6 +15,7 @@ __all__ = (
     'CounterCacheField',
     'GenericArrayForeignKey',
     'NaturalOrderingField',
+    'NonNegativeGeneratedField',
     'RestrictedGenericForeignKey',
 )
 
@@ -29,10 +29,24 @@ class ColorField(models.CharField):
         super().__init__(*args, **kwargs)
 
     def formfield(self, **kwargs):
+        # Imported here because utilities.forms indirectly imports netbox.models, which imports this module
+        from .forms.widgets import ColorSelect
         kwargs['widget'] = ColorSelect
         return super().formfield(**kwargs)
 
 
+class NonNegativeGeneratedField(models.GeneratedField):
+    """
+    A generated column which the database constrains to non-negative values via an inline CHECK, as it would a
+    PositiveIntegerField. Django emits no check for a GeneratedField's output_field because that field is never
+    bound to a column, so the check is supplied here from the generated column itself.
+    """
+    def db_parameters(self, connection):
+        params = super().db_parameters(connection)
+        params['check'] = f'{connection.ops.quote_name(self.column)} >= 0'
+        return params
+
+
 class NaturalOrderingField(models.CharField):
     """
     A field which stores a naturalized representation of its target field, to be used for ordering its parent model.

netbox/utilities/testing/mixins.py

@@ -1,9 +1,15 @@
+import itertools
+from decimal import Decimal
+
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError, models, transaction
 from django.test.testcases import SerializeMixin
 from django_rq import get_queue
 from django_rq.workers import get_worker
 from rq import SimpleWorker
 
 __all__ = (
+    'NormalizedMeasurementTestMixin',
     'RQQueueTestMixin',
 )
 
@@ -54,3 +60,163 @@ class RQQueueTestMixin(SerializeMixin):
             self.clear_rq_queues()
         finally:
             super().tearDown()
+
+
+class NormalizedMeasurementTestMixin:
+    """
+    Exercise a database-generated column that normalizes a measurement to its base unit. The column is checked
+    against the matching to_*() helper for every unit choice, across each write path: save(), QuerySet.update(),
+    bulk_update(), and bulk_create(). Subclasses set the attributes below and implement create_instance().
+    """
+    model = None
+    value_field = None       # e.g. 'distance'
+    unit_field = None        # e.g. 'distance_unit'
+    normalized_field = None  # e.g. '_abs_distance'
+    unit_choices = None      # e.g. DistanceUnitChoices
+    converter = None         # e.g. staticmethod(to_meters)
+    value = Decimal('123.45')
+
+    def setUp(self):
+        super().setUp()
+        self.sequence = itertools.count(1)
+
+    def create_instance(self, **attrs):
+        """
+        Return an unsaved instance of the model with the given attributes set. Each call must yield an instance
+        which can be saved alongside those from previous calls; next(self.sequence) supplies a unique number.
+        """
+        raise NotImplementedError
+
+    @property
+    def units(self):
+        return self.unit_choices.values()
+
+    @property
+    def max_value(self):
+        """
+        The largest value the source field can store.
+        """
+        field = self.model._meta.get_field(self.value_field)
+        if isinstance(field, models.DecimalField):
+            return Decimal('9' * (field.max_digits - field.decimal_places) + '.' + '9' * field.decimal_places)
+        return 2**31 - 1  # PositiveIntegerField
+
+    def assertNormalized(self, instance, value, unit):
+        """
+        Assert that the stored normalized value matches the converter's result for the given measurement.
+        """
+        expected = self.converter(value, unit) if value is not None and unit else None
+        instance.refresh_from_db()
+        self.assertEqual(getattr(instance, self.normalized_field), expected)
+
+    def test_save(self):
+        for unit in self.units:
+            with self.subTest(unit=unit):
+                instance = self.create_instance(**{self.value_field: self.value, self.unit_field: unit})
+                instance.save()
+                # The database returns the computed value on save, so it is available without a refresh
+                self.assertEqual(getattr(instance, self.normalized_field), self.converter(self.value, unit))
+                self.assertNormalized(instance, self.value, unit)
+
+    def test_max_value(self):
+        """
+        The normalized column must be wide enough to hold the source field's maximum value in every unit.
+        """
+        for unit in self.units:
+            # Isolate each unit so that an overflow in one does not abort the transaction for the rest
+            with self.subTest(unit=unit), transaction.atomic():
+                instance = self.create_instance(**{self.value_field: self.max_value, self.unit_field: unit})
+                instance.save()
+                self.assertNormalized(instance, self.max_value, unit)
+
+    def test_save_existing(self):
+        instance = self.create_instance()
+        instance.save()
+        for unit in self.units:
+            with self.subTest(unit=unit):
+                setattr(instance, self.value_field, self.value)
+                setattr(instance, self.unit_field, unit)
+                instance.save()
+                # An UPDATE also returns the computed value, so change logging sees the current value
+                self.assertEqual(getattr(instance, self.normalized_field), self.converter(self.value, unit))
+                self.assertNormalized(instance, self.value, unit)
+
+    def test_update(self):
+        instance = self.create_instance()
+        instance.save()
+        for unit in self.units:
+            with self.subTest(unit=unit):
+                self.model.objects.filter(pk=instance.pk).update(**{
+                    self.value_field: self.value,
+                    self.unit_field: unit,
+                })
+                self.assertNormalized(instance, self.value, unit)
+
+    def test_bulk_update(self):
+        instance = self.create_instance()
+        instance.save()
+        for unit in self.units:
+            with self.subTest(unit=unit):
+                setattr(instance, self.value_field, self.value)
+                setattr(instance, self.unit_field, unit)
+                self.model.objects.bulk_update([instance], [self.value_field, self.unit_field])
+                self.assertNormalized(instance, self.value, unit)
+
+    def test_bulk_create(self):
+        instances = self.model.objects.bulk_create([
+            self.create_instance(**{self.value_field: self.value, self.unit_field: unit})
+            for unit in self.units
+        ])
+        for instance, unit in zip(instances, self.units):
+            with self.subTest(unit=unit):
+                self.assertNormalized(instance, self.value, unit)
+
+    def test_negative_value_rejected(self):
+        """
+        A negative measurement must fail validation on the source field.
+        """
+        instance = self.create_instance(**{self.value_field: -self.value, self.unit_field: self.units[0]})
+        with self.assertRaises(ValidationError) as cm:
+            instance.full_clean()
+        self.assertIn(self.value_field, cm.exception.error_dict)
+
+    def test_negative_value_rejected_by_database(self):
+        """
+        Write paths which skip validation must still be unable to store a negative measurement.
+        """
+        unit = self.units[0]
+        negative = {self.value_field: -self.value, self.unit_field: unit}
+        instance = self.create_instance(**{self.value_field: self.value, self.unit_field: unit})
+        instance.save()
+
+        def assert_rejected(label, write):
+            with self.subTest(write_path=label):
+                with self.assertRaises(IntegrityError), transaction.atomic():
+                    write()
+
+        def save():
+            for attr, value in negative.items():
+                setattr(instance, attr, value)
+            instance.save()
+
+        def bulk_update():
+            for attr, value in negative.items():
+                setattr(instance, attr, value)
+            self.model.objects.bulk_update([instance], list(negative))
+
+        assert_rejected('save', save)
+        assert_rejected('update', lambda: self.model.objects.filter(pk=instance.pk).update(**negative))
+        assert_rejected('bulk_update', bulk_update)
+        assert_rejected('bulk_create', lambda: self.model.objects.bulk_create([self.create_instance(**negative)]))
+
+    def test_null_without_value_or_unit(self):
+        unit = self.units[0]
+        instance = self.create_instance(**{self.value_field: self.value, self.unit_field: unit})
+        instance.save()
+        queryset = self.model.objects.filter(pk=instance.pk)
+
+        queryset.update(**{self.value_field: None})
+        self.assertNormalized(instance, None, unit)
+
+        queryset.update(**{self.value_field: self.value, self.unit_field: None})
+        self.assertNormalized(instance, self.value, None)

netbox/utilities/tests/test_conversions.py

@@ -1,12 +1,20 @@
 from decimal import Decimal
 
+from django.db import connection
+
 from dcim.choices import CableLengthUnitChoices
+from dcim.models import DeviceType
 from netbox.choices import (
     DiameterUnitChoices,
+    DistanceUnitChoices,
     FlowRateUnitChoices,
     WeightUnitChoices,
 )
 from utilities.conversion import (
+    DIAMETER_TO_MILLIMETERS,
+    FLOW_RATE_TO_LITERS_PER_MINUTE,
+    LENGTH_TO_METERS,
+    WEIGHT_TO_GRAMS,
     to_grams,
     to_liters_per_minute,
     to_meters,
@@ -17,6 +25,31 @@ from utilities.testing.base import TestCase
 
 class ConversionsTestCase(TestCase):
 
+    def test_factors_cover_all_units(self):
+        """
+        Every unit choice must have a conversion factor, as the factors drive both the to_*() helpers and the
+        generated columns which normalize measurements.
+        """
+        for factors, choices in (
+            (WEIGHT_TO_GRAMS, WeightUnitChoices),
+            (LENGTH_TO_METERS, CableLengthUnitChoices),
+            (LENGTH_TO_METERS, DistanceUnitChoices),
+            (DIAMETER_TO_MILLIMETERS, DiameterUnitChoices),
+            (FLOW_RATE_TO_LITERS_PER_MINUTE, FlowRateUnitChoices),
+        ):
+            with self.subTest(choices=choices.__name__):
+                self.assertTrue(set(choices.values()) <= set(factors))
+                for factor in factors.values():
+                    self.assertIsInstance(factor, Decimal)
+
+    def test_normalized_columns_are_checked_non_negative(self):
+        """
+        Each generated column must carry an inline database check so that a negative measurement cannot be stored
+        through any write path.
+        """
+        field = DeviceType._meta.get_field('_abs_weight')
+        self.assertEqual(field.db_parameters(connection)['check'], '"_abs_weight" >= 0')
+
     def test_to_grams(self):
         self.assertEqual(
             to_grams(1, WeightUnitChoices.UNIT_KILOGRAM),
@@ -88,6 +121,11 @@ class ConversionsTestCase(TestCase):
             to_meters(1, CableLengthUnitChoices.UNIT_INCH),
             Decimal('0.0254')
         )
+        # Ties round half away from zero, matching the generated database columns
+        self.assertEqual(
+            to_meters(Decimal('0.75'), CableLengthUnitChoices.UNIT_INCH),
+            Decimal('0.0191')
+        )
 
     def test_to_millimeters(self):
         self.assertEqual(

netbox/wireless/migrations/0025_generated_fields.py

@@ -0,0 +1,110 @@
+# Generated by Django 6.1.2 on 2026-10-14 00:11
+
+from decimal import Decimal
+
+import django.core.validators
+import django.db.models.expressions
+import django.db.models.functions.comparison
+from django.db import migrations, models
+
+import utilities.fields
+
+
+# PostgreSQL cannot convert an existing column to a generated column in place, so each normalized
+# column is dropped and re-added. The database computes the values for all existing rows.
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("wireless", "0024_fix_ltree_cascade_triggers"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="wirelesslink",
+            name="_abs_distance",
+        ),
+        migrations.AddField(
+            model_name="wirelesslink",
+            name="_abs_distance",
+            field=utilities.fields.NonNegativeGeneratedField(
+                db_persist=True,
+                expression=models.Case(
+                    models.When(
+                        distance_unit="km",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1000")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="m",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="cm",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.01")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="mi",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("1609.344")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="ft",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.3048")),
+                        ),
+                    ),
+                    models.When(
+                        distance_unit="in",
+                        then=django.db.models.expressions.CombinedExpression(
+                            django.db.models.functions.comparison.Cast(
+                                models.F("distance"), output_field=models.DecimalField()
+                            ),
+                            "*",
+                            models.Value(Decimal("0.0254")),
+                        ),
+                    ),
+                ),
+                null=True,
+                output_field=models.DecimalField(
+                    blank=True, decimal_places=4, max_digits=14, null=True
+                ),
+            ),
+        ),
+        migrations.AlterField(
+            model_name="wirelesslink",
+            name="distance",
+            field=models.DecimalField(
+                blank=True,
+                decimal_places=2,
+                max_digits=8,
+                null=True,
+                validators=[django.core.validators.MinValueValidator(0)],
+            ),
+        ),
+    ]

netbox/wireless/tests/test_models.py

@@ -6,9 +6,12 @@ from django.test import RequestFactory, TestCase
 from core.models import ObjectChange
 from dcim.choices import InterfaceTypeChoices
 from dcim.models import Interface, Region, Site, SiteGroup
+from netbox.choices import DistanceUnitChoices
 from netbox.context_managers import event_tracking
 from users.models import User
+from utilities.conversion import to_meters
 from utilities.testing import create_test_device
+from utilities.testing.mixins import NormalizedMeasurementTestMixin
 from wireless.models import WirelessLAN, WirelessLink
 
 
@@ -106,3 +109,26 @@ class WirelessLinkTestCase(TestCase):
                 changed_object_id__in=(interface_a.pk, interface_b.pk),
             ).exists()
         )
+
+
+class WirelessLinkDistanceTestCase(NormalizedMeasurementTestMixin, TestCase):
+    model = WirelessLink
+    value_field = 'distance'
+    unit_field = 'distance_unit'
+    normalized_field = '_abs_distance'
+    unit_choices = DistanceUnitChoices
+    converter = staticmethod(to_meters)
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.device = create_test_device('Device 1')
+
+    def create_instance(self, **attrs):
+        index = next(self.sequence)
+        interface_a = Interface.objects.create(
+            device=self.device, name=f'Wireless {index}A', type=InterfaceTypeChoices.TYPE_80211A
+        )
+        interface_b = Interface.objects.create(
+            device=self.device, name=f'Wireless {index}B', type=InterfaceTypeChoices.TYPE_80211A
+        )
+        return WirelessLink(interface_a=interface_a, interface_b=interface_b, **attrs)