snowflake-ml-python 1.46.0__tar.gz → 1.47.0__tar.gz

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/CHANGELOG.md

@@ -1,6 +1,39 @@
 # Release History
 
-## 1.46.0
+## 1.47.0
+
+### New Features
+
+* Experiment Tracking: Added `ExperimentTracking.list_model_versions` to retrieve the model versions that were
+  logged under a run. Models logged via `log_model` inside a run are linked to that run through Snowflake lineage,
+  and this method traverses that lineage to return the corresponding `ModelVersion` objects.
+
+```python
+from snowflake.ml.experiment import ExperimentTracking
+
+exp = ExperimentTracking(session)
+exp.set_experiment("MY_EXPERIMENT")
+with exp.start_run(run_name="MY_RUN"):
+    exp.log_model(model, model_name="MY_MODEL", sample_input_data=X)
+
+model_versions = exp.list_model_versions(run_name="MY_RUN")
+```
+
+### Bug Fixes
+
+* Experiment Tracking: Fix a bug where `.set_experiment` does not recreate an experiment deleted in Snowsight
+
+### Behavior Changes
+
+* Registry: `enable_explainability` now defaults to `False` for all model types when logging a model. Previously it
+  defaulted to `True` for XGBoost, LightGBM, and CatBoost models and was auto-enabled for supported scikit-learn and
+  Snowpark ML modeling models when running in the Warehouse. To generate an `explain` method, explicitly pass
+  `options={"enable_explainability": True}` to `log_model` (this requires `sample_input_data` for supported model
+  types).
+
+### Deprecations
+
+## 1.46.0 (2026-07-07)
 
 ### New Features
 

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.46.0
+Version: 1.47.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -250,7 +250,7 @@ Requires-Dist: pyjwt<3,>=2.0.0
 Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
-Requires-Dist: scikit-learn<1.8
+Requires-Dist: scikit-learn<1.9
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: shap<1,>=0.46.0
 Requires-Dist: snowflake-connector-python[pandas]<5,>=3.17.3
@@ -416,7 +416,40 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.46.0
+## 1.47.0
+
+### New Features
+
+* Experiment Tracking: Added `ExperimentTracking.list_model_versions` to retrieve the model versions that were
+  logged under a run. Models logged via `log_model` inside a run are linked to that run through Snowflake lineage,
+  and this method traverses that lineage to return the corresponding `ModelVersion` objects.
+
+```python
+from snowflake.ml.experiment import ExperimentTracking
+
+exp = ExperimentTracking(session)
+exp.set_experiment("MY_EXPERIMENT")
+with exp.start_run(run_name="MY_RUN"):
+    exp.log_model(model, model_name="MY_MODEL", sample_input_data=X)
+
+model_versions = exp.list_model_versions(run_name="MY_RUN")
+```
+
+### Bug Fixes
+
+* Experiment Tracking: Fix a bug where `.set_experiment` does not recreate an experiment deleted in Snowsight
+
+### Behavior Changes
+
+* Registry: `enable_explainability` now defaults to `False` for all model types when logging a model. Previously it
+  defaulted to `True` for XGBoost, LightGBM, and CatBoost models and was auto-enabled for supported scikit-learn and
+  Snowpark ML modeling models when running in the Warehouse. To generate an `explain` method, explicitly pass
+  `options={"enable_explainability": True}` to `log_model` (this requires `sample_input_data` for supported model
+  types).
+
+### Deprecations
+
+## 1.46.0 (2026-07-07)
 
 ### New Features
 

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.14"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.9", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/experiment/experiment_tracking.py

@@ -24,6 +24,7 @@ from snowflake.ml.experiment._client import (
     experiment_tracking_sql_client as sql_client,
 )
 from snowflake.ml.experiment._entities import run_metadata
+from snowflake.ml.lineage import lineage_node
 from snowflake.ml.model import type_hints
 from snowflake.ml.utils import sql_client as sql_client_utils
 
