snowflake-cli 3.12.0__py3-none-any.whl → 3.13.0__py3-none-any.whl

snowflake/cli/_plugins/dbt/manager.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from collections import defaultdict
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import List, Optional, TypedDict
+from typing import Dict, List, Optional, TypedDict
 
 import yaml
 from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
@@ -35,6 +35,7 @@ from snowflake.connector.errors import ProgrammingError
 
 class DBTObjectEditableAttributes(TypedDict):
     default_target: Optional[str]
+    external_access_integrations: Optional[List[str]]
 
 
 class DBTManager(SqlExecutionMixin):
@@ -70,11 +71,25 @@ class DBTManager(SqlExecutionMixin):
 
         row = rows[0]
         # Convert row to dict using column names
-        columns = [desc[0] for desc in cursor.description]
+        columns = [desc[0].lower() for desc in cursor.description]
         row_dict = dict(zip(columns, row))
 
+        external_access_integrations = row_dict.get("external_access_integrations")
+        if external_access_integrations:
+            if isinstance(external_access_integrations, str):
+                external_access_integrations = [
+                    x.strip()
+                    for x in external_access_integrations.strip("[]").split(",")
+                    if x.strip()
+                ]
+            elif not isinstance(external_access_integrations, list):
+                external_access_integrations = None
+        else:
+            external_access_integrations = None
+
         return DBTObjectEditableAttributes(
-            default_target=row_dict.get("default_target")
+            default_target=row_dict.get("default_target"),
+            external_access_integrations=external_access_integrations,
         )
 
     def deploy(
@@ -86,6 +101,7 @@ class DBTManager(SqlExecutionMixin):
         default_target: Optional[str] = None,
         unset_default_target: bool = False,
         external_access_integrations: Optional[List[str]] = None,
+        install_local_deps: bool = False,
     ) -> SnowflakeCursor:
         dbt_project_path = path / "dbt_project.yml"
         if not dbt_project_path.exists():
@@ -125,7 +141,11 @@ class DBTManager(SqlExecutionMixin):
         with cli_console.phase("Creating DBT project"):
             if force is True:
                 return self._deploy_create_or_replace(
-                    fqn, stage_name, default_target, external_access_integrations
+                    fqn,
+                    stage_name,
+                    default_target,
+                    external_access_integrations,
+                    install_local_deps,
                 )
             else:
                 dbt_object_attributes = self.get_dbt_object_attributes(fqn)
@@ -137,10 +157,15 @@ class DBTManager(SqlExecutionMixin):
                         default_target,
                         unset_default_target,
                         external_access_integrations,
+                        install_local_deps,
                     )
                 else:
                     return self._deploy_create(
-                        fqn, stage_name, default_target, external_access_integrations
+                        fqn,
+                        stage_name,
+                        default_target,
+                        external_access_integrations,
+                        install_local_deps,
                     )
 
     def _deploy_alter(
@@ -151,51 +176,100 @@ class DBTManager(SqlExecutionMixin):
         default_target: Optional[str],
         unset_default_target: bool,
         external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
     ) -> SnowflakeCursor:
         query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
         query += f"\nFROM {stage_name}"
-        query = self._handle_external_access_integrations_query(
-            query, external_access_integrations
-        )
         result = self.execute_query(query)
+
+        set_properties = []
+        unset_properties = []
+
         current_default_target = dbt_object_attributes.get("default_target")
         if unset_default_target and current_default_target is not None:
-            unset_query = f"ALTER DBT PROJECT {fqn} UNSET DEFAULT_TARGET"
-            self.execute_query(unset_query)
+            unset_properties.append("DEFAULT_TARGET")
         elif default_target and (
             current_default_target is None
             or current_default_target.lower() != default_target.lower()
         ):
