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

snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -173,20 +173,28 @@ class SnowparkEntity(EntityBase[Generic[T]]):
         if self.model.secrets:
             query.append(self.model.get_secrets_sql())
 
-        if self.model.type == "procedure" and self.model.execute_as_caller:
-            query.append("EXECUTE AS CALLER")
+        if self.model.artifact_repository and (
+            self.model.artifact_repository_packages or self.model.packages
+        ):
+            if self.model.artifact_repository_packages:
+                packages = [
+                    f"'{item}'" for item in self.model.artifact_repository_packages
+                ]
+            else:
+                packages = [f"'{item}'" for item in self.model.packages]
 
-        if self.model.artifact_repository and self.model.artifact_repository_packages:
-            packages = [f"'{item}'" for item in self.model.artifact_repository_packages]
             query.extend(
                 [
                     f"ARTIFACT_REPOSITORY= {self.model.artifact_repository} ",
-                    f"ARTIFACT_REPOSITORY_PACKAGES=({','.join(packages)})",
+                    f"PACKAGES=({','.join(packages)})",
                 ]
             )
         if self.model.resource_constraint:
             query.append(self._get_resource_constraints_sql())
 
+        if self.model.type == "procedure" and self.model.execute_as_caller:
+            query.append("EXECUTE AS CALLER")
+
         return "\n".join(query)
 
     def get_execute_sql(self, execution_arguments: List[str] | None = None):

snowflake/cli/_plugins/snowpark/snowpark_entity_model.py

@@ -54,6 +54,9 @@ class SnowparkEntityModel(
         default=None, title="Artifact repository to be used"
     )
     artifact_repository_packages: Optional[List[str]] = Field(
+        default=None, title="Alias for packages"
+    )
+    packages: Optional[List[str]] = Field(
         default=None, title="Packages to be installed from artifact repository"
     )
 
