snowflake-cli 3.0.2__py3-none-any.whl → 3.2.0__py3-none-any.whl

snowflake/cli/_plugins/workspace/commands.py

@@ -15,12 +15,13 @@
 from __future__ import annotations
 
 import logging
+from io import StringIO
 from pathlib import Path
 from textwrap import dedent
 from typing import List, Optional
 
 import typer
-from click import MissingParameter
+import yaml
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
@@ -43,6 +44,24 @@ ws = SnowTyperFactory(
 log = logging.getLogger(__name__)
 
 
+@ws.command(requires_connection=False, hidden=True)
+@with_project_definition()
+def dump(**options):
+    """
+    Dumps the project definition.
+    """
+    cli_context = get_cli_context()
+    pd = cli_context.project_definition
+    io = StringIO()
+    yaml.safe_dump(
+        pd.model_dump(mode="json", by_alias=True),
+        io,
+        sort_keys=False,
+        width=float("inf"),  # Don't break lines
+    )
+    return MessageResult(io.getvalue())
+
+
 @ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
 def bundle(
@@ -243,6 +262,11 @@ def version_create(
         help=f"""The patch number you want to create for an existing version.
         Defaults to undefined if it is not set, which means the Snowflake CLI either uses the patch specified in the `manifest.yml` file or automatically generates a new patch number.""",
     ),
+    label: Optional[str] = typer.Option(
+        None,
+        "--label",
+        help="A label for the version that is displayed to consumers. If unset, the version label specified in `manifest.yml` file is used.",
+    ),
     skip_git_check: Optional[bool] = typer.Option(
         False,
         "--skip-git-check",
@@ -254,8 +278,6 @@ def version_create(
     **options,
 ):
     """Creates a new version for the specified entity."""
-    if version is None and patch is not None:
-        raise MissingParameter("Cannot provide a patch without version!")
 
     cli_context = get_cli_context()
     ws = WorkspaceManager(
@@ -267,6 +289,7 @@ def version_create(
         EntityActions.VERSION_CREATE,
         version=version,
         patch=patch,
+        label=label,
         skip_git_check=skip_git_check,
         interactive=interactive,
         force=force,
@@ -299,7 +322,7 @@ def version_drop(
     )
     ws.perform_action(
         entity_id,
-        EntityActions.VERSION_CREATE,
+        EntityActions.VERSION_DROP,
         version=version,
         interactive=interactive,
         force=force,

snowflake/cli/_plugins/workspace/context.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Callable
+
+from snowflake.cli.api.console.abc import AbstractConsole
+
+
+@dataclass
+class WorkspaceContext:
+    """
+    An object that is passed to each entity when instantiated by WorkspaceManager
+    to allow access to the CLI context without requiring the entities to use
+    get_cli_context().
+    """
+
+    console: AbstractConsole
+    project_root: Path
+    get_default_role: Callable[[], str]
+    get_default_warehouse: Callable[[], str | None]
+
+    @cached_property
+    def default_role(self) -> str:
+        return self.get_default_role()
+
+    @cached_property
+    def default_warehouse(self) -> str | None:
+        return self.get_default_warehouse()
+
+
+@dataclass
+class ActionContext:
+    """
+    An object that is passed to each action when called by WorkspaceManager
+    to provide access to metadata about the entity and project being acted upon.
+    """
+
+    get_entity: Callable

snowflake/cli/_plugins/workspace/manager.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 from typing import Dict
 
-from snowflake.cli._plugins.workspace.action_context import ActionContext
+from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.entities.common import EntityActions, get_sql_executor
@@ -31,13 +31,6 @@ class WorkspaceManager:
         self._entities_cache: Dict[str, Entity] = {}
         self._project_definition: DefinitionV20 = project_definition
         self._project_root = project_root
-        self._default_role = default_role()
-        if self._default_role is None:
-            self._default_role = get_sql_executor().current_role()
-        self.default_warehouse = None
-        cli_context = get_cli_context()
-        if cli_context.connection.warehouse:
-            self.default_warehouse = to_identifier(cli_context.connection.warehouse)
 
     def get_entity(self, entity_id: str):
         """
@@ -50,7 +43,13 @@ class WorkspaceManager:
             raise ValueError(f"No such entity ID: {entity_id}")
         entity_model_cls = entity_model.__class__
         entity_cls = v2_entity_model_to_entity_map[entity_model_cls]
-        self._entities_cache[entity_id] = entity_cls(entity_model)
+        workspace_ctx = WorkspaceContext(
+            console=cc,
+            project_root=self.project_root,
+            get_default_role=_get_default_role,
+            get_default_warehouse=_get_default_warehouse,
+        )
+        self._entities_cache[entity_id] = entity_cls(entity_model, workspace_ctx)
         return self._entities_cache[entity_id]
 
     def perform_action(self, entity_id: str, action: EntityActions, *args, **kwargs):
@@ -60,15 +59,26 @@ class WorkspaceManager:
         entity = self.get_entity(entity_id)
         if entity.supports(action):
             action_ctx = ActionContext(
-                console=cc,
-                project_root=self.project_root(),
-                default_role=self._default_role,
-                default_warehouse=self.default_warehouse,
                 get_entity=self.get_entity,
             )
             return entity.perform(action, action_ctx, *args, **kwargs)
         else:
             raise ValueError(f'This entity type does not support "{action.value}"')
 
+    @property
     def project_root(self) -> Path:
         return self._project_root
+
+
+def _get_default_role() -> str:
+    role = default_role()
+    if role is None:
+        role = get_sql_executor().current_role()
+    return role
+
+
+def _get_default_warehouse() -> str | None:
+    warehouse = get_cli_context().connection.warehouse
+    if warehouse:
+        warehouse = to_identifier(warehouse)
+    return warehouse

snowflake/cli/api/cli_global_context.py

@@ -54,9 +54,9 @@ class _CliGlobalContextManager:
     project_env_overrides_args: dict[str, str] = field(default_factory=dict)
 
     # FIXME: this property only exists to help implement
-    # nativeapp_definition_v2_to_v1. Consider changing the way
-    # this calculation is provided to commands in order to remove
-    # this logic (then make project_definition a non-cloned @property)
+    # nativeapp_definition_v2_to_v1 and single_app_and_package.
+    # Consider changing the way this calculation is provided to commands
+    # in order to remove this logic (then make project_definition a non-cloned @property)
     override_project_definition: ProjectDefinition | None = None
 
     _definition_manager: DefinitionManager | None = None
@@ -76,6 +76,7 @@ class _CliGlobalContextManager:
             self,
             connection_context=self.connection_context.clone(),
             project_env_overrides_args=self.project_env_overrides_args.copy(),
+            metrics=self.metrics.clone(),
         )
 
     def __setattr__(self, prop, val):

snowflake/cli/api/commands/flags.py

@@ -33,6 +33,7 @@ from snowflake.cli.api.connections import ConnectionContext
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.stage_path import StagePath
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
 
@@ -83,7 +84,7 @@ ConnectionOption = typer.Option(
     "--connection",
     "-c",
     "--environment",
-    help=f"Name of the connection, as defined in your `config.toml`. Default: `default`.",
+    help=f"Name of the connection, as defined in your `config.toml` file. Default: `default`.",
     callback=_connection_callback("connection_name"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -276,7 +277,7 @@ MfaPasscodeOption = typer.Option(
 EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
-    help="Run python connector diagnostic test",
+    help="Run Python connector diagnostic test",
     callback=_connection_callback("enable_diag"),
     show_default=False,
     is_flag=True,
@@ -349,7 +350,7 @@ VerboseOption = typer.Option(
 DebugOption = typer.Option(
     False,
     "--debug",
-    help="Displays log entries for log levels `debug` and higher; debug logs contains additional information.",
+    help="Displays log entries for log levels `debug` and higher; debug logs contain additional information.",
     callback=_context_callback("enable_tracebacks"),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
@@ -406,9 +407,9 @@ def variables_option(description: str):
 
 
 ExecuteVariablesOption = variables_option(
-    'Variables for the execution context. For example: `-D "<key>=<value>"`. '
-    "For SQL files variables are use to expand the template and any unknown variable will cause an error. "
-    "For Python files variables are used to update os.environ dictionary. Provided keys are capitalized to adhere to best practices."
+    'Variables for the execution context; for example: `-D "<key>=<value>"`. '
+    "For SQL files, variables are used to expand the template, and any unknown variable will cause an error (consider embedding quoting in the file)."
+    "For Python files, variables are used to update the os.environ dictionary. Provided keys are capitalized to adhere to best practices. "
     "In case of SQL files string values must be quoted in `''` (consider embedding quoting in the file).",
 )
 
@@ -473,6 +474,13 @@ class IdentifierStageType(click.ParamType):
         return FQN.from_stage(value)
 
 
+class IdentifierStagePathType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return StagePath.from_stage_str(value)
+
+
 def identifier_argument(
     sf_object: str,
     example: str,
@@ -481,7 +489,7 @@ def identifier_argument(
 ) -> typer.Argument:
     return typer.Argument(
         ...,
-        help=f"Identifier of the {sf_object}. For example: {example}",
+        help=f"Identifier of the {sf_object}; for example: {example}",
         show_default=False,
         click_type=click_type,
         callback=callback,
@@ -496,6 +504,14 @@ def identifier_stage_argument(
     )
 
 
+def identifier_stage_path_argument(
+    sf_object: str, example: str, callback: Callable | None = None
+) -> typer.Argument:
+    return identifier_argument(
+        sf_object, example, click_type=IdentifierStagePathType(), callback=callback
+    )
+
+
 def execution_identifier_argument(sf_object: str, example: str) -> typer.Argument:
     return typer.Argument(
         ...,

snowflake/cli/api/config.py

@@ -181,7 +181,7 @@ def _read_config_file():
                 )
                 warnings.warn(
                     f"Unauthorized users ({users}) have access to configuration file {CONFIG_MANAGER.file_path}.\n"
-                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /deny <USER_ID>:F` on those users to restrict permissions.'
+                    f'Run `icacls "{CONFIG_MANAGER.file_path}" /remove:g <USER_ID>` on those users to restrict permissions.'
                 )
 
         try:
@@ -340,16 +340,34 @@ def _get_envs_for_path(*path) -> dict:
     }
 
 
-def _dump_config(conf_file_cache: Dict):
+def _dump_config(config_and_connections: Dict):
+    config_toml_dict = config_and_connections.copy()
+
+    if CONNECTIONS_FILE.exists():
+        # update connections in connections.toml
+        # it will add only connections (maybe updated) which were originally read from connections.toml
+        # it won't add connections from config.toml
+        # because config manager doesn't have connections from config.toml if connections.toml exists
+        _update_connections_toml(config_and_connections.get("connections") or {})
+        # to config.toml save only connections from config.toml
+        connections_to_save_in_config_toml = _read_config_file_toml().get("connections")
+        if connections_to_save_in_config_toml:
+            config_toml_dict["connections"] = connections_to_save_in_config_toml
+        else:
+            config_toml_dict.pop("connections", None)
+
     with SecurePath(CONFIG_MANAGER.file_path).open("w+") as fh:
-        dump(conf_file_cache, fh)
+        dump(config_toml_dict, fh)
 
 
 def _check_default_config_files_permissions() -> None:
-    if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(CONNECTIONS_FILE):
-        raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
-    if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):
-        raise ConfigFileTooWidePermissionsError(CONFIG_FILE)
+    if not IS_WINDOWS:
+        if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(
+            CONNECTIONS_FILE
+        ):
+            raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
+        if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):
+            raise ConfigFileTooWidePermissionsError(CONFIG_FILE)
 
 
 from typing import Literal
@@ -370,9 +388,12 @@ def get_feature_flags_section() -> Dict[str, bool | Literal["UNKNOWN"]]:
     return {k: _bool_or_unknown(v) for k, v in flags.items()}
 
 
+def _read_config_file_toml() -> dict:
+    return tomlkit.loads(CONFIG_MANAGER.file_path.read_text()).unwrap()
+
+
 def _read_connections_toml() -> dict:
-    with open(CONNECTIONS_FILE, "r") as f:
-        return tomlkit.loads(f.read()).unwrap()
+    return tomlkit.loads(CONNECTIONS_FILE.read_text()).unwrap()
 
 
 def _update_connections_toml(connections: dict):

snowflake/cli/api/connections.py

@@ -22,7 +22,7 @@ from dataclasses import asdict, dataclass, field, fields, replace
 from pathlib import Path
 from typing import Optional
 
-from snowflake.cli.api.config import get_default_connection_name
+from snowflake.cli.api.config import get_connection_dict, get_default_connection_name
 from snowflake.cli.api.exceptions import InvalidSchemaError
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.compat import IS_WINDOWS
@@ -79,6 +79,17 @@ class ConnectionContext:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
             setattr(self, key, value)
 
+    def update_from_config(self) -> ConnectionContext:
+        connection_config = get_connection_dict(connection_name=self.connection_name)
+        if "private_key_path" in connection_config:
+            connection_config["private_key_file"] = connection_config[
+                "private_key_path"
+            ]
+            del connection_config["private_key_path"]
+
+        self.update(**connection_config)
+        return self
+
     def __repr__(self) -> str:
         """Minimal repr where None values have their keys omitted."""
         items = [f"{k}={repr(v)}" for (k, v) in self.present_values_as_dict().items()]

snowflake/cli/api/console/console.py

@@ -29,10 +29,6 @@ IMPORTANT_STYLE: Style = Style(bold=True, italic=True)
 INDENTATION_LEVEL: int = 2
 
 
-class CliConsoleNestingProhibitedError(RuntimeError):
-    """CliConsole phase nesting not allowed."""
-
-
 class CliConsole(AbstractConsole):
     """An utility for displaying intermediate output.
 
@@ -70,28 +66,21 @@ class CliConsole(AbstractConsole):
     @contextmanager
     def phase(self, enter_message: str, exit_message: Optional[str] = None):
         """A context manager for organising steps into logical group."""
-        if self.in_phase:
-            raise CliConsoleNestingProhibitedError("Only one phase allowed at a time.")
-        if self._extra_indent > 0:
-            raise CliConsoleNestingProhibitedError(
-                "Phase cannot be used in an indented block."
-            )
-
         self._print(self._format_message(enter_message, Output.PHASE))
-        self._in_phase = True
+        self._extra_indent += 1
 
         try:
             yield self.step
         finally:
-            self._in_phase = False
+            self._extra_indent -= 1
             if exit_message:
                 self._print(self._format_message(exit_message, Output.PHASE))
 
     @contextmanager
     def indented(self):
         """
-        A context manager for temporarily indenting messages and warnings. Phases and steps cannot be used in indented blocks,
-        but multiple indented blocks can be nested (use sparingly).
+        A context manager for temporarily indenting messages and warnings.
+        Multiple indented blocks can be nested (use sparingly).
         """
         self._extra_indent += 1
         try:
@@ -104,10 +93,6 @@ class CliConsole(AbstractConsole):
 
         If called within a phase, the output will be indented.
         """
-        if self._extra_indent > 0:
-            raise CliConsoleNestingProhibitedError(
-                "Step cannot be used in an indented block."
-            )
         text = self._format_message(message, Output.STEP)
         self._print(text)
 

snowflake/cli/api/entities/common.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Generic, Type, TypeVar, get_args
 
-from snowflake.cli._plugins.workspace.action_context import ActionContext
+from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
 from snowflake.cli.api.sql_execution import SqlExecutor
 
 
@@ -10,6 +10,7 @@ class EntityActions(str, Enum):
     DEPLOY = "action_deploy"
     DROP = "action_drop"
     VALIDATE = "action_validate"
+    EVENTS = "action_events"
 
     VERSION_LIST = "action_version_list"
     VERSION_CREATE = "action_version_create"
@@ -24,8 +25,9 @@ class EntityBase(Generic[T]):
     Base class for the fully-featured entity classes.
     """
 
-    def __init__(self, entity_model: T):
+    def __init__(self, entity_model: T, workspace_ctx: WorkspaceContext):
         self._entity_model = entity_model
+        self._workspace_ctx = workspace_ctx
 
     @classmethod
     def get_entity_model_type(cls) -> Type[T]:

snowflake/cli/api/entities/utils.py

@@ -1,6 +1,5 @@
 import os
 from pathlib import Path
-from textwrap import dedent
 from typing import Any, List, NoReturn, Optional
 
 import jinja2
@@ -13,10 +12,11 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
 )
+from snowflake.cli._plugins.nativeapp.sf_facade import get_snowflake_facade
 from snowflake.cli._plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
-    StagePath,
+    StagePathType,
     compute_stage_diff,
     preserve_from_diff,
     sync_local_diff_with_stage,
@@ -30,7 +30,11 @@ from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
 )
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.exceptions import (
+    DoesNotExistOrUnauthorizedError,
+    NoWarehouseSelectedInSessionError,
+    SnowflakeSQLExecutionError,
+)
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.rendering.sql_templates import (
@@ -41,46 +45,21 @@ from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
 
-def generic_sql_error_handler(
-    err: ProgrammingError, role: Optional[str] = None, warehouse: Optional[str] = None
-) -> NoReturn:
+def generic_sql_error_handler(err: ProgrammingError) -> NoReturn:
     # Potential refactor: If moving away from Python 3.8 and 3.9 to >= 3.10, use match ... case
-    if err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                '{role}' may not have access to warehouse '{warehouse}'.
-                Please grant usage privilege on warehouse to this role.
-                """
-            ),
-            errno=err.errno,
-        )
+    if (
+        err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED
+        or "does not exist or not authorized" in err.msg
+    ):
+        raise DoesNotExistOrUnauthorizedError(msg=err.msg) from err
     elif err.errno == NO_WAREHOUSE_SELECTED_IN_SESSION:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                Please provide a warehouse for the active session role in your project definition file, config.toml file, or via command line.
-                """
-            ),
-            errno=err.errno,
-        )
-    elif "does not exist or not authorized" in err.msg:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                Please check the name of the resource you are trying to query or the permissions of the role you are using to run the query.
-                """
-            )
-        )
+        raise NoWarehouseSelectedInSessionError(msg=err.msg) from err
     raise err
 
 
 def _get_stage_paths_to_sync(
     local_paths_to_sync: List[Path], deploy_root: Path
-) -> List[StagePath]:
+) -> List[StagePathType]:
     """
     Takes a list of paths (files and directories), returning a list of all files recursively relative to the deploy root.
     """
@@ -128,22 +107,15 @@ def sync_deploy_root_with_stage(
         A `DiffResult` instance describing the changes that were performed.
     """
 
-    sql_executor = get_sql_executor()
+    sql_facade = get_snowflake_facade()
     # 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(
         f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
     )
-    with sql_executor.use_role(role):
-        sql_executor.execute_query(
-            f"create schema if not exists {package_name}.{stage_schema}"
-        )
-        sql_executor.execute_query(
-            f"""
-                    create stage if not exists {stage_fqn}
-                    encryption = (TYPE = 'SNOWFLAKE_SSE')
-                    DIRECTORY = (ENABLE = TRUE)"""
-        )
+    if not sql_facade.stage_exists(stage_fqn):
+        sql_facade.create_schema(stage_schema, database=package_name)
+        sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
@@ -217,36 +189,24 @@ def sync_deploy_root_with_stage(
     return diff
 
 
-def _execute_sql_script(
-    script_content: str,
-    database_name: Optional[str] = None,
-) -> None:
-    """
-    Executing the provided SQL script content.
-    This assumes that a relevant warehouse is already active.
-    If database_name is passed in, it will be used first.
-    """
-    try:
-        sql_executor = get_sql_executor()
-        if database_name is not None:
-            sql_executor.execute_query(f"use database {database_name}")
-        sql_executor.execute_queries(script_content)
-    except ProgrammingError as err:
-        generic_sql_error_handler(err)
-
-
 def execute_post_deploy_hooks(
     console: AbstractConsole,
     project_root: Path,
     post_deploy_hooks: Optional[List[PostDeployHook]],
     deployed_object_type: str,
+    role_name: str,
     database_name: str,
+    warehouse_name: str,
 ) -> None:
     """
     Executes post-deploy hooks for the given object type.
     While executing SQL post deploy hooks, it first switches to the database provided in the input.
     All post deploy scripts templates will first be expanded using the global template context.
     """
+    get_cli_context().metrics.set_counter_default(
+        CLICounterField.POST_DEPLOY_SCRIPTS, 0
+    )
+
     if not post_deploy_hooks:
         return
 
@@ -254,9 +214,11 @@ def execute_post_deploy_hooks(
 
     with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
         sql_scripts_paths = []
+        display_paths = []
         for hook in post_deploy_hooks:
             if hook.sql_script:
                 sql_scripts_paths.append(hook.sql_script)
+                display_paths.append(hook.display_path)
             else:
                 raise ValueError(
                     f"Unsupported {deployed_object_type} post-deploy hook type: {hook}"
@@ -268,11 +230,16 @@ def execute_post_deploy_hooks(
             sql_scripts_paths,
         )
 
-        for index, sql_script_path in enumerate(sql_scripts_paths):
+        sql_facade = get_snowflake_facade()
+
+        for index, sql_script_path in enumerate(display_paths):
             console.step(f"Executing SQL script: {sql_script_path}")
-            _execute_sql_script(
-                script_content=scripts_content_list[index],
-                database_name=database_name,
+            sql_facade.execute_user_script(
+                queries=scripts_content_list[index],
+                script_name=sql_script_path,
+                role=role_name,
+                warehouse=warehouse_name,
+                database=database_name,
             )
 
 

snowflake/cli/api/errno.py

@@ -26,3 +26,5 @@ ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93046
 NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93055
 APPLICATION_NO_LONGER_AVAILABLE = 93079
 APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128
+APPLICATION_REQUIRES_TELEMETRY_SHARING = 93321
+CANNOT_DISABLE_MANDATORY_TELEMETRY = 93329