-            set_default_query = (
-                f"ALTER DBT PROJECT {fqn} SET DEFAULT_TARGET='{default_target}'"
-            )
-            self.execute_query(set_default_query)
+            set_properties.append(f"DEFAULT_TARGET='{default_target}'")
+
+        current_external_access_integrations = dbt_object_attributes.get(
+            "external_access_integrations"
+        )
+        if self._should_update_external_access_integrations(
+            current_external_access_integrations,
+            external_access_integrations,
+            install_local_deps,
+        ):
+            if external_access_integrations:
+                integrations_str = ", ".join(sorted(external_access_integrations))
+                set_properties.append(
+                    f"EXTERNAL_ACCESS_INTEGRATIONS=({integrations_str})"
+                )
+            elif install_local_deps:
+                set_properties.append("EXTERNAL_ACCESS_INTEGRATIONS=()")
+
+        if set_properties or unset_properties:
+            self._execute_property_updates(fqn, set_properties, unset_properties)
+
         return result
 
+    @staticmethod
+    def _should_update_external_access_integrations(
+        current: Optional[List[str]],
+        requested: Optional[List[str]],
+        install_local_deps: bool,
+    ) -> bool:
+        if requested is not None:
+            current_set = set(current) if current else set()
+            requested_set = set(requested)
+            return current_set != requested_set
+        elif install_local_deps:
+            current_set = set(current) if current else set()
+            return current_set != set()
+        return False
+
+    def _execute_property_updates(
+        self, fqn: FQN, set_clauses: List[str], unset_properties: List[str]
+    ) -> None:
+        if set_clauses:
+            query = f"ALTER DBT PROJECT {fqn} SET {', '.join(set_clauses)}"
+            self.execute_query(query)
+
+        for property_name in unset_properties:
+            query = f"ALTER DBT PROJECT {fqn} UNSET {property_name}"
+            self.execute_query(query)
+
     def _deploy_create(
         self,
         fqn: FQN,
         stage_name: str,
         default_target: Optional[str],
         external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
     ) -> SnowflakeCursor:
-        # Project doesn't exist - create new one
         query = f"CREATE DBT PROJECT {fqn}"
         query += f"\nFROM {stage_name}"
         if default_target:
             query += f" DEFAULT_TARGET='{default_target}'"
         query = self._handle_external_access_integrations_query(
-            query, external_access_integrations
+            query, external_access_integrations, install_local_deps
         )
         return self.execute_query(query)
 
     @staticmethod
     def _handle_external_access_integrations_query(
-        query: str, external_access_integrations: Optional[List[str]]
+        query: str,
+        external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
     ) -> str:
+        # Providing external access integrations will trigger installation of local deps as well
         if external_access_integrations:
             integrations_str = ", ".join(external_access_integrations)
             query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ({integrations_str})"
+        elif install_local_deps:
+            query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ()"
         return query
 
     def _deploy_create_or_replace(
@@ -204,28 +278,27 @@ class DBTManager(SqlExecutionMixin):
         stage_name: str,
         default_target: Optional[str],
         external_access_integrations: Optional[List[str]],
+        install_local_deps: bool,
     ) -> SnowflakeCursor:
         query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
         query += f"\nFROM {stage_name}"
         if default_target:
             query += f" DEFAULT_TARGET='{default_target}'"
         query = self._handle_external_access_integrations_query(
-            query, external_access_integrations
+            query, external_access_integrations, install_local_deps
         )
         return self.execute_query(query)
 
-    @staticmethod
     def _validate_profiles(
+        self,
         profiles_path: SecurePath,
-        target_profile: str,
+        profile_name: str,
         default_target: str | None = None,
     ) -> None:
         """
         Validates that:
          * profiles.yml exists
          * contain profile specified in dbt_project.yml
-         * no other profiles are defined there
-         * does not contain any confidential data like passwords
          * default_target (if specified) exists in the profile's outputs
         """
         profiles_file = profiles_path / PROFILES_FILENAME
@@ -236,62 +309,60 @@ class DBTManager(SqlExecutionMixin):
         with profiles_file.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
             profiles = yaml.safe_load(fd)
 
-        if target_profile not in profiles:
+        if profile_name not in profiles:
             raise CliError(
-                f"profile {target_profile} is not defined in {PROFILES_FILENAME}"
+                f"Profile {profile_name} is not defined in {PROFILES_FILENAME}."
             )
 
         errors = defaultdict(list)
