fix: Add pin conflict detection to both file and SQL registries

Raises FeatureViewPinConflict when a user pins to an older version while also modifying the feature view definition (schema, source, etc.). Fixes FeatureView.__copy__() to include description and owner fields, which was causing false positive conflict detection. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
feast-dev · franciscojavierarceo · Mar 26, 2026 · Mar 12, 2026 · Mar 12, 2026 · Mar 13, 2026
commit f9e896ff98163f910e6db7108c3d8e9f7c9d357e
@@ -213,7 +213,9 @@ driver_stats = FeatureView(
 )
 ```
 
-When pinning, the other constructor parameters (schema, source, etc.) are ignored — the snapshot's content is used instead. Version history is not modified by a pin; the existing v0, v1, v2, etc. snapshots remain intact.
+When pinning, the feature view definition (schema, source, transformations, etc.) must match the currently active definition. If you've also modified the definition alongside the pin, `feast apply` will raise a `FeatureViewPinConflict` error. To apply changes, use `version="latest"`. To revert, only change the `version` parameter.
+
+The snapshot's content replaces the active feature view. Version history is not modified by a pin; the existing v0, v1, v2, etc. snapshots remain intact.
 
 After reverting with a pin, you can go back to normal auto-incrementing behavior by removing the `version` parameter (or setting it to `"latest"`) and running `feast apply` again. If the restored definition differs from the pinned snapshot, a new version will be created.
 

@@ -138,6 +138,15 @@ def __init__(self, name, version, project=None):
             super().__init__(f"Version {version} of feature view {name} does not exist")
 
 
+class FeatureViewPinConflict(FeastError):
+    def __init__(self, name, version):
+        super().__init__(
+            f"Cannot pin feature view '{name}' to {version} because the definition has also been modified. "
+            f"To pin to an older version, only change the 'version' parameter — do not modify other fields. "
+            f"To apply a new definition, use version='latest' or omit the version parameter."
+        )
+
+
 class OnDemandFeatureViewNotFoundException(FeastObjectNotFoundException):
     def __init__(self, name, project=None):
         if project:

@@ -296,6 +296,8 @@ def __copy__(self):
             sink_source=self.batch_source if self.source_views else None,
             enable_validation=self.enable_validation,
             version=self.version,
+            description=self.description,
+            owner=self.owner,
         )
 
         # This is deliberately set outside of the FV initialization as we do not have the Entity objects.

@@ -31,6 +31,7 @@
     EntityNotFoundException,
     FeatureServiceNotFoundException,
     FeatureViewNotFoundException,
+    FeatureViewPinConflict,
     FeatureViewVersionNotFound,
     PermissionNotFoundException,
     ProjectNotFoundException,
@@ -591,6 +592,34 @@ def apply_feature_view(
                     version_tag(pin_version),
                     project,
                 )
+
+            # Check that the user hasn't also modified the definition.
+            # Compare user's FV (with version="latest") against active FV.
+            self._prepare_registry_for_changes(project)
+            try:
+                active_fv = proto_registry_utils.get_any_feature_view(
+                    self.cached_registry_proto, feature_view.name, project
+                )
+                user_fv_copy = feature_view.__copy__()
+                user_fv_copy.version = "latest"
+                active_fv.version = "latest"
+                # Clear metadata that differs due to registry state
+                user_fv_copy.created_timestamp = active_fv.created_timestamp
+                user_fv_copy.last_updated_timestamp = active_fv.last_updated_timestamp
+                user_fv_copy.current_version_number = active_fv.current_version_number
+                if hasattr(active_fv, "materialization_intervals"):
+                    user_fv_copy.materialization_intervals = (
+                        active_fv.materialization_intervals
+                    )
+                if user_fv_copy != active_fv:
+                    raise FeatureViewPinConflict(
+                        feature_view.name, version_tag(pin_version)
+                    )
+            except FeatureViewNotFoundException:
+                # FV doesn't exist yet — pinning to a version of a non-existent
+                # FV will fail anyway, let it proceed to the normal error path
+                pass
+
             proto_class, python_class = self._proto_class_for_type(
                 record.feature_view_type
             )

@@ -36,6 +36,7 @@
     EntityNotFoundException,
     FeatureServiceNotFoundException,
     FeatureViewNotFoundException,
+    FeatureViewPinConflict,
     FeatureViewVersionNotFound,
     PermissionNotFoundException,
     ProjectNotFoundException,
@@ -629,6 +630,29 @@ def apply_feature_view(
                     version_tag(pin_version),
                     project,
                 )
+
+            # Check that the user hasn't also modified the definition.
+            # Compare user's FV (with version="latest") against active FV.
+            try:
+                active_fv = self._get_any_feature_view(feature_view.name, project)
+                user_fv_copy = feature_view.__copy__()
+                user_fv_copy.version = "latest"
+                active_fv.version = "latest"
+                # Clear metadata that differs due to registry state
+                user_fv_copy.created_timestamp = active_fv.created_timestamp
+                user_fv_copy.last_updated_timestamp = active_fv.last_updated_timestamp
+                user_fv_copy.current_version_number = active_fv.current_version_number
+                if hasattr(active_fv, "materialization_intervals"):
+                    user_fv_copy.materialization_intervals = (
+                        active_fv.materialization_intervals
+                    )
+                if user_fv_copy != active_fv:
+                    raise FeatureViewPinConflict(
+                        feature_view.name, version_tag(pin_version)
+                    )
+            except FeatureViewNotFoundException:
+                pass
+
             snap_type, snap_proto_bytes = snapshot
             proto_class, python_class = self._proto_class_for_type(snap_type)
             snap_proto = proto_class.FromString(snap_proto_bytes)

@@ -7,7 +7,7 @@
 import pytest
 
 from feast.entity import Entity
-from feast.errors import FeatureViewVersionNotFound
+from feast.errors import FeatureViewPinConflict, FeatureViewVersionNotFound
 from feast.feature_view import FeatureView
 from feast.field import Field
 from feast.infra.registry.registry import Registry
@@ -97,8 +97,8 @@ def test_pin_to_v0(self, registry, make_fv):
         fv2 = make_fv(description="updated")
         registry.apply_feature_view(fv2, "test_project", commit=True)
 
-        # Pin to v0
-        fv_pin = make_fv(version="v0")
+        # Pin to v0 (definition must match active FV, only version changes)
+        fv_pin = make_fv(description="updated", version="v0")
         registry.apply_feature_view(fv_pin, "test_project", commit=True)
 
         # Verify active entry has v0's content
@@ -123,8 +123,8 @@ def test_apply_after_pin_creates_new_version(self, registry, make_fv):
         fv2 = make_fv(description="v1 desc")
         registry.apply_feature_view(fv2, "test_project", commit=True)
 
-        # Pin to v0
-        fv_pin = make_fv(version="v0")
+        # Pin to v0 (definition must match active FV, only version changes)
+        fv_pin = make_fv(description="v1 desc", version="v0")
         registry.apply_feature_view(fv_pin, "test_project", commit=True)
 
         # Apply new content (should create new version)
@@ -135,6 +135,38 @@ def test_apply_after_pin_creates_new_version(self, registry, make_fv):
         # Should have v0, v1, and potentially more versions
         assert len(versions) >= 2
 
+    def test_pin_with_modified_definition_raises(self, registry, make_fv):
+        # Create v0
+        fv1 = make_fv(description="original")
+        registry.apply_feature_view(fv1, "test_project", commit=True)
+
+        # Create v1
+        fv2 = make_fv(description="updated")
+        registry.apply_feature_view(fv2, "test_project", commit=True)
+
+        # Attempt to pin to v0 while also changing description
+        fv_pin = make_fv(description="sneaky change", version="v0")
+        with pytest.raises(FeatureViewPinConflict):
+            registry.apply_feature_view(fv_pin, "test_project", commit=True)
+
+    def test_pin_without_modification_succeeds(self, registry, make_fv):
+        # Create v0
+        fv1 = make_fv(description="original")
+        registry.apply_feature_view(fv1, "test_project", commit=True)
+
+        # Create v1
+        fv2 = make_fv(description="updated")
+        registry.apply_feature_view(fv2, "test_project", commit=True)
+
+        # Pin to v0 with same definition as active (only version changes)
+        fv_pin = make_fv(description="updated", version="v0")
+        registry.apply_feature_view(fv_pin, "test_project", commit=True)
+
+        # Verify active entry has v0's content
+        active_fv = registry.get_feature_view("driver_stats", "test_project")
+        assert active_fv.description == "original"
+        assert active_fv.version == "v0"
+
     def test_version_in_proto_roundtrip(self, registry, make_fv):
         fv = make_fv(version="v3")
         # Manually set version number for testing