@@ -196,21 +197,22 @@ class ExperimentTracking:
         schema_name = sql_identifier.SqlIdentifier(schema_name) if schema_name is not None else self._schema_name
 
         experiment_name = sql_identifier.SqlIdentifier(experiment_name)
-        if (
+        if not (
             self._experiment
             and self._experiment.name == experiment_name
             and self._database_name == database_name
             and self._schema_name == schema_name
         ):
-            return self._experiment
+            # If the requested experiment differs from the current one, switch context (and drop any active run)
+            self._update_database_and_schema(database_name, schema_name)
+            self._experiment = entities.Experiment(experiment_name=experiment_name)
+            self._unset_run()
 
-        self._update_database_and_schema(database_name, schema_name)
+        # Always attempt to create idempotently so an experiment that was deleted (e.g. via the UI) is restored.
         self._sql_client.create_experiment(
             experiment_name=experiment_name,
             creation_mode=sql_client_utils.CreationMode(if_not_exists=True),
         )
-        self._experiment = entities.Experiment(experiment_name=experiment_name)
-        self._unset_run()
         return self._experiment
 
     def delete_experiment(
@@ -267,6 +269,44 @@ class ExperimentTracking:
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
             return self._registry.log_model(model, model_name=model_name, **kwargs)
 
+    def list_model_versions(self, run_name: Optional[str] = None) -> list[ml_model.ModelVersion]:
+        """
+        List the model versions that were logged under a run.
+
+        Models logged via ``log_model`` inside a run are linked to that run through Snowflake lineage. This method
+        traverses that lineage to return the corresponding model versions.
+
+        Args:
+            run_name: The name of the run to list model versions from. If None, uses the currently active run.
+
+        Returns:
+            A list of ModelVersion objects that were logged under the run.
+
+        Raises:
+            RuntimeError: If no experiment is set, or if no run_name is provided and no run is active.
+        """
+        if not self._experiment:
+            raise RuntimeError("No experiment set. Please set an experiment before listing model versions.")
+
+        if run_name:
+            resolved_run_name = sql_identifier.SqlIdentifier(run_name)
+        elif self._run:
+            resolved_run_name = self._run.name
+        else:
+            raise RuntimeError("No run is active. Please provide a run_name or start a run.")
+
+        experiment_fqn = self._sql_client.fully_qualified_object_name(
+            self._database_name, self._schema_name, self._experiment.name
+        )
+        run_node = lineage_node.LineageNode(
+            session=self._session,
+            name=experiment_fqn,
+            domain="experiment",
+            version=resolved_run_name.identifier(),
+        )
+        logged_models = run_node.lineage(direction="downstream", domain_filter={"model"})
+        return [model for model in logged_models if isinstance(model, ml_model.ModelVersion)]
+
     def start_run(
         self,
         run_name: Optional[str] = None,

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/aggregation.py

@@ -19,6 +19,11 @@ from snowflake.ml.feature_store.interval_utils import (  # noqa: F401 - re-expor
     parse_interval as parse_interval,
 )
 
+# Product-wide upper bound on ``n`` for the ordered-N list aggregations
+# (last_n / first_n / last_distinct_n / first_distinct_n). Enforced at authoring
+# time so users get a clear error, and matched by the engine's own bound.
+_MAX_ORDERED_N = 100
+
 
 class AggregationType(Enum):
     """Supported aggregation functions for tiled feature views.
@@ -161,6 +166,11 @@ class AggregationSpec:
                 raise ValueError(
                     f"Parameter 'n' must be a positive integer for aggregation " f"'{self.output_column}', got: {n}"
                 )
+            if n > _MAX_ORDERED_N:
+                raise ValueError(
+                    f"Parameter 'n' must be between 1 and {_MAX_ORDERED_N} for "
+                    f"{self.function.value} aggregation '{self.output_column}', got: {n}"
+                )
 
         # Validate params for approx_percentile
         if self.function == AggregationType.APPROX_PERCENTILE:

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/feature_group.py

@@ -730,6 +730,26 @@ def _resolve_fg_output_columns(fg: FeatureGroup) -> list[str]:
     return cols
 
 
+def _normalize_join_key_datatype(datatype: Any) -> Any:
+    """Collapse ``StringType`` VARCHAR length so join keys compare by logical type.
+
+    A shared string join key can surface with different VARCHAR lengths across
+    sources -- e.g. a tiled FeatureView exposes the unbounded ``StringType()``
+    default while a batch FeatureView read back through its materialized dynamic
+    table reports a length narrowed to its stored data. The length is irrelevant
+    to join semantics and to the response schema, so all ``StringType`` variants
+    normalize to the unbounded ``StringType()``. Other datatypes pass through
+    unchanged.
+
+    Args:
+        datatype: A Snowpark datatype from a source's join-key column.
+
+    Returns:
+        ``StringType()`` for any ``StringType`` input; ``datatype`` otherwise.
+    """
+    return StringType() if isinstance(datatype, StringType) else datatype
+
+
 def _fg_join_key_field_types(fg: FeatureGroup, *, strict: bool = False) -> dict[str, Any]:
     """Resolve ``{join_key -> Snowpark datatype}`` across every source FV.
 
@@ -787,6 +807,7 @@ def _fg_join_key_field_types(fg: FeatureGroup, *, strict: bool = False) -> dict[
         else:
             iterator = ((f.name, f.datatype) for f in fv.output_schema.fields if f.name in pk)
         for name, datatype in iterator:
+            datatype = _normalize_join_key_datatype(datatype)
             previous = type_by_name.get(name)
             if previous is None:
                 type_by_name[name] = datatype

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/feature_store.py

@@ -1028,6 +1028,14 @@ class FeatureStore:
                     original_exception=ValueError(f"Entity {e.name} has not been registered."),
                 )
 
+        # Fail fast if name+version or a column would overflow the Postgres online store identifiers.
+        try:
+            feature_view._validate_online_store_identifier_budget(version)
+        except ValueError as e:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT, original_exception=e
+            ) from e
+
         # RTFVs are OFT-only (no DT/View, no preamble/postamble).
         if feature_view.is_realtime_feature_view:
             logger.warning("RealtimeFeatureView is in Public Preview since 1.43.0.")
@@ -1463,6 +1471,9 @@ class FeatureStore:
             probe_fv._online_config = online_config
             try:
                 probe_fv._validate_online_store_supported()
+                probe_version = feature_view.version
+                if probe_version is not None:
+                    probe_fv._validate_online_store_identifier_budget(probe_version)
             except ValueError as e:
                 raise snowml_exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ARGUMENT, original_exception=e
@@ -1523,6 +1534,12 @@ class FeatureStore:
                 new_feature_view._online_config = online_config  # no public setter; mirrors __init__
 
             new_feature_view._validate()
+            try:
+                new_feature_view._validate_online_store_identifier_budget(feature_view._version)
+            except ValueError as e:
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT, original_exception=e
+                ) from e
             # update_feature_view cannot mutate the structural invariants that
             # validate_snapshot_config_for_register checks (entities, timestamp_col,
             # refresh_mode, etc.); they were enforced once at registration. Only the
@@ -1932,10 +1949,6 @@ class FeatureStore:
         Returns:
             FeatureView object.
 
-        Raises:
-            SnowflakeMLException: [ValueError] FeatureView with name and version is not found,
-                or incurred exception when reconstructing the FeatureView object.
-
         Example::
 
             >>> fs = FeatureStore(...)
@@ -1958,10 +1971,58 @@ class FeatureStore:
             desc:this is description
 
         """
-        name = SqlIdentifier(name)
-        version = FeatureViewVersion(version)
+        return self._get_feature_view_impl(name, version)
 
-        fv_name = FeatureView._get_physical_name(name, version)
+    @overload
+    def _get_feature_view_impl(
+        self,
+        name: str,
+        version: str,
+        *,
+        raise_if_not_found: Literal[True] = True,
+    ) -> FeatureView:
+        ...
+
+    @overload
+    def _get_feature_view_impl(
+        self,
+        name: str,
+        version: str,
+        *,
+        raise_if_not_found: Literal[False],
+    ) -> Optional[FeatureView]:
+        ...
+
+    def _get_feature_view_impl(
+        self,
+        name: str,
+        version: str,
+        *,
+        raise_if_not_found: bool = True,
+    ) -> Optional[FeatureView]:
+        """Retrieve a registered FeatureView, optionally returning None instead of raising.
+
+        Private helper shared by :meth:`get_feature_view` and :meth:`delete_feature_view`.
+        The public ``get_feature_view`` always raises on NOT_FOUND (``raise_if_not_found=True``).
+        ``delete_feature_view`` passes ``raise_if_not_found=False`` so it can detect an orphaned
+        state (backing DT already dropped) and attempt cleanup without a separate backend probe.
+
+        Args:
+            name: FeatureView name.
+            version: FeatureView version.
+            raise_if_not_found: When True (default) raises SnowflakeMLException on NOT_FOUND.
+                When False, returns None instead.
+
+        Returns:
+            FeatureView if found; None when not found and ``raise_if_not_found`` is False.
+
+        Raises:
+            SnowflakeMLException: [ValueError] FeatureView not found and raise_if_not_found is True.
+        """
+        name_id = SqlIdentifier(name)
+        version_id = FeatureViewVersion(version)
+
+        fv_name = FeatureView._get_physical_name(name_id, version_id)
         results = self._get_fv_backend_representations(fv_name)
         if len(results) == 1:
             return self._compose_feature_view(
@@ -1971,7 +2032,7 @@ class FeatureStore:
             )
         if len(results) == 0:
             # RTFVs are OFT-only; the metadata table is the source of truth.
-            rtfv_meta = self._metadata_manager.get_realtime_config(name.resolved(), str(version))
+            rtfv_meta = self._metadata_manager.get_realtime_config(name_id.resolved(), str(version_id))
             if rtfv_meta is not None:
                 from snowflake.ml.feature_store.realtime_registration import (
                     compose_rtfv_from_metadata,
@@ -1979,9 +2040,11 @@ class FeatureStore:
 
                 return compose_rtfv_from_metadata(self, rtfv_meta)
 
+        if not raise_if_not_found:
+            return None
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.NOT_FOUND,
-            original_exception=ValueError(f"Failed to find FeatureView {name}/{version}: {results}"),
+            original_exception=ValueError(f"Failed to find FeatureView {name_id}/{version_id}: {results}"),
         )
 
     @dispatch_decorator()
@@ -2603,6 +2666,24 @@ class FeatureStore:
             ----------------------
 
         """
+        # For str+version input: look up the FV without raising on NOT_FOUND.
+        # If the backing DT was dropped in a previous partial deletion, resolved will be None;
+        # attempt streaming orphan cleanup. RTFVs are reconstructed from their OFT metadata
+        # so they naturally return non-None here and continue on the normal deletion path.
+        if isinstance(feature_view, str) and version is not None:
+            resolved = self._get_feature_view_impl(feature_view, version, raise_if_not_found=False)
+            if resolved is None:
+                if self._cleanup_orphaned_feature_view_resources(feature_view, version):
+                    logger.warning(
+                        "feature store: FeatureView %s/%s backing object was already dropped; "
+                        "cleaned up orphaned artifacts.",
+                        feature_view,
+                        version,
+                    )
+                    return
+            else:
+                feature_view = resolved
+
         feature_view = self._validate_feature_view_name_and_version_input(feature_view, version)
 
         # TODO: we should leverage lineage graph to check downstream deps, and block the deletion
@@ -2634,7 +2715,7 @@ class FeatureStore:
             )
 
         # Drop companion task first (if any), then snapshot artifacts for this FV.