-        if len(profiles.keys()) > 1:
-            for profile_name in profiles.keys():
-                if profile_name.lower() != target_profile.lower():
-                    errors[profile_name].append("Remove unnecessary profiles")
+        profile = profiles[profile_name]
+        target_name = default_target or profile.get("target")
+        available_targets = set(profile["outputs"].keys())
+        if target_name in available_targets:
+            target = profile["outputs"][target_name]
+            target_errors = self._validate_target(target_name, target)
+            if target_errors:
+                errors[profile_name].extend(target_errors)
+        else:
+            available_targets_str = ", ".join(sorted(available_targets))
+            errors[profile_name].append(
+                f"Target '{target_name}' is not defined in profile '{profile_name}'. "
+                f"Available targets: {available_targets_str}"
+            )
+
+        if errors:
+            message = f"Found following errors in {PROFILES_FILENAME}. Please fix them before proceeding:"
+            for target, issues in errors.items():
+                message += f"\n{target}"
+                message += "\n * " + "\n * ".join(issues)
+            raise CliError(message)
 
+    def _validate_target(
+        self, target_name: str, target_details: Dict[str, str]
+    ) -> List[str]:
+        errors = []
         required_fields = {
-            "account",
             "database",
             "role",
             "schema",
             "type",
-            "user",
-            "warehouse",
         }
-        supported_fields = {
-            "threads",
-        }
-        for target_name, target in profiles[target_profile]["outputs"].items():
-            if missing_keys := required_fields - set(target.keys()):
-                errors[target_profile].append(
-                    f"Missing required fields: {', '.join(sorted(missing_keys))} in target {target_name}"
-                )
-            if (
-                unsupported_keys := set(target.keys())
-                - required_fields
-                - supported_fields
-            ):
-                errors[target_profile].append(
-                    f"Unsupported fields found: {', '.join(sorted(unsupported_keys))} in target {target_name}"
-                )
-            if "type" in target and target["type"].lower() != "snowflake":
-                errors[target_profile].append(
-                    f"Value for type field is invalid. Should be set to `snowflake` in target {target_name}"
-                )
-
-        if default_target is not None:
-            available_targets = set(profiles[target_profile]["outputs"].keys())
-            if default_target not in available_targets:
-                available_targets_str = ", ".join(sorted(available_targets))
-                errors["default_target"].append(
-                    f"Default target '{default_target}' is not defined in profile '{target_profile}'. "
-                    f"Available targets: {available_targets_str}"
-                )
+        if missing_keys := required_fields - set(target_details.keys()):
+            errors.append(
+                f"Missing required fields: {', '.join(sorted(missing_keys))} in target {target_name}"
+            )
+        if role := target_details.get("role"):
+            if not self._validate_role(role_name=role):
+                errors.append(f"Role '{role}' does not exist or is not accessible.")
+        return errors
 
-        if errors:
-            message = f"Found following errors in {PROFILES_FILENAME}. Please fix them before proceeding:"
-            for target, issues in errors.items():
-                message += f"\n{target}"
-                message += "\n * " + "\n * ".join(issues)
-            raise CliError(message)
+    def _validate_role(self, role_name: str) -> bool:
+        try:
+            with self.use_role(role_name):
+                self.execute_query("select 1")
+            return True
+        except ProgrammingError:
+            return False
 
     @staticmethod
     def _prepare_profiles_file(profiles_path: Path, tmp_path: Path):

snowflake/cli/_plugins/nativeapp/entities/application_package.py

@@ -1066,7 +1066,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
         for version in free_versions:
             last_updated = last_updated_map[version]
-            if not oldest_version or last_updated < oldest_version_last_updated_on:
+            if not oldest_version or (
+                oldest_version_last_updated_on is not None
+                and last_updated < oldest_version_last_updated_on
+            ):
                 oldest_version = version
                 oldest_version_last_updated_on = last_updated
 

snowflake/cli/_plugins/object/manager.py

@@ -137,3 +137,4 @@ def _handle_create_error_codes(err: Exception) -> None:
                 raise ClickException(f"{err_code} internal server error.")
             case _:
                 raise err
