snowflake-cli 3.2.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

snowflake/cli/api/cli_global_context.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
+from functools import wraps
 from pathlib import Path
 from typing import TYPE_CHECKING, Iterator
 
@@ -157,7 +158,7 @@ class _CliGlobalContextAccess:
         return self._manager.enable_tracebacks
 
     @property
-    def metrics(self):
+    def metrics(self) -> CLIMetrics:
         return self._manager.metrics
 
     @property
@@ -213,6 +214,26 @@ def get_cli_context() -> _CliGlobalContextAccess:
     return _CliGlobalContextAccess(get_cli_context_manager())
 
 
+def span(span_name: str):
+    """
+    Decorator to start a command metrics span that encompasses a whole function
+
+    Must be used instead of directly calling @get_cli_context().metrics.span(span_name)
+    as a decorator to ensure that the cli context is grabbed at run time instead of at
+    module load time, which would not reflect forking
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            with get_cli_context().metrics.span(span_name):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 @contextmanager
 def fork_cli_context(
     connection_overrides: dict | None = None,

snowflake/cli/api/config.py

@@ -286,8 +286,12 @@ def get_config_value(*path, key: str, default: Optional[Any] = Empty) -> Any:
         raise
 
 
-def get_config_bool_value(*path, key: str, default: Optional[Any] = Empty) -> bool:
-    value = get_config_value(*path, key=key, default=default)
+def get_config_bool_value(*path, key: str, default: Optional[bool]) -> Optional[bool]:
+    value = get_config_value(*path, key=key, default=None)
+
+    if value is None:
+        return default
+
     try:
         return try_cast_to_bool(value)
     except ValueError:

snowflake/cli/api/connections.py

@@ -79,6 +79,17 @@ class ConnectionContext:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
             setattr(self, key, value)
 
+    def merge_with_config(self, **updates) -> ConnectionContext:
+        """
+        Updates missing fields from the config, but does not overwrite existing.
+        """
+        field_map = {field.name for field in fields(self)}
+        for key, value in updates.items():
+            if key in field_map and getattr(self, key) is None:
+                setattr(self, key, value)
+
+        return self
+
     def update_from_config(self) -> ConnectionContext:
         connection_config = get_connection_dict(connection_name=self.connection_name)
         if "private_key_path" in connection_config:
@@ -87,7 +98,7 @@ class ConnectionContext:
             ]
             del connection_config["private_key_path"]
 
-        self.update(**connection_config)
+        self.merge_with_config(**connection_config)
         return self
 
     def __repr__(self) -> str:

snowflake/cli/api/constants.py

@@ -62,6 +62,10 @@ class ObjectType(Enum):
         "image-repository", "image repository", "image repositories"
     )
     GIT_REPOSITORY = ObjectNames("git-repository", "git repository", "git repositories")
+    APPLICATION = ObjectNames("application", "application", "applications")
+    APPLICATION_PACKAGE = ObjectNames(
+        "application-package", "application package", "application packages"
+    )
 
     def __str__(self):
         """This makes using this Enum easier in formatted string"""
@@ -69,7 +73,11 @@ class ObjectType(Enum):
 
 
 OBJECT_TO_NAMES = {o.value.cli_name: o.value for o in ObjectType}
-SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys())
+UNSUPPORTED_OBJECTS = {
+    ObjectType.APPLICATION.value.cli_name,
+    ObjectType.APPLICATION_PACKAGE.value.cli_name,
+}
+SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys() - UNSUPPORTED_OBJECTS)
 
 # Scope names here must replace spaces with '-'. For example 'compute pool' is 'compute-pool'.
 VALID_SCOPES = ["database", "schema", "compute-pool"]

snowflake/cli/api/entities/common.py

@@ -1,8 +1,14 @@
+import functools
 from enum import Enum
+from pathlib import Path
 from typing import Generic, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
+from snowflake.cli.api.cli_global_context import span
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutor
+from snowflake.connector import SnowflakeConnection
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class EntityActions(str, Enum):
@@ -16,10 +22,47 @@ class EntityActions(str, Enum):
     VERSION_CREATE = "action_version_create"
     VERSION_DROP = "action_version_drop"
 
+    RELEASE_DIRECTIVE_UNSET = "action_release_directive_unset"
+    RELEASE_DIRECTIVE_SET = "action_release_directive_set"
+    RELEASE_DIRECTIVE_LIST = "action_release_directive_list"
+
+    RELEASE_CHANNEL_LIST = "action_release_channel_list"
+    RELEASE_CHANNEL_ADD_ACCOUNTS = "action_release_channel_add_accounts"
+    RELEASE_CHANNEL_REMOVE_ACCOUNTS = "action_release_channel_remove_accounts"
+    RELEASE_CHANNEL_ADD_VERSION = "action_release_channel_add_version"
+    RELEASE_CHANNEL_REMOVE_VERSION = "action_release_channel_remove_version"
+
+    PUBLISH = "action_publish"
+
 
 T = TypeVar("T")
 
 
+def attach_spans_to_entity_actions(entity_name: str):
+    """
+    Class decorator for EntityBase subclasses to automatically wrap
+    every implemented entity action method with a metrics span
+
+    Args:
+        entity_name (str): Custom name for entity type to be displayed in metrics
+    """
+
+    def decorator(cls: type[T]) -> type[T]:
+        for attr_name, attr_value in vars(cls).items():
+            is_entity_action = attr_name in [
+                enum_member for enum_member in EntityActions
+            ]
+
+            if is_entity_action and callable(attr_value):
+                attr_name_without_action_prefix = attr_name.partition("_")[2]
+                span_name = f"action.{entity_name}.{attr_name_without_action_prefix}"
+                action_with_span = span(span_name)(attr_value)
+                setattr(cls, attr_name, action_with_span)
+        return cls
+
+    return decorator
+
+
 class EntityBase(Generic[T]):
     """
     Base class for the fully-featured entity classes.
