snowflake-cli 3.9.1__py3-none-any.whl → 3.10.1__py3-none-any.whl

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -18,7 +18,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.project_paths import bundle_root
 from snowflake.cli.api.project.schemas.entities.common import Identifier, PathMapping
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 log = logging.getLogger(__name__)
 
@@ -102,7 +102,6 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         if (
             experimental
             or GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
-            or GlobalFeatureFlag.ENABLE_STREAMLIT_EMBEDDED_STAGE.is_enabled()
         ):
             self._deploy_experimental(bundle_map=bundle_map, replace=replace)
         else:
@@ -123,7 +122,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
                 bundle_map=bundle_map,
                 prune=prune,
                 recursive=True,
-                stage_path=StageManager().stage_path_parts_from_str(stage_root),
+                stage_path_parts=StageManager().stage_path_parts_from_str(stage_root),
                 print_diff=True,
             )
 
@@ -136,7 +135,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         return self.perform(EntityActions.GET_URL, action_context, *args, **kwargs)
 
     def describe(self) -> SnowflakeCursor:
-        return self._execute_query(self.get_describe_sql())
+        return self._execute_query(self.get_describe_sql(), cursor_class=DictCursor)
 
     def action_share(
         self, action_ctx: ActionContext, to_role: str, *args, **kwargs
@@ -146,13 +145,9 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     def get_add_live_version_sql(
         self, schema: Optional[str] = None, database: Optional[str] = None
     ):
+        # this query unlike most others doesn't accept fqn wrapped in `IDENTIFIER('')`
         return f"ALTER STREAMLIT {self._get_identifier(schema,database)} ADD LIVE VERSION FROM LAST;"
 
-    def get_checkout_sql(
-        self, schema: Optional[str] = None, database: Optional[str] = None
-    ):
-        return f"ALTER STREAMLIT {self._get_identifier(schema,database)} CHECKOUT;"
-
     def get_deploy_sql(
         self,
         if_not_exists: bool = False,
@@ -172,7 +167,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         else:
             query = "CREATE STREAMLIT"
 
-        query += f" {self._get_identifier(schema, database)}"
+        query += f" {self._get_sql_identifier(schema, database)}"
 
         if from_stage_name:
             query += f"\nROOT_LOCATION = '{from_stage_name}'"
@@ -207,13 +202,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         return query + ";"
 
     def get_describe_sql(self) -> str:
-        return f"DESCRIBE STREAMLIT {self._get_identifier()};"
+        return f"DESCRIBE STREAMLIT {self._get_sql_identifier()};"
 
     def get_share_sql(self, to_role: str) -> str:
-        return f"GRANT USAGE ON STREAMLIT {self._get_identifier()} TO ROLE {to_role};"
+        return (
+            f"GRANT USAGE ON STREAMLIT {self._get_sql_identifier()} TO ROLE {to_role};"
+        )
 
     def get_execute_sql(self):
-        return f"EXECUTE STREAMLIT {self._get_identifier()}();"
+        return f"EXECUTE STREAMLIT {self._get_sql_identifier()}();"
 
     def get_usage_grant_sql(self, app_role: str, schema: Optional[str] = None) -> str:
         entity_id = self.entity_id
@@ -239,26 +236,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             )
         )
         try:
-            if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
-                self._execute_query(self.get_add_live_version_sql())
-            elif not GlobalFeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
-                self._execute_query(self.get_checkout_sql())
+            self._execute_query(self.get_add_live_version_sql())
         except ProgrammingError as e:
-            if "Checkout already exists" in str(
-                e
-            ) or "There is already a live version" in str(e):
-                log.info("Checkout already exists, continuing")
+            if "There is already a live version" in str(e):
+                log.info("Live version already exists, continuing")
             else:
                 raise
 
-        embeded_stage_name = (
-            f"snow://streamlit/{self.model.fqn.using_connection(self._conn).identifier}"
-        )
-
-        if GlobalFeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled():
-            stage_root = f"{embeded_stage_name}/versions/live"
-        else:
-            stage_root = f"{embeded_stage_name}/default_checkout"
+        stage_root = self.describe().fetchone()["live_version_location_uri"]
+        stage_path_parts = StageManager().stage_path_parts_from_str(stage_root)
 
         sync_deploy_root_with_stage(
             console=self._workspace_ctx.console,
@@ -266,6 +252,7 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
             bundle_map=bundle_map,
             prune=prune,
             recursive=True,
-            stage_path=StageManager().stage_path_parts_from_str(stage_root),
+            stage_path_parts=stage_path_parts,
             print_diff=True,
+            force_overwrite=True,  # files copied to streamlit vstage need to be overwritten
         )