+    raise err

snowflake/cli/_plugins/spcs/services/commands.py

@@ -151,6 +151,14 @@ AutoResumeOption = OverrideableOption(
     help=_AUTO_RESUME_HELP,
 )
 
+_AUTO_SUSPEND_SECS_HELP = "Number of seconds of inactivity after which the service will be automatically suspended."
+AutoSuspendSecsOption = OverrideableOption(
+    None,
+    "--auto-suspend-secs",
+    help=_AUTO_SUSPEND_SECS_HELP,
+    min=0,
+)
+
 _COMMENT_HELP = "Comment for the service."
 
 add_object_command_aliases(
@@ -217,7 +225,7 @@ def deploy(
     upgrade: bool = typer.Option(
         False,
         "--upgrade",
-        help="Updates the existing service. Can update min_instances, max_instances, query_warehouse, auto_resume, external_access_integrations and comment.",
+        help="Updates the existing service. Can update min_instances, max_instances, query_warehouse, auto_resume, auto_suspend_secs, external_access_integrations and comment.",
     ),
     **options,
 ) -> CommandResult:
@@ -241,6 +249,7 @@ def deploy(
         min_instances=service.min_instances,
         max_instances=max_instances,
         auto_resume=service.auto_resume,
+        auto_suspend_secs=service.auto_suspend_secs,
         external_access_integrations=service.external_access_integrations,
         query_warehouse=service.query_warehouse,
         tags=service.tags,
@@ -529,6 +538,7 @@ def set_property(
     max_instances: Optional[int] = MaxInstancesOption(show_default=False),
     query_warehouse: Optional[str] = QueryWarehouseOption(show_default=False),
     auto_resume: Optional[bool] = AutoResumeOption(default=None, show_default=False),
+    auto_suspend_secs: Optional[int] = AutoSuspendSecsOption(show_default=False),
     external_access_integrations: Optional[List[str]] = typer.Option(
         None,
         "--eai-name",
@@ -546,6 +556,7 @@ def set_property(
         max_instances=max_instances,
         query_warehouse=query_warehouse,
         auto_resume=auto_resume,
+        auto_suspend_secs=auto_suspend_secs,
         external_access_integrations=external_access_integrations,
         comment=comment,
     )
@@ -576,6 +587,12 @@ def unset_property(
         help=f"Reset the AUTO_RESUME property - {_AUTO_RESUME_HELP}",
         show_default=False,
     ),
+    auto_suspend_secs: bool = AutoSuspendSecsOption(
+        default=False,
+        param_decls=["--auto-suspend-secs"],
+        help=f"Reset the AUTO_SUSPEND_SECS property - {_AUTO_SUSPEND_SECS_HELP}",
+        show_default=False,
+    ),
     comment: bool = CommentOption(
         default=False,
         help=f"Reset the COMMENT property - {_COMMENT_HELP}",
@@ -593,6 +610,7 @@ def unset_property(
         max_instances=max_instances,
         query_warehouse=query_warehouse,
         auto_resume=auto_resume,
+        auto_suspend_secs=auto_suspend_secs,
         comment=comment,
     )
     return SingleQueryResult(cursor)

snowflake/cli/_plugins/spcs/services/manager.py

@@ -114,6 +114,7 @@ class ServiceManager(SqlExecutionMixin):
         min_instances: int,
         max_instances: int,
         auto_resume: bool,
+        auto_suspend_secs: Optional[int],
         external_access_integrations: Optional[List[str]],
         query_warehouse: Optional[str],
         tags: Optional[List[Tag]],
@@ -139,6 +140,7 @@ class ServiceManager(SqlExecutionMixin):
                 max_instances=max_instances,
                 query_warehouse=query_warehouse,
                 auto_resume=auto_resume,
+                auto_suspend_secs=auto_suspend_secs,
                 external_access_integrations=external_access_integrations,
                 comment=comment,
             )
@@ -163,6 +165,9 @@ class ServiceManager(SqlExecutionMixin):
             if max_instances:
                 query.append(f"MAX_INSTANCES = {max_instances}")
 
+            if auto_suspend_secs is not None:
+                query.append(f"AUTO_SUSPEND_SECS = {auto_suspend_secs}")
+
             if query_warehouse:
                 query.append(f"QUERY_WAREHOUSE = {query_warehouse}")
 
@@ -532,6 +537,7 @@ class ServiceManager(SqlExecutionMixin):
         max_instances: Optional[int],
         query_warehouse: Optional[str],
         auto_resume: Optional[bool],
+        auto_suspend_secs: Optional[int],
         external_access_integrations: Optional[List[str]],
         comment: Optional[str],
     ):
@@ -540,6 +546,7 @@ class ServiceManager(SqlExecutionMixin):
             ("max_instances", max_instances),
             ("query_warehouse", query_warehouse),
             ("auto_resume", auto_resume),
+            ("auto_suspend_secs", auto_suspend_secs),
             ("external_access_integrations", external_access_integrations),
             ("comment", comment),
         ]
@@ -563,6 +570,9 @@ class ServiceManager(SqlExecutionMixin):
         if auto_resume is not None:
             query.append(f" auto_resume = {auto_resume}")
 
+        if auto_suspend_secs is not None:
+            query.append(f" auto_suspend_secs = {auto_suspend_secs}")
+
         if external_access_integrations is not None:
             external_access_integration_list = ",".join(
                 f"{e}" for e in external_access_integrations
@@ -583,6 +593,7 @@ class ServiceManager(SqlExecutionMixin):
         max_instances: bool,
         query_warehouse: bool,
         auto_resume: bool,
+        auto_suspend_secs: bool,
         comment: bool,
     ):
         property_pairs = [
@@ -590,6 +601,7 @@ class ServiceManager(SqlExecutionMixin):
             ("max_instances", max_instances),
             ("query_warehouse", query_warehouse),
             ("auto_resume", auto_resume),
+            ("auto_suspend_secs", auto_suspend_secs),
             ("comment", comment),
         ]
 

snowflake/cli/_plugins/spcs/services/service_entity_model.py

@@ -30,6 +30,11 @@ class ServiceEntityModel(EntityModelBaseWithArtifacts, ExternalAccessBaseModel):
         title="The service will automatically resume when a service function or ingress is called.",
         default=True,
     )
+    auto_suspend_secs: Optional[int] = Field(
+        title="Number of seconds of inactivity after which the service is automatically suspended.",
+        default=None,
+        ge=0,
+    )
     query_warehouse: Optional[str] = Field(
         title="Warehouse to use if a service container connects to Snowflake to execute a query without explicitly specifying a warehouse to use",
         default=None,

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -6,7 +6,9 @@ from click import ClickException
 from snowflake.cli._plugins.connection.util import make_snowsight_url
 from snowflake.cli._plugins.nativeapp.artifacts import build_bundle
 from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli._plugins.streamlit.manager import StreamlitManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    SPCS_RUNTIME_V2_NAME,
     StreamlitEntityModel,
 )
 from snowflake.cli._plugins.workspace.context import ActionContext
@@ -64,6 +66,14 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self._conn, f"/#/streamlit-apps/{name.url_identifier}"
         )
 