@@ -29,6 +72,10 @@ class EntityBase(Generic[T]):
         self._entity_model = entity_model
         self._workspace_ctx = workspace_ctx
 
+    @property
+    def entity_id(self) -> str:
+        return self._entity_model.entity_id  # type: ignore
+
     @classmethod
     def get_entity_model_type(cls) -> Type[T]:
         """
@@ -52,6 +99,44 @@ class EntityBase(Generic[T]):
         """
         return getattr(self, action)(action_ctx, *args, **kwargs)
 
+    @property
+    def root(self) -> Path:
+        return self._workspace_ctx.project_root
+
+    @property
+    def identifier(self) -> str:
+        return self.model.fqn.sql_identifier
+
+    @property
+    def fqn(self) -> FQN:
+        return self._entity_model.fqn  # type: ignore[attr-defined]
+
+    @functools.cached_property
+    def _sql_executor(
+        self,
+    ) -> SqlExecutor:
+        return get_sql_executor()
+
+    def _execute_query(self, sql: str) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(sql)
+
+    @functools.cached_property
+    def _conn(self) -> SnowflakeConnection:
+        return self._sql_executor._conn  # noqa
+
+    @property
+    def model(self):
+        return self._entity_model
+
+    def get_usage_grant_sql(self, app_role: str) -> str:
+        return f"GRANT USAGE ON {self.model.type.upper()} {self.identifier} TO ROLE {app_role};"
+
+    def get_describe_sql(self) -> str:
+        return f"DESCRIBE {self.model.type.upper()} {self.identifier};"
+
+    def get_drop_sql(self) -> str:
+        return f"DROP {self.model.type.upper()} {self.identifier};"
+
 
 def get_sql_executor() -> SqlExecutor:
     """Returns an SQL Executor that uses the connection from the current CLI context"""

snowflake/cli/api/entities/utils.py