-        # This mirrors the overwrite cleanup ordering and guarantees we don’t
+        # This mirrors the overwrite cleanup ordering and guarantees we don't
         # leave a running CRON task targeting a deleted snapshot table.
         fv_physical_name = FeatureView._get_physical_name(feature_view.name, feature_view.version)
         self._cleanup_stale_feature_view_resources(
@@ -5557,6 +5638,100 @@ class FeatureStore:
                 e,
             )
 
+    def _cleanup_orphaned_feature_view_resources(self, fv_name: str, version: str) -> bool:
+        """Clean up orphaned companion artifacts for a partially deleted FeatureView.
+
+        Called when the backing DT/View no longer exists but companion artifacts
+        may still be present.  Handles:
+
+        - Streaming ref_count decrement and ``$UDF_TRANSFORMED`` / ``$UDF_TRANSFORMED$BACKFILL``
+          table drops (streaming FVs).
+        - The companion refresh Task (append-only / CRON-scheduled FVs) and, probed
+          independently, the snapshot table and its status row (append-only FVs).
+        - The ``$ONLINE`` companion Online Feature Table (any online-enabled FV), which is
+          named after the FV and outlives a dropped offline DT.
+        - FV metadata row deletion from the metadata table.
+
+        Args:
+            fv_name: Feature view name string (as supplied by the caller).
+            version: Feature view version string.
+
+        Returns:
+            True if any orphaned artifacts were found and cleaned up; False if nothing
+            existed (the caller should re-raise NOT_FOUND in that case).
+        """
+        from snowflake.ml.feature_store.streaming_registration import (
+            cleanup_streaming_feature_view,
+        )
+
+        fv_name_id = SqlIdentifier(fv_name)
+        fv_version = FeatureViewVersion(version)
+        feature_view_name = FeatureView._get_physical_name(fv_name_id, fv_version)
+        fully_qualified_name = self._get_fully_qualified_name(feature_view_name)
+        online_table_name = FeatureView._get_online_table_name(feature_view_name)
+
+        streaming_meta = self._metadata_manager.get_streaming_metadata(fv_name, version)
+
+        # Append-only and CRON-scheduled FVs own a companion refresh Task named after the FV's
+        # physical name; append-only FVs additionally accumulate a $SNAPSHOT table. When the
+        # backing DT was dropped either can be left behind, and a partial deletion may have
+        # removed one but not the other, so probe for each independently rather than inferring
+        # the snapshot table's existence from the Task.
+        has_refresh_task = bool(
+            self._session.sql(
+                f"SHOW TASKS LIKE '{feature_view_name.resolved()}' IN SCHEMA {self._config.full_schema_path}"
+            ).collect(statement_params=self._telemetry_stmp)
+        )
+        snapshot_table_name = FeatureView._get_snapshot_table_name(feature_view_name)
+        has_snapshot_table = bool(
+            self._session.sql(
+                f"SHOW TABLES LIKE '{snapshot_table_name.resolved()}' IN SCHEMA {self._config.full_schema_path}"
+            ).collect(statement_params=self._telemetry_stmp)
+        )
+
+        # Any online-enabled FV owns a $ONLINE Online Feature Table that is independent of the
+        # offline DT, so it can outlive a dropped DT even for plain (non-streaming,
+        # non-append-only) FVs. _find_object returns [] when the OFT preview is disabled.
+        has_online_table = bool(self._find_object("ONLINE FEATURE TABLES", online_table_name))
+
+        # Nothing recoverable from metadata or the backend: let the caller re-raise NOT_FOUND.
+        if streaming_meta is None and not has_refresh_task and not has_snapshot_table and not has_online_table:
+            return False
+
+        if streaming_meta is not None:
+            cleanup_streaming_feature_view(
+                session=self._session,
+                feature_view_name=feature_view_name,
+                version=version,
+                fv_name=fv_name,
+                fv_metadata=_FeatureViewMetadata(entities=[], timestamp_col="", is_streaming=True),
+                metadata_manager=self._metadata_manager,
+                get_fully_qualified_name_fn=self._get_fully_qualified_name,
+                telemetry_stmp=self._telemetry_stmp,
+            )
+
+        # Drop the companion refresh Task and any append-only snapshot table independently:
+        # both names are deterministic and the underlying drops use IF EXISTS, and a partial
+        # deletion may have left only one of the two behind.
+        if has_refresh_task:
+            self._drop_companion_refresh_task(fully_qualified_name)
+        if has_snapshot_table:
+            self._drop_orphaned_snapshot_table(feature_view_name)
+
+        # Best-effort drop of the $ONLINE companion table, which is not covered by
+        # cleanup_streaming_feature_view and is not returned by get_feature_view.
+        if has_online_table:
+            fq_online_name = self._get_fully_qualified_name(online_table_name)
+            try:
+                self._session.sql(f"DROP ONLINE FEATURE TABLE IF EXISTS {fq_online_name}").collect(
+                    statement_params=self._telemetry_stmp
+                )
+            except Exception as e:
+                logger.warning("feature store: failed to drop online feature table %s: %s", fq_online_name, e)
+
+        self._metadata_manager.delete_feature_view_metadata(fv_name, version)
+        return True
+
     def _cleanup_stale_feature_view_resources(
         self,
         feature_view: FeatureView,
@@ -5602,14 +5777,25 @@ class FeatureStore:
                 delete flows pass ``True`` explicitly.
         """
         if not new_has_task:
-            self._session.sql(f"DROP TASK IF EXISTS {fully_qualified_name}").collect(
-                statement_params=self._telemetry_stmp
-            )
+            self._drop_companion_refresh_task(fully_qualified_name)
         if drop_snapshot_table is None:
             drop_snapshot_table = not feature_view.append_only
         if drop_snapshot_table:
             self._drop_orphaned_snapshot_table(feature_view_name)
 
+    def _drop_companion_refresh_task(self, fully_qualified_name: str) -> None:
+        """Drop a feature view's companion refresh Task.
+
+        Append-only and CRON-scheduled FVs own a Task named identically to the offline
+        object's fully qualified name. ``IF EXISTS`` makes this a safe no-op for FVs that
+        never had a Task (Views and duration-based Dynamic Tables).
+
+        Args:
+            fully_qualified_name: Fully qualified name of the offline object, which is also
+                the companion Task name when one exists.
+        """
+        self._session.sql(f"DROP TASK IF EXISTS {fully_qualified_name}").collect(statement_params=self._telemetry_stmp)
+
     def _create_snapshot_table(
         self,
         feature_view: FeatureView,

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/feature_view.py

@@ -58,6 +58,14 @@ _UDF_TRANSFORMED_TABLE_SUFFIX = "$UDF_TRANSFORMED"
 _FEATURE_VIEW_VERSION_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.\-]*$")
 _FEATURE_VIEW_VERSION_MAX_LENGTH = 128
 
+# Postgres online store identifiers must fit PostgreSQL's 63-byte limit (NAMEDATALEN - 1); longer names
+# are silently truncated and can collide. name+version maps to "{name}${version}$UDF_TRANSFORMED"
+# (17 bytes of affixes) and columns to a distinct-N tile column "_PARTIAL_FIRST_DISTINCT_1000_TS_<col>"
+# (32 bytes), so each budget below leaves a 1-byte margin. The padding-guard test rechecks the affixes.
+_PG_IDENTIFIER_BYTE_LIMIT = 63
+_POSTGRES_ONLINE_MAX_NAME_VERSION_LEN = 45
+_POSTGRES_ONLINE_MAX_COLUMN_LEN = 30
+
 _RESULT_SCAN_QUERY_PATTERN = re.compile(
     r".*FROM\s*TABLE\s*\(\s*RESULT_SCAN\s*\(.*",
     flags=re.DOTALL | re.IGNORECASE | re.X,
@@ -2151,6 +2159,52 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                 f"OnlineConfig(store_type=OnlineStoreType.POSTGRES) to enable online storage."
             )
 
+    def _validate_online_store_identifier_budget(self, version: FeatureViewVersion) -> None:
+        """Reject name+version or column names that would overflow the Postgres online store's identifiers.
+
+        Only the Postgres online store is affected; columns get a tighter budget than name+version.
+        Enforced at registration and update, where the version is known.
+
+        Args:
+            version: The feature view version being registered or updated.
+
+        Raises:
+            ValueError: If the combined name+version or any column name exceeds its online store budget.
+        """
+        if (
+            self._online_config is None
+            or not self._online_config.enable
+            or self._online_config.store_type != OnlineStoreType.POSTGRES
+        ):
+            return
+
+        name_version_len = len(self._name.resolved()) + len(str(version))
+        if name_version_len > _POSTGRES_ONLINE_MAX_NAME_VERSION_LEN:
+            raise ValueError(
+                f"feature view name and version are too long for the Postgres online store: "
+                f"'{self._name}' with version '{version}' uses {name_version_len} characters, but the "
+                f"combined limit is {_POSTGRES_ONLINE_MAX_NAME_VERSION_LEN}. Shorten the name or version."
+            )
+
+        resolved_columns: set[str] = set()
+        try:
+            inferred_columns = self._get_column_names()
+        except Exception:
+            inferred_columns = None
+        for column in inferred_columns or []:
+            resolved_columns.add(column.resolved())
+        for entity in self._entities:
+            for join_key in entity.join_keys:
+                key = join_key if isinstance(join_key, SqlIdentifier) else SqlIdentifier(join_key)
+                resolved_columns.add(key.resolved())
+
+        for resolved in sorted(resolved_columns):
+            if len(resolved) > _POSTGRES_ONLINE_MAX_COLUMN_LEN:
+                raise ValueError(
+                    f"column '{resolved}' is too long for the Postgres online store: {len(resolved)} "
+                    f"characters exceeds the limit of {_POSTGRES_ONLINE_MAX_COLUMN_LEN}. Rename the column."
+                )
+
     def _validate_window_offset_alignment(self) -> None:
         """Validate that window and offset are multiples of feature_granularity.
 

{snowflake_ml_python-1.46.0 → snowflake_ml_python-1.47.0}/snowflake/ml/feature_store/realtime_registration.py

@@ -30,6 +30,7 @@ from snowflake.ml._internal.utils.sql_identifier import SqlIdentifier
 from snowflake.ml.feature_store import feature_view as fv_mod, online_service
 from snowflake.ml.feature_store.entity import Entity
 from snowflake.ml.feature_store.feature_group import (
+    _normalize_join_key_datatype,
     build_source_refs,
     hydrate_source_refs,
     reject_name_collision,
@@ -248,7 +249,7 @@ def validate_rtfv_entity_contract(
                 # The upstream declares the entity but the column isn't in its
                 # output_schema; nothing to type-check here.
                 continue
-            datatype = field.datatype
+            datatype = _normalize_join_key_datatype(field.datatype)
             prev = seen_types.get(jk)
             if prev is None:
                 seen_types[jk] = (datatype, upstream_label)
@@ -358,11 +359,12 @@ def resolve_realtime_join_key_fields(feature_view: FeatureView) -> list[Any]:
             field = field_by_name.get(key)
             if field is None:
                 continue
+            datatype = _normalize_join_key_datatype(field.datatype)
             previous = type_by_name.get(key)
             if previous is None:
-                type_by_name[key] = field.datatype
+                type_by_name[key] = datatype
                 source_by_name[key] = label
-            elif previous != field.datatype:
+            elif previous != datatype:
                 # Registry-corruption path: register-time validator should have
                 # rejected this. Defense-in-depth so we don't synthesize a
                 # schema that depends on source order.
@@ -371,7 +373,7 @@ def resolve_realtime_join_key_fields(feature_view: FeatureView) -> list[Any]:
                     original_exception=RuntimeError(
                         f"realtime feature view: join key {key!r} has inconsistent "
                         f"datatypes across upstream sources ({source_by_name[key]} "
-                        f"declares {previous}; {label} declares {field.datatype}). "
+                        f"declares {previous}; {label} declares {datatype}). "
                         "Registry corruption -- the register-time validator should "
                         "have rejected this."
                     ),