+    def _is_spcs_runtime_v2_mode(self, experimental: bool = False) -> bool:
+        """Check if SPCS runtime v2 mode is enabled."""
+        return (
+            experimental
+            and self.model.runtime_name == SPCS_RUNTIME_V2_NAME
+            and self.model.compute_pool
+        )
+
     def bundle(self, output_dir: Optional[Path] = None) -> BundleMap:
         return build_bundle(
             self.root,
@@ -83,7 +93,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         replace: bool,
         prune: bool = False,
         bundle_map: Optional[BundleMap] = None,
-        experimental: Optional[bool] = False,
+        experimental: bool = False,
         *args,
         **kwargs,
     ):
@@ -129,9 +139,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             console.step(f"Creating Streamlit object {self.model.fqn.sql_identifier}")
 
             self._execute_query(
-                self.get_deploy_sql(replace=replace, from_stage_name=stage_root)
+                self.get_deploy_sql(
+                    replace=replace,
+                    from_stage_name=stage_root,
+                    experimental=False,
+                )
             )
 
+            StreamlitManager(connection=self._conn).grant_privileges(self.model)
+
         return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
 
     def describe(self) -> SnowflakeCursor:
@@ -156,6 +172,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         artifacts_dir: Optional[Path] = None,
         schema: Optional[str] = None,
         database: Optional[str] = None,