@@ -23,7 +23,7 @@ from snowflake.cli._plugins.stage.diff import (
     to_stage_path,
 )
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
-from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.errno import (
@@ -42,7 +42,6 @@ from snowflake.cli.api.rendering.sql_templates import (
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
 
 
 def generic_sql_error_handler(err: ProgrammingError) -> NoReturn:
@@ -76,6 +75,7 @@ def _get_stage_paths_to_sync(
     return stage_paths
 
 
+@span("sync_deploy_root_with_stage")
 def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
@@ -212,7 +212,10 @@ def execute_post_deploy_hooks(
 
     get_cli_context().metrics.set_counter(CLICounterField.POST_DEPLOY_SCRIPTS, 1)
 
-    with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
+    with (
+        console.phase(f"Executing {deployed_object_type} post-deploy actions"),
+        get_cli_context().metrics.span("post_deploy_hooks"),
+    ):
         sql_scripts_paths = []
         display_paths = []
         for hook in post_deploy_hooks:
@@ -321,17 +324,15 @@ def drop_generic_object(
         console.message(f"Dropped {object_type} {object_name} successfully.")
 
 
-def print_messages(
-    console: AbstractConsole, create_or_upgrade_cursor: Optional[SnowflakeCursor]
-):
+def print_messages(console: AbstractConsole, cursor_results: list[tuple[str]]):
     """
     Shows messages in the console returned by the CREATE or UPGRADE
     APPLICATION command.
     """
-    if not create_or_upgrade_cursor:
+    if not cursor_results:
         return
 
-    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
+    messages = [row[0] for row in cursor_results]
     for message in messages:
         console.warning(message)
     console.message("")

snowflake/cli/api/errno.py

@@ -14,17 +14,74 @@
 
 # General errors
 NO_WAREHOUSE_SELECTED_IN_SESSION = 606
+EMPTY_SQL_STATEMENT = 900
 
-DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003
-DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = 2043
-INSUFFICIENT_PRIVILEGES = 3001
+SQL_COMPILATION_ERROR = 1003
+OBJECT_ALREADY_EXISTS_IN_DOMAIN = 1998
+OBJECT_ALREADY_EXISTS = 2002
+DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003  # BASE_TABLE_OR_VIEW_NOT_FOUND
+DUPLICATE_COLUMN_NAME = 2025
+VIEW_EXPANSION_FAILED = 2037
+DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = (
+    2043  # OBJECT_DOES_NOT_EXIST_OR_CANNOT_PERFORM_OPERATION
+)
+INSUFFICIENT_PRIVILEGES = 3001  # NOT_AUTHORIZED
+INVALID_OBJECT_TYPE_FOR_SPECIFIED_PRIVILEGE = 3008
+ROLE_NOT_ASSIGNED = 3013
+NO_INDIVIDUAL_PRIVS = 3028
+OBJECT_ALREADY_EXISTS_NO_PRIVILEGES = 3041
 
 # Native Apps
+APPLICATION_PACKAGE_MANIFEST_SPECIFIED_FILE_NOT_FOUND = 93003
+APPLICATION_FILE_NOT_FOUND_ON_STAGE = 93009
+CANNOT_GRANT_OBJECT_NOT_IN_APP_PACKAGE = 93011
+CANNOT_GRANT_RESTRICTED_PRIVILEGE_TO_APP_PACKAGE_SHARE = 93012
+APPLICATION_PACKAGE_VERSION_ALREADY_EXISTS = 93030
+APPLICATION_PACKAGE_VERSION_NAME_TOO_LONG = 93035
+APPLICATION_PACKAGE_PATCH_DOES_NOT_EXIST = 93036
+APPLICATION_PACKAGE_MAX_VERSIONS_HIT = 93037
 CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION = 93044
 CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES = 93045
 ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93046
+NO_VERSIONS_AVAILABLE_FOR_ACCOUNT = 93054
 NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93055
 APPLICATION_NO_LONGER_AVAILABLE = 93079
+APPLICATION_INSTANCE_FAILED_TO_RUN_SETUP_SCRIPT = 93082
+APPLICATION_INSTANCE_NO_ACTIVE_WAREHOUSE_FOR_CREATE_OR_UPGRADE = 93083
+APPLICATION_INSTANCE_EMPTY_SETUP_SCRIPT = 93084
+VERSION_REFERENCED_BY_RELEASE_DIRECTIVE = 93088
+APPLICATION_PACKAGE_MANIFEST_CONTAINER_IMAGE_URL_BAD_VALUE = 93148
+CANNOT_GRANT_NON_MANIFEST_PRIVILEGE = 93118
 APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128
+APPLICATION_PACKAGE_PATCH_ALREADY_EXISTS = 93168
+APPLICATION_PACKAGE_CANNOT_SET_EXTERNAL_DISTRIBUTION_WITH_SPCS = 93197
+NATIVE_APPLICATION_MANIFEST_UNRECOGNIZED_FIELD = 93301
+NATIVE_APPLICATION_MANIFEST_UNEXPECTED_VALUE_FOR_PROPERTY = 93302
+NATIVE_APPLICATION_MANIFEST_GENERIC_JSON_ERROR = 93303
+NATIVE_APPLICATION_MANIFEST_INVALID_SYNTAX = 93300
 APPLICATION_REQUIRES_TELEMETRY_SHARING = 93321
 CANNOT_DISABLE_MANDATORY_TELEMETRY = 93329
+VERSION_NOT_ADDED_TO_RELEASE_CHANNEL = 512008
+CANNOT_DISABLE_RELEASE_CHANNELS = 512001
+RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND = 93036
+RELEASE_DIRECTIVE_DOES_NOT_EXIST = 93090
+VERSION_DOES_NOT_EXIST = 93031
+VERSION_NOT_IN_RELEASE_CHANNEL = 512010
+ACCOUNT_DOES_NOT_EXIST = 1999
+ACCOUNT_HAS_TOO_MANY_QUALIFIERS = 906
+CANNOT_MODIFY_RELEASE_CHANNEL_ACCOUNTS = 512017
+VERSION_ALREADY_ADDED_TO_RELEASE_CHANNEL = 512005
+MAX_VERSIONS_IN_RELEASE_CHANNEL_REACHED = 512004
+MAX_UNBOUND_VERSIONS_REACHED = 512023
+CANNOT_DEREGISTER_VERSION_ASSOCIATED_WITH_CHANNEL = 512021
+TARGET_ACCOUNT_USED_BY_OTHER_RELEASE_DIRECTIVE = 93091
+
+
+ERR_JAVASCRIPT_EXECUTION = 100132
+
+SNOWSERVICES_IMAGE_REPOSITORY_IMAGE_IMPORT_TO_NATIVE_APP_FAIL = 397007
+SNOWSERVICES_IMAGE_MANIFEST_NOT_FOUND = 397012
+SNOWSERVICES_IMAGE_REPOSITORY_FAILS_TO_RETRIEVE_IMAGE_HASH_NEW = 397013
+
+NO_REFERENCE_SET_FOR_DEFINITION = 505019
+NO_ACTIVE_REF_DEFINITION_WITH_REF_NAME_IN_APPLICATION = 505026

snowflake/cli/api/feature_flags.py

@@ -24,20 +24,31 @@ from snowflake.cli.api.config import (
 
 class BooleanFlag(NamedTuple):
     name: str
-    default: bool = False
+    default: bool | None = False
 
 
 @unique
 class FeatureFlagMixin(Enum):
-    def is_enabled(self) -> bool:
+    def get_value(self) -> bool | None:
         return get_config_bool_value(
             *FEATURE_FLAGS_SECTION_PATH,
             key=self.value.name.lower(),
             default=self.value.default,
         )
 
-    def is_disabled(self):
-        return not self.is_enabled()
+    def is_enabled(self) -> bool:
+        return self.get_value() is True
+
+    def is_disabled(self) -> bool:
+        return self.get_value() is False
+
+    def is_set(self) -> bool:
+        return (
+            get_config_bool_value(
+                *FEATURE_FLAGS_SECTION_PATH, key=self.value.name.lower(), default=None
+            )
+            is not None
+        )
 
     def env_variable(self):
         return get_env_variable_name(*FEATURE_FLAGS_SECTION_PATH, key=self.value.name)
@@ -52,3 +63,8 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_VERSIONED_STAGE", False
     )
+    ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID = BooleanFlag(
+        "ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID", False
+    )
+    ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
+    ENABLE_SPCS_SERVICE_METRICS = BooleanFlag("ENABLE_SPCS_SERVICE_METRICS", False)

snowflake/cli/api/metrics.py

@@ -116,10 +116,8 @@ class CLIMetricsSpan:
     children: Set[CLIMetricsSpan] = field(init=False, default_factory=set)
 
     # private state
-    # start time of the step from the monotonic clock in order to calculate execution time
-    _monotonic_start: float = field(
-        init=False, default_factory=lambda: time.monotonic()
-    )
+    # start time of the step from a performance counter in order to calculate execution time
+    _start_time: float = field(init=False, default_factory=time.perf_counter)
 
     def __hash__(self) -> int:
         return hash(self.span_id)
@@ -154,7 +152,7 @@ class CLIMetricsSpan:
         if error:
             self.error = error
 
-        self.execution_time = time.monotonic() - self._monotonic_start
+        self.execution_time = time.perf_counter() - self._start_time
 
     def to_dict(self) -> Dict:
         """
@@ -191,9 +189,10 @@ class CLIMetrics:
     _in_progress_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
     # list of finished steps for telemetry to process
     _completed_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
-    # monotonic clock time of when this class was initialized to approximate when the command first started executing
-    _monotonic_start: float = field(
-        init=False, default_factory=lambda: time.monotonic(), compare=False
+    # clock time of a performance counter when this class was initialized
+    # to approximate when the command first started executing
+    _start_time: float = field(
+        init=False, default_factory=time.perf_counter, compare=False
     )
 
     def clone(self) -> CLIMetrics:
@@ -223,7 +222,7 @@ class CLIMetrics:
         return self._in_progress_spans[-1] if len(self._in_progress_spans) > 0 else None
 
     @contextmanager
-    def start_span(self, name: str) -> Iterator[CLIMetricsSpan]:
+    def span(self, name: str) -> Iterator[CLIMetricsSpan]:
         """
         Starts a new span that tracks various metrics throughout its execution
 
@@ -236,7 +235,7 @@ class CLIMetrics:
         """
         new_span = CLIMetricsSpan(
             name=name,
-            start_time=time.monotonic() - self._monotonic_start,
+            start_time=time.perf_counter() - self._start_time,
             parent=self.current_span,
         )
 
@@ -275,34 +274,29 @@ class CLIMetrics:
     @property
     def completed_spans(self) -> List[Dict]:
         """
-        Returns the completed spans tracked throughout a command, sorted by start time, for reporting telemetry
+        Returns the completed spans tracked throughout a command for reporting telemetry
 
         Ensures that the spans we send are within the configured limits and marks
         certain spans as trimmed if their children would bypass the limits we set
         """
         # take spans breadth-first within the depth and total limits
         # since we care more about the big picture than granularity
-        spans_to_report = set(
-            nsmallest(
-                n=self.SPAN_TOTAL_LIMIT,
-                iterable=(
-                    span
-                    for span in self._completed_spans
-                    if span.span_depth <= self.SPAN_DEPTH_LIMIT
-                ),
-                key=lambda span: (span.span_depth, span.start_time),
-            )
+        spans_to_report = nsmallest(
+            n=self.SPAN_TOTAL_LIMIT,
+            iterable=(
+                span
+                for span in self._completed_spans
+                if span.span_depth <= self.SPAN_DEPTH_LIMIT
+            ),
+            key=lambda span: (span.span_depth, span.start_time, span.execution_time),
         )
 
-        # sort by start time to make reading the payload easier
-        sorted_spans_to_report = sorted(
-            spans_to_report, key=lambda span: span.start_time
-        )
+        spans_to_report_set = set(spans_to_report)
 
         return [
             {
                 **span.to_dict(),
-                CLIMetricsSpan.TRIMMED_KEY: not span.children <= spans_to_report,
+                CLIMetricsSpan.TRIMMED_KEY: not span.children <= spans_to_report_set,
             }
-            for span in sorted_spans_to_report
+            for span in spans_to_report
         ]

snowflake/cli/api/project/definition_conversion.py

@@ -13,7 +13,6 @@ from snowflake.cli._plugins.nativeapp.artifacts import (
     bundle_artifacts,
 )
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
-from snowflake.cli._plugins.nativeapp.codegen.compiler import TEMPLATES_PROCESSOR
 from snowflake.cli._plugins.nativeapp.codegen.templates.templates_processor import (
     TemplatesProcessor,
 )
@@ -457,7 +456,7 @@ def _convert_templates_in_files(
             artifact
             for artifact in pkg_model.artifacts
             for processor in artifact.processors
-            if processor.name == TEMPLATES_PROCESSOR
+            if processor.name.lower() == TemplatesProcessor.NAME
         ]
         if not in_memory and artifacts_to_template:
             metrics.set_counter(CLICounterField.TEMPLATES_PROCESSOR, 1)

snowflake/cli/api/project/schemas/project_definition.py

@@ -15,12 +15,17 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from types import UnionType
+from typing import Any, Dict, List, Optional, Union, get_args, get_origin
 
 from packaging.version import Version
 from pydantic import Field, ValidationError, field_validator, model_validator
 from pydantic_core.core_schema import ValidationInfo
 from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageChildrenTypes,
+    ApplicationPackageEntityModel,
+)
 from snowflake.cli.api.project.errors import SchemaValidationError
 from snowflake.cli.api.project.schemas.entities.common import (
     TargetField,
@@ -159,6 +164,12 @@ class DefinitionV20(_ProjectDefinitionBase):
                 target_object = entity.from_
                 target_type = target_object.get_type()
                 cls._validate_target_field(target_key, target_type, entities)
+        elif entity.type == ApplicationPackageEntityModel.get_type():
+            for child_entity in entity.children:
+                target_key = child_entity.target
+                cls._validate_target_field(
+                    target_key, ApplicationPackageChildrenTypes, entities
+                )
 
     @classmethod
     def _validate_target_field(
@@ -168,11 +179,20 @@ class DefinitionV20(_ProjectDefinitionBase):
             raise ValueError(f"No such target: {target_key}")
 
         # Validate the target type
-        actual_target_type = entities[target_key].__class__
-        if target_type and target_type is not actual_target_type:
-            raise ValueError(
-                f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
-            )
+        if target_type:
+            actual_target_type = entities[target_key].__class__
+            if get_origin(target_type) in (Union, UnionType):
+                if actual_target_type not in get_args(target_type):
+                    expected_types_str = ", ".join(
+                        [t.__name__ for t in get_args(target_type)]
+                    )
+                    raise ValueError(
+                        f"Target type mismatch. Expected one of [{expected_types_str}], got {actual_target_type.__name__}"
+                    )
+            elif target_type is not actual_target_type:
+                raise ValueError(
+                    f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
+                )
 
     @model_validator(mode="before")
     @classmethod
@@ -200,6 +220,7 @@ class DefinitionV20(_ProjectDefinitionBase):
                     mixin_defs=data["mixins"],
                 )
                 entities[entity_name] = merged_values
+
         return data
 
     @classmethod

snowflake/cli/api/project/schemas/v1/streamlit/streamlit.py

@@ -27,7 +27,7 @@ class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):
         title="Stage in which the app’s artifacts will be stored", default="streamlit"
     )
     query_warehouse: str = Field(
-        title="Snowflake warehouse to host the app", default="streamlit"
+        title="Snowflake warehouse to host the app", default=None
     )
     main_file: Optional[Path] = Field(
         title="Entrypoint file of the Streamlit app", default="streamlit_app.py"

snowflake/cli/api/project/util.py

@@ -148,6 +148,10 @@ def unquote_identifier(identifier: str) -> str:
     string for a LIKE clause, or to match an identifier passed back as
     a value from a SQL statement.
     """
+    # ensure input is a valid identifier - otherwise, it could accidentally uppercase
+    # a quoted identifier
+    identifier = to_identifier(identifier)
+
     if match := re.fullmatch(QUOTED_IDENTIFIER_REGEX, identifier):
         return match.group(1).replace('""', '"')
     # unquoted identifiers are internally represented as uppercase
@@ -276,3 +280,44 @@ def append_test_resource_suffix(identifier: str) -> str:
     # Otherwise just append the string, don't add quotes
     # in case the user doesn't want them
     return f"{identifier}{suffix}"
+
+
+def same_identifiers(id1: str, id2: str) -> bool:
+    """
+    Returns whether two identifiers refer to the same object.
+
+    Two unquoted identifiers are considered the same if they are equal when both are converted to uppercase
+    Two quoted identifiers are considered the same if they are exactly equal
+    An unquoted identifier and a quoted identifier are considered the same
+      if the quoted identifier is equal to the uppercase version of the unquoted identifier
+    """
+    # Canonicalize the identifiers by converting unquoted identifiers to uppercase and leaving quoted identifiers as is
+    canonical_id1 = id1.upper() if is_valid_unquoted_identifier(id1) else id1
+    canonical_id2 = id2.upper() if is_valid_unquoted_identifier(id2) else id2
+
+    # The canonical identifiers are equal if they are equal when both are quoted
+    # (if they are already quoted, this is a no-op)
+    return to_quoted_identifier(canonical_id1) == to_quoted_identifier(canonical_id2)
+
+
+def sql_match(*, pattern: str, value: str) -> bool:
+    """
+    Returns whether the value matches the pattern when used with LIKE in Snowflake.
+    Compares the 2 input and ignores the case.
+    """
+    value = unquote_identifier(value)
+    return (
+        re.fullmatch(
+            pattern.replace(r"%", ".*").replace(r"_", "."), value, re.IGNORECASE
+        )
+        is not None
+    )
+
+
+def identifier_in_list(identifier: str, identifier_list: list[str]) -> bool:
+    """
+    Returns whether the identifier is in the list of identifiers.
+    """
+    return any(
+        same_identifiers(identifier, id_from_list) for id_from_list in identifier_list
+    )