snowflake/cli/api/artifacts/upload.py

@@ -30,7 +30,7 @@ def sync_artifacts_with_stage(
         bundle_map=bundle_map,
         prune=prune,
         recursive=True,
-        stage_path=stage_path_parts,
+        stage_path_parts=stage_path_parts,
         print_diff=True,
     )
     project_paths.clean_up_output()

snowflake/cli/api/cli_global_context.py

@@ -19,7 +19,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
 from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, Optional
+from typing import TYPE_CHECKING, Iterator
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfigurationError
@@ -31,7 +31,6 @@ from snowflake.connector import SnowflakeConnection
 if TYPE_CHECKING:
     from snowflake.cli.api.project.definition_manager import DefinitionManager
     from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
-    from snowflake.core import Root
 
 _CONNECTION_CACHE = OpenConnectionCache()
 
@@ -197,18 +196,10 @@ class _CliGlobalContextAccess:
     @property
     def _should_force_mute_intermediate_output(self) -> bool:
         """Computes whether cli_console output should be muted."""
-        return self._manager.output_format == OutputFormat.JSON
-
-    @property
-    def snow_api_root(
-        self,
-    ) -> Optional[Root]:
-        from snowflake.core import Root
-
-        if self.connection:
-            return Root(self.connection)
-        else:
-            return None
+        return (
+            self._manager.output_format.is_json
+            or self._manager.output_format == OutputFormat.CSV
+        )
 
     @property
     def enhanced_exit_codes(self) -> bool:

snowflake/cli/api/commands/decorators.py

@@ -53,6 +53,7 @@ from snowflake.cli.api.commands.flags import (
     SilentOption,
     TemporaryConnectionOption,
     TokenFilePathOption,
+    TokenOption,
     UserOption,
     VerboseOption,
     WarehouseOption,
@@ -279,6 +280,12 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=MasterTokenOption,
     ),