+        experimental: bool = False,
         *args,
         **kwargs,
     ) -> str:
@@ -199,6 +216,12 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         if self.model.secrets:
             query += "\n" + self.model.get_secrets_sql()
 
+        # SPCS runtime fields are only supported for FBE/versioned streamlits (FROM syntax)
+        # Never add these fields for stage-based deployments (ROOT_LOCATION syntax)
+        if not from_stage_name and self._is_spcs_runtime_v2_mode(experimental):
+            query += f"\nRUNTIME_NAME = '{self.model.runtime_name}'"
+            query += f"\nCOMPUTE_POOL = '{self.model.compute_pool}'"
+
         return query + ";"
 
     def get_describe_sql(self) -> str:
@@ -233,6 +256,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             self.get_deploy_sql(
                 if_not_exists=True,
                 replace=replace,
+                experimental=True,
             )
         )
         try:
@@ -256,3 +280,5 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             print_diff=True,
             force_overwrite=True,  # files copied to streamlit vstage need to be overwritten
         )
+
+        StreamlitManager(connection=self._conn).grant_privileges(self.model)

snowflake/cli/_plugins/streamlit/streamlit_entity_model.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from typing import Literal, Optional
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from snowflake.cli.api.project.schemas.entities.common import (
     Artifacts,
     EntityModelBaseWithArtifacts,
@@ -23,9 +23,10 @@ from snowflake.cli.api.project.schemas.entities.common import (
     GrantBaseModel,
     ImportsBaseModel,
 )
-from snowflake.cli.api.project.schemas.updatable_model import (
-    DiscriminatorField,
-)
+from snowflake.cli.api.project.schemas.updatable_model import DiscriminatorField
+
+# SPCS Runtime v2 constants
+SPCS_RUNTIME_V2_NAME = "SYSTEM$ST_CONTAINER_RUNTIME_PY3_11"
 
 
 class StreamlitEntityModel(
@@ -54,3 +55,22 @@ class StreamlitEntityModel(
         title="List of paths or file source/destination pairs to add to the deploy root",
         default=None,
     )
+    runtime_name: Optional[str] = Field(
+        title="The runtime name to run the streamlit app on", default=None
+    )
+    compute_pool: Optional[str] = Field(
+        title="The compute pool name of the snowservices running the streamlit app",
+        default=None,
+    )
+
+    @model_validator(mode="after")
+    def validate_spcs_runtime_fields(self):
+        """Validate that runtime_name and compute_pool are provided together for SPCS container runtime."""
+        # Only validate for SPCS container runtime, not warehouse runtime
+        if self.compute_pool and not self.runtime_name:
+            raise ValueError("compute_pool is specified without runtime_name")
+        if self.runtime_name == SPCS_RUNTIME_V2_NAME and not self.compute_pool:
+            raise ValueError(
+                f"compute_pool is required when using {SPCS_RUNTIME_V2_NAME}"
+            )
+        return self

snowflake/cli/api/commands/decorators.py

@@ -27,6 +27,7 @@ from snowflake.cli.api.commands.flags import (
     ConnectionOption,
     DatabaseOption,
     DebugOption,
+    DecimalPrecisionOption,
     DiagAllowlistPathOption,
     DiagLogPathOption,
     EnableDiagOption,
@@ -446,6 +447,12 @@ GLOBAL_OPTIONS = [
         annotation=Optional[bool],
         default=EnhancedExitCodesOption,
     ),
+    inspect.Parameter(
+        "decimal_precision",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[int],
+        default=DecimalPrecisionOption,
+    ),
 ]