@@ -91,9 +94,14 @@ class SnowparkEntityModel(
     def check_artifact_repository(cls, values: dict) -> dict:
         artifact_repository = values.get("artifact_repository")
         artifact_repository_packages = values.get("artifact_repository_packages")
-        if artifact_repository_packages and not artifact_repository:
+        packages = values.get("packages")
+        if artifact_repository_packages and packages:
+            raise ValueError(
+                "You cannot specify both artifact_repository_packages and packages.",
+            )
+        if (artifact_repository_packages or packages) and not artifact_repository:
             raise ValueError(
-                "You specified Artifact_repository_packages without setting Artifact_repository.",
+                "You specified packages / artifact_repository_packages without setting artifact_repository.",
             )
         return values
 

snowflake/cli/_plugins/sql/commands.py

@@ -15,11 +15,13 @@
 from __future__ import annotations
 
 import sys
+from enum import Enum
 from logging import getLogger
 from pathlib import Path
 from typing import List, Optional
 
 import typer
+from click import UsageError
 from snowflake.cli._plugins.sql.manager import SqlManager
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
@@ -34,6 +36,7 @@ from snowflake.cli.api.output.types import (
     MultipleResults,
     QueryResult,
 )
+from snowflake.cli.api.rendering.sql_templates import SQLTemplateSyntaxConfig
 
 logger = getLogger(__name__)
 # simple Typer with defaults because it won't become a command group as it contains only one command
@@ -46,6 +49,37 @@ SourceOption = OverrideableOption(
 )
 
 
+class _EnabledTemplating(str, Enum):
+    LEGACY = "LEGACY"
+    STANDARD = "STANDARD"
+    JINJA = "JINJA"
+    ALL = "ALL"
+    NONE = "NONE"
+
+
+def _parse_template_syntax_config(
+    enabled_syntaxes: List[_EnabledTemplating],
+) -> SQLTemplateSyntaxConfig:
+    if (
+        _EnabledTemplating.ALL in enabled_syntaxes
+        or _EnabledTemplating.NONE in enabled_syntaxes
+    ) and len(enabled_syntaxes) > 1:
+        raise UsageError(
+            "ALL and NONE template syntax options should not be used with other options."
+        )
+
+    if _EnabledTemplating.ALL in enabled_syntaxes:
+        return SQLTemplateSyntaxConfig(True, True, True)
+    if _EnabledTemplating.NONE in enabled_syntaxes:
+        return SQLTemplateSyntaxConfig(False, False, False)
+
+    result = SQLTemplateSyntaxConfig()
+    result.enable_legacy_syntax = _EnabledTemplating.LEGACY in enabled_syntaxes
+    result.enable_standard_syntax = _EnabledTemplating.STANDARD in enabled_syntaxes
+    result.enable_jinja_syntax = _EnabledTemplating.JINJA in enabled_syntaxes
+    return result
+
+
 @app.command(name="sql", requires_connection=True, no_args_is_help=False)
 @with_project_definition(is_optional=True)
 def execute_sql(
@@ -83,6 +117,12 @@ def execute_sql(
         flag_value=False,
         is_flag=True,
     ),
+    enabled_templating: List[_EnabledTemplating] = typer.Option(
+        [_EnabledTemplating.LEGACY, _EnabledTemplating.STANDARD],
+        "--enable-templating",
+        help="Syntax used to resolve variables before passing queries to Snowflake.",
+        case_sensitive=False,
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -100,6 +140,8 @@ def execute_sql(
     if data_override:
         data = {v.key: v.value for v in parse_key_value_variables(data_override)}
 
+    template_syntax_config = _parse_template_syntax_config(enabled_templating)
+
     retain_comments = bool(retain_comments)
     single_transaction = bool(single_transaction)
     std_in = bool(std_in)
@@ -116,7 +158,12 @@ def execute_sql(
             raise CliArgumentError("single transaction cannot be used with REPL")
         from snowflake.cli._plugins.sql.repl import Repl
 
-        Repl(SqlManager(), data=data, retain_comments=retain_comments).run()
+        Repl(
+            SqlManager(),
+            data=data,
+            retain_comments=retain_comments,
+            template_syntax_config=template_syntax_config,
+        ).run()
         sys.exit(0)
 
     manager = SqlManager()
@@ -128,6 +175,7 @@ def execute_sql(
         data=data,
         retain_comments=retain_comments,
         single_transaction=single_transaction,
+        template_syntax_config=template_syntax_config,
     )
     if expected_results_cnt == 0:
         # case expected if input only scheduled async queries

snowflake/cli/_plugins/sql/manager.py

@@ -32,7 +32,10 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.exceptions import CliArgumentError, CliSqlError
 from snowflake.cli.api.output.types import CollectionResult
-from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
+from snowflake.cli.api.rendering.sql_templates import (
+    SQLTemplateSyntaxConfig,
+    snowflake_sql_jinja_render,
+)
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
 from snowflake.connector.cursor import SnowflakeCursor
@@ -51,6 +54,7 @@ class SqlManager(SqlExecutionMixin):
         data: Dict | None = None,
         retain_comments: bool = False,
         single_transaction: bool = False,
+        template_syntax_config: SQLTemplateSyntaxConfig = SQLTemplateSyntaxConfig(),
     ) -> Tuple[ExpectedResultsCount, Iterable[SnowflakeCursor]]:
         """Reads, transforms and execute statements from input.
 
@@ -62,9 +66,15 @@ class SqlManager(SqlExecutionMixin):
         """
         query = sys.stdin.read() if std_in else query
 
-        stmt_operators = (
-            transpile_snowsql_templates,
-            partial(snowflake_sql_jinja_render, data=data),
+        stmt_operators = []
+        if template_syntax_config.enable_legacy_syntax:
+            stmt_operators.append(transpile_snowsql_templates)
+        stmt_operators.append(
+            partial(
+                snowflake_sql_jinja_render,
+                template_syntax_config=template_syntax_config,
+                data=data,
+            )
         )
         remove_comments = not retain_comments
 

snowflake/cli/_plugins/sql/repl.py

@@ -13,6 +13,7 @@ from snowflake.cli._plugins.sql.manager import SqlManager
 from snowflake.cli.api.cli_global_context import get_cli_context_manager
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.output.types import MultipleResults, QueryResult
+from snowflake.cli.api.rendering.sql_templates import SQLTemplateSyntaxConfig
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 from snowflake.connector.cursor import SnowflakeCursor
@@ -35,6 +36,7 @@ class Repl:
         sql_manager: SqlManager,
         data: dict | None = None,
         retain_comments: bool = False,
+        template_syntax_config: SQLTemplateSyntaxConfig = SQLTemplateSyntaxConfig(),
     ):
         """Requires a `SqlManager` instance to execute queries.
 
@@ -46,6 +48,7 @@ class Repl:
         setattr(get_cli_context_manager(), "is_repl", True)
         self._data = data or {}
         self._retain_comments = retain_comments
+        self._template_syntax_config = template_syntax_config
         self._history = FileHistory(HISTORY_FILE)
         self._lexer = PygmentsLexer(CliLexer)
         self._completer = cli_completer
@@ -155,6 +158,7 @@ class Repl:
             std_in=False,
             data=self._data,
             retain_comments=self._retain_comments,
+            template_syntax_config=self._template_syntax_config,
         )
         return cursors
 

snowflake/cli/_plugins/stage/commands.py

@@ -48,7 +48,6 @@ from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -74,7 +73,7 @@ add_object_command_aliases(
     object_type=ObjectType.STAGE,
     name_argument=StageNameArgument,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all stages that begin with “my”',
+        help_example='`list --like "my%"` lists all stages that begin with "my"',
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
 )
@@ -98,7 +97,7 @@ def copy(
         show_default=False,
     ),
     destination_path: str = typer.Argument(
-        help="Target directory path for copy operation. Should be stage if source is local or local if source is stage.",
+        help="Target directory path for copy operation.",
         show_default=False,
     ),
     overwrite: bool = typer.Option(
@@ -117,19 +116,24 @@ def copy(
         default=False,
         help="Specifies whether Snowflake uses gzip to compress files during upload. Ignored when downloading.",
     ),
+    refresh: bool = typer.Option(
+        default=False,
+        help="Specifies whether ALTER STAGE {name} REFRESH should be executed after uploading.",
+    ),
     **options,
 ) -> CommandResult:
     """
-    Copies all files from target path to target directory. This works for both uploading
-    to and downloading files from the stage.
+    Copies all files from source path to target directory. This works for uploading
+    to and downloading files from the stage, and copying between named stages.
     """
     is_get = is_stage_path(source_path)
     is_put = is_stage_path(destination_path)
 
     if is_get and is_put:
-        raise click.ClickException(
-            "Both source and target path are remote. This operation is not supported."
+        cursor = StageManager().copy_files(
+            source_path=source_path, destination_path=destination_path
         )
+        return QueryResult(cursor)
     if not is_get and not is_put:
         raise click.ClickException(
             "Both source and target path are local. This operation is not supported."
@@ -149,6 +153,7 @@ def copy(
         parallel=parallel,
         overwrite=overwrite,
         auto_compress=auto_compress,
+        refresh=refresh,
     )
 
 
@@ -160,12 +165,19 @@ def stage_create(
         "--encryption",
         help="Type of encryption supported for all files stored on the stage.",
     ),
+    enable_directory: bool = typer.Option(
+        False,
+        "--enable-directory",
+        help="Specifies whether directory support is enabled for the stage.",
+    ),
     **options,
 ) -> CommandResult:
     """
     Creates a named stage if it does not already exist.
     """
-    cursor = StageManager().create(fqn=stage_name, encryption=encryption)
+    cursor = StageManager().create(
+        fqn=stage_name, encryption=encryption, enable_directory=enable_directory
+    )
     return SingleQueryResult(cursor)
 
 
@@ -206,7 +218,7 @@ def stage_diff(
         local_root=Path(folder_name),
         stage_path=StageManager.stage_path_parts_from_str(stage_name),  # noqa: SLF001
     )
-    if get_cli_context().output_format == OutputFormat.JSON:
+    if get_cli_context().output_format.is_json:
         return ObjectResult(diff.to_dict())
     else:
         print_diff_to_console(diff)
@@ -264,6 +276,7 @@ def _put(
     parallel: int,
     overwrite: bool,
     auto_compress: bool,
+    refresh: bool,
 ):
     if recursive and not source_path.is_file():
         cursor_generator = StageManager().put_recursive(
@@ -273,7 +286,7 @@ def _put(
             parallel=parallel,
             auto_compress=auto_compress,
         )
-        return CollectionResult(cursor_generator)
+        output = CollectionResult(cursor_generator)
     else:
         cursor = StageManager().put(
             local_path=source_path.resolve(),
@@ -282,4 +295,10 @@ def _put(
             parallel=parallel,
             auto_compress=auto_compress,
         )
-        return QueryResult(cursor)
+        output = QueryResult(cursor)
+
+    if refresh:
+        StageManager().refresh(
+            StageManager.stage_path_parts_from_str(destination_path).stage_name
+        )
+    return output

snowflake/cli/_plugins/stage/diff.py

@@ -239,6 +239,7 @@ def sync_local_diff_with_stage(
     deploy_root_path: Path,
     diff_result: DiffResult,
     stage_full_path: str,
+    force_overwrite: bool = False,
 ):
     """
     Syncs a given local directory's contents with a Snowflake stage, including removing old files, and re-uploading modified and new files.
@@ -267,6 +268,7 @@ def sync_local_diff_with_stage(
             deploy_root_path=deploy_root_path,
             stage_paths=diff_result.only_local,
             role=role,
+            overwrite=force_overwrite,
         )
     except Exception as err:
         # Could be ProgrammingError or IntegrityError from SnowflakeCursor

snowflake/cli/_plugins/stage/manager.py

@@ -32,7 +32,7 @@ from tempfile import TemporaryDirectory
 from textwrap import dedent
 from typing import Deque, Dict, Generator, List, Optional, Union
 
-from click import ClickException, UsageError
+from click import UsageError
 from snowflake.cli._plugins.snowpark.package_utils import parse_requirements
 from snowflake.cli.api.commands.common import (
     OnErrorType,
@@ -41,6 +41,7 @@ from snowflake.cli.api.commands.common import (
 from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import PYTHON_3_12
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, to_string_literal
 from snowflake.cli.api.secure_path import SecurePath
@@ -58,7 +59,10 @@ log = logging.getLogger(__name__)
 
 
 UNQUOTED_FILE_URI_REGEX = r"[\w/*?\-.=&{}$#[\]\"\\!@%^+:]+"
+AT_PREFIX = "@"
 USER_STAGE_PREFIX = "@~"
+SNOW_PREFIX = "snow://"
+
 EXECUTE_SUPPORTED_FILES_FORMATS = (
     ".sql",
     ".py",
@@ -68,6 +72,17 @@ EXECUTE_SUPPORTED_FILES_FORMATS = (
 OMIT_FIRST = slice(1, None)
 STAGE_PATH_REGEX = rf"(?P<prefix>(@|{re.escape('snow://')}))?(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})/?(?P<directory>([^/]*/?)*)?"
 
+# Define supported VSTAGE resource types
+VSTAGE_RESOURCE_TYPE_REGEX = r"[a-zA-Z0-9\-]+"
+VSTAGE_PATH_REGEX = (
+    rf"(?P<prefix>{re.escape(SNOW_PREFIX)})"
+    rf"(?P<resource_type>{VSTAGE_RESOURCE_TYPE_REGEX})/"
+    rf"(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?"
+    rf"(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?"
+    rf"(?P<name>{VALID_IDENTIFIER_REGEX})/?"
+    rf"(?P<directory>([^/]*/?)*)?"
+)
+
 
 class InternalStageEncryptionType(Enum):
     SNOWFLAKE_FULL = "SNOWFLAKE_FULL"
@@ -80,6 +95,7 @@ class StagePathParts:
     stage: str
     stage_name: str
     is_directory: bool
+    is_vstage: bool = False
 
     @classmethod
     def get_directory(cls, stage_path: str) -> str:
@@ -97,15 +113,9 @@ class StagePathParts:
     def schema(self) -> str | None:
         raise NotImplementedError
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        raise NotImplementedError
-
     def add_stage_prefix(self, file_path: str) -> str:
         raise NotImplementedError
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        raise NotImplementedError
-
     def get_full_stage_path(self, path: str):
         if prefix := FQN.from_stage_path(self.stage).prefix:
             return prefix + "." + path
@@ -113,7 +123,7 @@ class StagePathParts:
 
     def get_standard_stage_path(self) -> str:
         path = self.get_full_stage_path(self.path)
-        return f"@{path}{'/'if self.is_directory and not path.endswith('/') else ''}"
+        return f"{AT_PREFIX}{path}{'/'if self.is_directory and not path.endswith('/') else ''}"
 
     def get_standard_stage_directory_path(self) -> str:
         path = self.get_standard_stage_path()
@@ -121,17 +131,6 @@ class StagePathParts:
             return path + "/"
         return path
 
-    def strip_stage_prefix(self, path: str):
-        raise NotImplementedError
-
-
-def _strip_standard_stage_prefix(path: str) -> str:
-    """Removes '@' or 'snow://' prefix from given string"""
-    for prefix in ["@", "snow://"]:
-        if path.startswith(prefix):
-            path = path.removeprefix(prefix)
-    return path
-
 
 @dataclass
 class DefaultStagePathParts(StagePathParts):
@@ -149,10 +148,10 @@ class DefaultStagePathParts(StagePathParts):
     def __init__(self, stage_path: str):
         match = re.fullmatch(STAGE_PATH_REGEX, stage_path)
         if match is None:
-            raise ClickException("Invalid stage path")
+            raise CliError("Invalid stage path")
         self.directory = match.group("directory")
         self._schema = match.group("second_qualifier") or match.group("first_qualifier")
-        self._prefix = match.group("prefix") or "@"
+        self._prefix = match.group("prefix") or AT_PREFIX
         self.stage = stage_path.removesuffix(self.directory).rstrip("/")
 
         stage_name = FQN.from_stage(self.stage).name
@@ -180,24 +179,47 @@ class DefaultStagePathParts(StagePathParts):
     def schema(self) -> str | None:
         return self._schema
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        file_path = _strip_standard_stage_prefix(file_path)
-        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
-        return f"{self.stage}/{'/'.join(file_path_without_prefix)}"
-
-    def strip_stage_prefix(self, file_path: str) -> str:
-        file_path = _strip_standard_stage_prefix(file_path)
-        if file_path.startswith(self.stage_name):
-            return file_path[len(self.stage_name) :]
-        return file_path
-
     def add_stage_prefix(self, file_path: str) -> str:
         stage = self.stage.rstrip("/")
         return f"{stage}/{file_path.lstrip('/')}"
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[1 + stage_path_length : -1])
+
+@dataclass
+class VStagePathParts(StagePathParts):
+    def __init__(self, stage_path: str):
+        match = re.fullmatch(VSTAGE_PATH_REGEX, stage_path)
+        if match is None or not match.group("resource_type") or not match.group("name"):
+            raise CliError(f"Invalid vstage path: {stage_path}.")
+        self.resource_type = match.group("resource_type")
+        self.directory = match.group("directory")
+        self._schema = match.group("second_qualifier") or match.group("first_qualifier")
+        self._prefix = match.group("prefix")
+        self.stage = stage_path.removesuffix(self.directory).rstrip("/")
+        self.stage_name = self.stage.removeprefix(self._prefix)
+        self.is_directory = True if stage_path.endswith("/") else False
+        self.is_vstage = True
+
+    @property
+    def path(self) -> str:
+        return f"{self._prefix}{self.stage_name.rstrip('/')}/{self.directory}".rstrip(
+            "/"
+        )
+
+    @property
+    def full_path(self) -> str:
+        return f"{self._prefix}{self.stage_name.rstrip('/')}/{self.directory}".rstrip(
+            "/"
+        )
+
+    @property
+    def schema(self) -> str | None:
+        return self._schema
+
+    def add_stage_prefix(self, file_path: str) -> str:
+        return self.full_path
+
+    def get_standard_stage_path(self) -> str:
+        return self.full_path
 
 
 @dataclass
@@ -229,37 +251,29 @@ class UserStagePathParts(StagePathParts):
     def full_path(self) -> str:
         return f"{self.stage}/{self.directory}".rstrip("/")
 
-    def replace_stage_prefix(self, file_path: str) -> str:
-        if Path(file_path).parts[0] == self.stage_name:
-            return file_path
-        return f"{self.stage}/{file_path}"
-
     def add_stage_prefix(self, file_path: str) -> str:
         return f"{self.stage}/{file_path}"
 
-    def get_directory_from_file_path(self, file_path: str) -> List[str]:
-        stage_path_length = len(Path(self.directory).parts)
-        return list(Path(file_path).parts[stage_path_length:-1])
-
 
 class StageManager(SqlExecutionMixin):
     def __init__(self):
         super().__init__()
         self._python_exe_procedure = None
 
-    @staticmethod
-    def build_path(stage_path: str) -> StagePath:
+    def build_path(self, stage_path: Union[str, StagePath]) -> StagePath:
+        if isinstance(stage_path, StagePath):
+            return stage_path
         return StagePath.from_stage_str(stage_path)
 
     @staticmethod
     def get_standard_stage_prefix(name: str | FQN) -> str:
         if isinstance(name, FQN):
             name = name.identifier
-        # Handle embedded stages
-        if name.startswith("snow://") or name.startswith("@"):
+        # Handle vstages
+        if name.startswith(SNOW_PREFIX) or name.startswith(AT_PREFIX):
             return name
 
-        return f"@{name}"
+        return f"{AT_PREFIX}{name}"
 
     @staticmethod
     def get_stage_from_path(path: str):
@@ -275,7 +289,7 @@ class StageManager(SqlExecutionMixin):
             return name  # already quoted
 
         standard_name = StageManager.get_standard_stage_prefix(name)
-        if standard_name.startswith("@") and not re.fullmatch(
+        if standard_name.startswith(AT_PREFIX) and not re.fullmatch(
             r"@([\w./$])+", standard_name
         ):
             return to_string_literal(standard_name)
@@ -503,7 +517,7 @@ class StageManager(SqlExecutionMixin):
         destination_stage_path = StagePath.from_stage_str(destination_path)
 
         if destination_stage_path.is_user_stage():
-            raise ClickException(
+            raise CliError(
                 "Destination path cannot be a user stage. Please provide a named stage."
             )
 
@@ -534,11 +548,14 @@ class StageManager(SqlExecutionMixin):
         comment: Optional[str] = None,
         temporary: bool = False,
         encryption: InternalStageEncryptionType | None = None,
+        enable_directory: bool = False,
     ) -> SnowflakeCursor:
         temporary_str = "temporary " if temporary else ""
         query = f"create {temporary_str}stage if not exists {fqn.sql_identifier}"
         if encryption:
             query += f" encryption = (type = '{encryption.value}')"
+        if enable_directory:
+            query += f" directory = (enable = true)"
         if comment:
             query += f" comment='{comment}'"
         return self.execute_query(query)
@@ -572,7 +589,7 @@ class StageManager(SqlExecutionMixin):
 
         all_files_list = self._get_files_list_from_stage(stage_path.root_path())
         if not all_files_list:
-            raise ClickException(f"No files found on stage '{stage_path}'")
+            raise CliError(f"No files found on stage '{stage_path}'")
 
         all_files_with_stage_name_prefix = [
             stage_path_parts.get_directory(file) for file in all_files_list
@@ -584,7 +601,7 @@ class StageManager(SqlExecutionMixin):
         )
 
         if not filtered_file_list:
-            raise ClickException(f"No files matched pattern '{stage_path}'")
+            raise CliError(f"No files matched pattern '{stage_path}'")
 
         # sort filtered files in alphabetical order with directories at the end
         sorted_file_path_list = sorted(
@@ -678,7 +695,7 @@ class StageManager(SqlExecutionMixin):
             if filtered_files:
                 return filtered_files
             else:
-                raise ClickException(
+                raise CliError(
                     f"Invalid file extension, only {', '.join(EXECUTE_SUPPORTED_FILES_FORMATS)} files are allowed."
                 )
         # Filter with fnmatch if contains `*` or `?`
@@ -750,8 +767,15 @@ class StageManager(SqlExecutionMixin):
         stage_path = StageManager.get_standard_stage_prefix(stage_path)
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)
+        elif stage_path.startswith(SNOW_PREFIX):
+            return VStagePathParts(stage_path)
         return DefaultStagePathParts(stage_path)
 
+    def refresh(self, stage_name):
+        sql = f"ALTER STAGE {stage_name} REFRESH"
+        log.info("Refreshing stage %s", stage_name)
+        return self.execute_query(sql)
+
     def _check_for_requirements_file(self, stage_path: StagePath) -> List[str]:
         """Looks for requirements.txt file on stage."""
         current_dir = stage_path.parent if stage_path.is_file() else stage_path
@@ -800,7 +824,7 @@ class StageManager(SqlExecutionMixin):
     def _bootstrap_snowpark_execution_environment(self, stage_path: StagePath):
         """Prepares Snowpark session for executing Python code remotely."""
         if sys.version_info >= PYTHON_3_12:
-            raise ClickException(
+            raise CliError(
                 f"Executing Python files is not supported in Python >= 3.12. Current version: {sys.version}"
             )