+    inspect.Parameter(
+        "token",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=TokenOption,
+    ),
     inspect.Parameter(
         "token_file_path",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/flags.py

@@ -212,6 +212,16 @@ MasterTokenOption = typer.Option(
     hidden=True,
 )
 
+
+TokenOption = typer.Option(
+    None,
+    "--token",
+    help="OAuth token to use when connecting to Snowflake.",
+    callback=_connection_callback("token"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 TokenFilePathOption = typer.Option(
     None,
     "--token-file-path",
@@ -274,6 +284,7 @@ MfaPasscodeOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+
 EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
@@ -435,6 +446,7 @@ OutputFormatOption = typer.Option(
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
+
 SilentOption = typer.Option(
     False,
     "--silent",

snowflake/cli/api/commands/snow_typer.py

@@ -46,6 +46,8 @@ from typer.core import TyperGroup
 
 log = logging.getLogger(__name__)
 
+PREVIEW_PREFIX = ""
+
 
 class SortedTyperGroup(TyperGroup):
     def list_commands(self, ctx: click.Context) -> List[str]:
@@ -92,6 +94,7 @@ class SnowTyper(typer.Typer):
         requires_connection: bool = False,
         is_enabled: Callable[[], bool] | None = None,
         require_warehouse: bool = False,
+        preview: bool = False,
         **kwargs,
     ):
         """
@@ -106,9 +109,18 @@ class SnowTyper(typer.Typer):
 
         def custom_command(command_callable):
             """Custom command wrapper similar to Typer.command."""
-            # Sanitize doc string which is used to create help in terminal
             command_callable.__doc__ = sanitize_for_terminal(command_callable.__doc__)
 
+            if preview and command_callable.__doc__:
+                if not command_callable.__doc__.strip().startswith(PREVIEW_PREFIX):
+                    command_callable.__doc__ = (
+                        f"{PREVIEW_PREFIX}{command_callable.__doc__.strip()}"
+                    )
+
+            if preview and "help" in kwargs and kwargs["help"]:
+                if not kwargs["help"].strip().startswith(PREVIEW_PREFIX):
+                    kwargs["help"] = f"{PREVIEW_PREFIX}{kwargs['help'].strip()}"
+
             if requires_connection:
                 command_callable = global_options_with_connection(command_callable)
             elif requires_global_options:
@@ -228,6 +240,7 @@ class SnowTyperFactory:
         short_help: Optional[str] = None,
         is_hidden: Optional[Callable[[], bool]] = None,
         deprecated: bool = False,
+        preview: bool = False,
         subcommand_metavar: Optional[str] = None,
     ):
         self.name = name
@@ -235,15 +248,21 @@ class SnowTyperFactory:
         self.short_help = short_help
         self.is_hidden = is_hidden
         self.deprecated = deprecated
+        self.preview = preview
         self.commands_to_register: List[SnowTyperCommandData] = []
         self.subapps_to_register: List[SnowTyperFactory] = []
         self.callbacks_to_register: List[Callable] = []
         self.subcommand_metavar = subcommand_metavar
 
     def create_instance(self) -> SnowTyper:
+        help_text = self.help
+        if self.preview and help_text:
+            if not help_text.strip().startswith(PREVIEW_PREFIX):
+                help_text = f"{PREVIEW_PREFIX}{help_text.strip()}"
+
         app = SnowTyper(
             name=self.name,
-            help=self.help,
+            help=help_text,
             short_help=self.short_help,
             hidden=self.is_hidden() if self.is_hidden else False,
             deprecated=self.deprecated,
@@ -251,6 +270,8 @@ class SnowTyperFactory:
         )
         # register commands
         for command in self.commands_to_register:
+            if self.preview and "preview" not in command.kwargs:
+                command.kwargs["preview"] = True
             app.command(*command.args, **command.kwargs)(command.func)
         # register callbacks
         for callback in self.callbacks_to_register:

snowflake/cli/api/config.py

@@ -55,6 +55,7 @@ CONNECTIONS_SECTION = "connections"
 CLI_SECTION = "cli"
 LOGS_SECTION = "logs"
 PLUGINS_SECTION = "plugins"
+IGNORE_NEW_VERSION_WARNING_KEY = "ignore_new_version_warning"
 
 LOGS_SECTION_PATH = [CLI_SECTION, LOGS_SECTION]
 PLUGINS_SECTION_PATH = [CLI_SECTION, PLUGINS_SECTION]
@@ -204,10 +205,12 @@ def _read_config_file():
 
 def _initialise_logs_section():
     with _config_file() as conf_file_cache:
-        if conf_file_cache.get(CLI_SECTION) is None:
-            conf_file_cache[CLI_SECTION] = _DEFAULT_CLI_CONFIG
-        if conf_file_cache[CLI_SECTION].get(LOGS_SECTION) is None:
-            conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
+        conf_file_cache[CLI_SECTION][LOGS_SECTION] = _DEFAULT_LOGS_CONFIG
+
+
+def _initialise_cli_section():
+    with _config_file() as conf_file_cache:
+        conf_file_cache[CLI_SECTION] = {IGNORE_NEW_VERSION_WARNING_KEY: False}
 
 
 def set_config_value(path: List[str], value: Any) -> None:
@@ -297,7 +300,7 @@ def get_config_value(*path, key: str, default: Optional[Any] = Empty) -> Any:
         return env_variable
     try:
         return get_config_section(*path)[key]
-    except (KeyError, NonExistentKey, MissingConfigOptionError):
+    except (KeyError, NonExistentKey, MissingConfigOptionError, ConfigSourceError):
         if default is not Empty:
             return default
         raise
@@ -321,6 +324,7 @@ def _initialise_config(config_file: Path) -> None:
     config_file = SecurePath(config_file)
     config_file.parent.mkdir(parents=True, exist_ok=True)
     config_file.touch()
+    _initialise_cli_section()
     _initialise_logs_section()
     log.info("Created Snowflake configuration file at %s", CONFIG_MANAGER.file_path)
 

snowflake/cli/api/connections.py

@@ -48,6 +48,7 @@ class ConnectionContext:
     private_key_file: Optional[str] = None
     warehouse: Optional[str] = None
     mfa_passcode: Optional[str] = None
+    token: Optional[str] = None
     enable_diag: Optional[bool] = False
     diag_log_path: Optional[Path] = None
     diag_allowlist_path: Optional[Path] = None

snowflake/cli/api/constants.py

@@ -36,6 +36,7 @@ class ObjectNames:
 class ObjectType(Enum):
     COMPUTE_POOL = ObjectNames("compute-pool", "compute pool", "compute pools")
     DBT_PROJECT = ObjectNames("dbt-project", "dbt project", "dbt projects")
+    DCM_PROJECT = ObjectNames("dcm", "DCM Project", "DCM Projects")
     DATABASE = ObjectNames("database", "database", "databases")
     FUNCTION = ObjectNames("function", "function", "functions")
     INTEGRATION = ObjectNames("integration", "integration", "integrations")
@@ -48,7 +49,6 @@ class ObjectType(Enum):
     NETWORK_RULE = ObjectNames("network-rule", "network rule", "network rules")
     NOTEBOOK = ObjectNames("notebook", "notebook", "notebooks")
     PROCEDURE = ObjectNames("procedure", "procedure", "procedures")
-    PROJECT = ObjectNames("project", "project", "projects")
     ROLE = ObjectNames("role", "role", "roles")
     SCHEMA = ObjectNames("schema", "schema", "schemas")
     SERVICE = ObjectNames("service", "service", "services")
@@ -79,7 +79,7 @@ OBJECT_TO_NAMES = {o.value.cli_name: o.value for o in ObjectType}
 UNSUPPORTED_OBJECTS = {
     ObjectType.APPLICATION.value.cli_name,
     ObjectType.APPLICATION_PACKAGE.value.cli_name,
-    ObjectType.PROJECT.value.cli_name,
+    ObjectType.DCM_PROJECT.value.cli_name,
     ObjectType.DBT_PROJECT.value.cli_name,
 }
 SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys() - UNSUPPORTED_OBJECTS)

snowflake/cli/api/entities/common.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Generic, List, Optional, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
-from snowflake.cli.api.cli_global_context import get_cli_context, span
+from snowflake.cli.api.cli_global_context import span
 from snowflake.cli.api.entities.resolver import Dependency, DependencyResolver
 from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
 from snowflake.cli.api.identifiers import FQN
@@ -102,8 +102,8 @@ class EntityBase(Generic[T]):
     ) -> SqlExecutor:
         return get_sql_executor()
 
-    def _execute_query(self, sql: str) -> SnowflakeCursor:
-        return self._sql_executor.execute_query(sql)
+    def _execute_query(self, sql: str, **kwargs) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(sql, **kwargs)
 
     @functools.cached_property
     def _conn(self) -> SnowflakeConnection:
@@ -117,13 +117,6 @@ class EntityBase(Generic[T]):
     def schema(self) -> Optional[str]:
         return self.get_from_fqn_or_conn("schema")
 
-    @property
-    def snow_api_root(self) -> Optional[object]:
-        root = get_cli_context().snow_api_root
-        if root is None:
-            raise ValueError("snow_api_root is not set")
-        return root
-
     @property
     def model(self) -> T:
         return self._entity_model
@@ -140,12 +133,22 @@ class EntityBase(Generic[T]):
     def get_drop_sql(self) -> str:
         return f"DROP {self.model.type.upper()} {self.identifier};"  # type: ignore[attr-defined]
 
-    def _get_identifier(
+    def _get_fqn(
         self, schema: Optional[str] = None, database: Optional[str] = None
-    ) -> str:
+    ) -> FQN:
         schema_to_use = schema or self._entity_model.fqn.schema or self._conn.schema  # type: ignore
         db_to_use = database or self._entity_model.fqn.database or self._conn.database  # type: ignore
-        return f"{self._entity_model.fqn.set_schema(schema_to_use).set_database(db_to_use).sql_identifier}"  # type: ignore
+        return self._entity_model.fqn.set_schema(schema_to_use).set_database(db_to_use)  # type: ignore
+
+    def _get_sql_identifier(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ) -> str:
+        return str(self._get_fqn(schema, database).sql_identifier)
+
+    def _get_identifier(
+        self, schema: Optional[str] = None, database: Optional[str] = None
+    ) -> str:
+        return str(self._get_fqn(schema, database).identifier)
 
     def get_from_fqn_or_conn(self, attribute_name: str) -> str:
         attribute = getattr(self.fqn, attribute_name, None) or getattr(

snowflake/cli/api/entities/utils.py

@@ -86,11 +86,12 @@ def sync_deploy_root_with_stage(
     bundle_map: BundleMap,
     prune: bool,
     recursive: bool,
-    stage_path: StagePathParts,
+    stage_path_parts: StagePathParts,
     role: str | None = None,
     package_name: str | None = None,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
+    force_overwrite: bool = False,
 ) -> DiffResult:
     """
     Ensures that the files on our remote stage match the artifacts we have in
@@ -101,27 +102,31 @@ def sync_deploy_root_with_stage(
         role (str): The name of the role to use for queries and commands.
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
-        stage_path (DefaultStagePathParts): stage path object.
+        stage_path_parts (StagePathParts): stage path parts object.
 
         package_name (str): supported for Native App compatibility. Should be None out of Native App context.
 
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
         local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
+        force_overwrite (bool): Some resources (e.g. streamlit) need to overwrite files on the stage. Defaults to False.
 
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-    if not package_name:
+    if stage_path_parts.is_vstage:
+        # vstages are created by FBE, so no need to do it manually
+        pass
+    elif not package_name:
         # ensure stage exists
-        stage_fqn = FQN.from_stage(stage_path.stage)
+        stage_fqn = FQN.from_stage(stage_path_parts.stage)
         console.step(f"Creating stage {stage_fqn} if not exists.")
         StageManager().create(fqn=stage_fqn)
     else:
         # ensure stage exists - nativeapp behavior
         sql_facade = get_snowflake_facade()
-        schema = stage_path.schema
-        stage_fqn = stage_path.stage
+        schema = stage_path_parts.schema
+        stage_fqn = stage_path_parts.stage
         # Does a stage already exist within the application package, or we need to create one?
         # Using "if not exists" should take care of either case.
         console.step(
@@ -134,12 +139,12 @@ def sync_deploy_root_with_stage(
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
         console.step(
-            f"Performing a diff between the Snowflake stage: {stage_path.path} and your local deploy_root: {deploy_root.resolve()}."
+            f"Performing a diff between the Snowflake stage: {stage_path_parts.path} and your local deploy_root: {deploy_root.resolve()}."
         )
 
     diff: DiffResult = compute_stage_diff(
         local_root=deploy_root,
-        stage_path=stage_path,
+        stage_path=stage_path_parts,
     )
 
     if local_paths_to_sync:
@@ -201,7 +206,8 @@ def sync_deploy_root_with_stage(
             role=role,
             deploy_root_path=deploy_root,
             diff_result=diff,
-            stage_full_path=stage_path.full_path,
+            stage_full_path=stage_path_parts.full_path,
+            force_overwrite=force_overwrite,
         )
     return diff
 

snowflake/cli/api/feature_flags.py

@@ -50,16 +50,12 @@ class FeatureFlagMixin(Enum):
             is not None
         )
 
-    def env_variable(self):
+    def env_variable(self) -> str:
         return get_env_variable_name(*FEATURE_FLAGS_SECTION_PATH, key=self.value.name)
 
 
 @unique
 class FeatureFlag(FeatureFlagMixin):
-    ENABLE_STREAMLIT_EMBEDDED_STAGE = BooleanFlag(
-        "ENABLE_STREAMLIT_EMBEDDED_STAGE", False
-    )
-    ENABLE_STREAMLIT_NO_CHECKOUTS = BooleanFlag("ENABLE_STREAMLIT_NO_CHECKOUTS", False)
     ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_VERSIONED_STAGE", False
     )
@@ -76,3 +72,4 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_NATIVE_APP_CHILDREN = BooleanFlag("ENABLE_NATIVE_APP_CHILDREN", False)
     # TODO 4.0: remove ENABLE_RELEASE_CHANNELS
     ENABLE_RELEASE_CHANNELS = BooleanFlag("ENABLE_RELEASE_CHANNELS", None)
+    ENABLE_SNOWFLAKE_PROJECTS = BooleanFlag("ENABLE_SNOWFLAKE_PROJECTS", False)

snowflake/cli/api/output/formats.py

@@ -18,3 +18,9 @@ from enum import Enum
 class OutputFormat(Enum):
     TABLE = "TABLE"
     JSON = "JSON"
+    JSON_EXT = "JSON_EXT"
+    CSV = "CSV"
+
+    @property
+    def is_json(self) -> bool:
+        return self in (OutputFormat.JSON, OutputFormat.JSON_EXT)

snowflake/cli/api/output/types.py

@@ -16,11 +16,22 @@ from __future__ import annotations
 
 import json
 import typing as t
+from enum import IntEnum
 
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.connector import DictCursor
 from snowflake.connector.cursor import SnowflakeCursor
 
 
+class SnowflakeColumnType(IntEnum):
+    """Snowflake column type codes for JSON-capable data types."""
+
+    VARIANT = 5
+    OBJECT = 9
+    ARRAY = 10
+
+
 class CommandResult:
     @property
     def result(self):
@@ -69,13 +80,48 @@ class StreamResult(CommandResult):
 class QueryResult(CollectionResult):
     def __init__(self, cursor: SnowflakeCursor | DictCursor):
         self.column_names = [col.name for col in cursor.description]
+        # Store column type information to identify VARIANT columns (JSON data)
+        self.column_types = [col.type_code for col in cursor.description]
         super().__init__(elements=self._prepare_payload(cursor))
         self._query = cursor.query
 
     def _prepare_payload(self, cursor: SnowflakeCursor | DictCursor):
         if isinstance(cursor, DictCursor):
-            return (k for k in cursor)
-        return ({k: v for k, v in zip(self.column_names, row)} for row in cursor)
+            return (self._process_columns(k) for k in cursor)
+        return (
+            self._process_columns({k: v for k, v in zip(self.column_names, row)})
+            for row in cursor
+        )
+
+    def _process_columns(self, row_dict):
+        if get_cli_context().output_format != OutputFormat.JSON_EXT:
+            return row_dict
+
+        processed_row = {}
+        for i, (column_name, value) in enumerate(row_dict.items()):
+            # Check if this column can contain JSON data
+            if i < len(self.column_types) and self.column_types[i] in (
+                SnowflakeColumnType.VARIANT,
+                SnowflakeColumnType.OBJECT,
+                SnowflakeColumnType.ARRAY,
+            ):
+                # For ARRAY and OBJECT types, the values are always JSON strings that need parsing
+                # For VARIANT types, only parse if the value is a string
+                if self.column_types[i] in (
+                    SnowflakeColumnType.OBJECT,
+                    SnowflakeColumnType.ARRAY,
+                ) or isinstance(value, str):
+                    try:
+                        # Try to parse as JSON
+                        processed_row[column_name] = json.loads(value)
+                    except (json.JSONDecodeError, TypeError):
+                        # If parsing fails, keep the original value
+                        processed_row[column_name] = value
+                else:
+                    processed_row[column_name] = value
+            else:
+                processed_row[column_name] = value
+        return processed_row
 
     @property
     def query(self):

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

@@ -16,6 +16,10 @@ from __future__ import annotations
 
 from typing import Dict, List, Union, get_args
 
+from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
+    DCMProjectEntity,
+    DCMProjectEntityModel,
+)
 from snowflake.cli._plugins.nativeapp.entities.application import (
     ApplicationEntity,
     ApplicationEntityModel,
@@ -26,10 +30,6 @@ from snowflake.cli._plugins.nativeapp.entities.application_package import (
 )
 from snowflake.cli._plugins.notebook.notebook_entity import NotebookEntity
 from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
-from snowflake.cli._plugins.project.project_entity_model import (
-    ProjectEntity,
-    ProjectEntityModel,
-)
 from snowflake.cli._plugins.snowpark.snowpark_entity import (
     FunctionEntity,
     ProcedureEntity,
@@ -62,7 +62,7 @@ Entity = Union[
     ApplicationPackageEntity,
     StreamlitEntity,
     ProcedureEntity,
-    ProjectEntity,
+    DCMProjectEntity,
     FunctionEntity,
     ComputePoolEntity,
     ImageRepositoryEntity,
@@ -79,7 +79,7 @@ EntityModel = Union[
     ImageRepositoryEntityModel,
     ServiceEntityModel,
     NotebookEntityModel,
-    ProjectEntityModel,
+    DCMProjectEntityModel,
 ]
 
 ALL_ENTITIES: List[Entity] = [*get_args(Entity)]