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

snowflake/cli/__about__.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from enum import Enum, unique
 
-VERSION = "3.11.0"
+VERSION = "3.12.0"
 
 
 @unique

snowflake/cli/_app/cli_app.py

@@ -256,7 +256,6 @@ class CliAppFactory:
                 "--commands-registration",
                 help="Commands registration",
                 hidden=True,
-                is_eager=True,
                 callback=self._commands_registration_callback(),
             ),
         ) -> None:

snowflake/cli/_app/printing.py

@@ -22,7 +22,7 @@ from decimal import Decimal
 from json import JSONEncoder
 from pathlib import Path
 from textwrap import indent
-from typing import TextIO
+from typing import Any, Dict, TextIO
 
 from rich import box, get_console
 from rich import print as rich_print
@@ -61,13 +61,114 @@ class CustomJSONEncoder(JSONEncoder):
             return list(o.result)
         if isinstance(o, (date, datetime, time)):
             return o.isoformat()
-        if isinstance(o, (Path, Decimal)):
+        if isinstance(o, Path):
+            return o.as_posix()
+        if isinstance(o, Decimal):
             return str(o)
         if isinstance(o, bytearray):
             return o.hex()
         return super().default(o)
 
 
+class StreamingJSONEncoder(JSONEncoder):
+    """Streaming JSON encoder that doesn't materialize generators into lists"""
+
+    def default(self, o):
+        if isinstance(o, str):
+            return sanitize_for_terminal(o)
+        if isinstance(o, (ObjectResult, MessageResult)):
+            return o.result
+        if isinstance(o, (CollectionResult, MultipleResults)):
+            raise TypeError(
+                f"CollectionResult should be handled by streaming functions, not encoder"
+            )
+        if isinstance(o, (date, datetime, time)):
+            return o.isoformat()
+        if isinstance(o, Path):
+            return o.as_posix()
+        if isinstance(o, Decimal):
+            return str(o)
+        if isinstance(o, bytearray):
+            return o.hex()
+        return super().default(o)
+
+
+def _print_json_item_with_array_indentation(item: Any, indent: int):
+    """Print a JSON item with proper indentation for array context"""
+    if indent:
+        indented_output = json.dumps(item, cls=StreamingJSONEncoder, indent=indent)
+        indented_lines = indented_output.split("\n")
+        for i, line in enumerate(indented_lines):
+            if i == 0:
+                print(" " * indent + line, end="")
+            else:
+                print("\n" + " " * indent + line, end="")
+    else:
+        json.dump(item, sys.stdout, cls=StreamingJSONEncoder, separators=(",", ":"))
+
+
+def _stream_collection_as_json(result: CollectionResult, indent: int = 4):
+    """Stream a CollectionResult as a JSON array without loading all data into memory"""
+    items = iter(result.result)
+    try:
+        first_item = next(items)
+    except StopIteration:
+        print("[]", end="")
+        return
+
+    print("[")
+
+    _print_json_item_with_array_indentation(first_item, indent)
+
+    for item in items:
+        print(",")
+        _print_json_item_with_array_indentation(item, indent)
+
+    print("\n]", end="")
+
+
+def _stream_collection_as_csv(result: CollectionResult):
+    """Stream a CollectionResult as CSV without loading all data into memory"""
+    items = iter(result.result)
+    try:
+        first_item = next(items)
+    except StopIteration:
+        return
+
+    fieldnames = list(first_item.keys())
+    if not isinstance(first_item, dict):
+        raise TypeError("CSV output requires dictionary items")
+
+    writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames, lineterminator="\n")
+    writer.writeheader()
+    _write_csv_row(writer, first_item)
+
+    for item in items:
+        _write_csv_row(writer, item)
+
+
+def _write_csv_row(writer: csv.DictWriter, row_data: Dict[str, Any]):
+    """Write a single CSV row, handling special data types"""
+    processed_row = {}
+    for key, value in row_data.items():
+        if isinstance(value, str):
+            processed_row[key] = sanitize_for_terminal(value)
+        elif isinstance(value, (date, datetime, time)):
+            processed_row[key] = value.isoformat()
+        elif isinstance(value, Path):
+            processed_row[key] = value.as_posix()
+        elif isinstance(value, Decimal):
+            processed_row[key] = str(value)
+        elif isinstance(value, bytearray):
+            processed_row[key] = value.hex()
+        elif value is None:
+            processed_row[key] = ""
+        else:
+            processed_row[key] = str(value)
+
+    writer.writerow(processed_row)
+
+
 def _get_format_type() -> OutputFormat:
     output_format = get_cli_context().output_format
     if output_format:
@@ -110,12 +211,13 @@ def is_structured_format(output_format):
 def print_structured(
     result: CommandResult, output_format: OutputFormat = OutputFormat.JSON
 ):
-    """Handles outputs like json, yml and other structured and parsable formats."""
+    """Handles outputs like json, csv and other structured and parsable formats with streaming."""
     printed_end_line = False
+
     if isinstance(result, MultipleResults):
         if output_format == OutputFormat.CSV:
             for command_result in result.result:
-                _print_csv_result(command_result)
+                _print_csv_result_streaming(command_result)
                 print(flush=True)
             printed_end_line = True
         else:
@@ -125,35 +227,67 @@ def print_structured(
         # instead of joining all the values into a JSON array or CSV entry set
         for r in result.result:
             if output_format == OutputFormat.CSV:
-                _print_csv_result(r.result)
+                _print_csv_result_streaming(r)
             else:
-                json.dump(r, sys.stdout, cls=CustomJSONEncoder)
+                json.dump(r, sys.stdout, cls=StreamingJSONEncoder)
             print(flush=True)
             printed_end_line = True
     else:
         if output_format == OutputFormat.CSV:
-            _print_csv_result(result)
+            _print_csv_result_streaming(result)
             printed_end_line = True
         else:
-            json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
+            _print_json_result_streaming(result)
+
     # Adds empty line at the end
     if not printed_end_line:
         print(flush=True)
 
 
-def _print_csv_result(result: CommandResult):
-    data = json.loads(json.dumps(result, cls=CustomJSONEncoder))
+def _print_json_result_streaming(result: CommandResult):
+    """Print a single CommandResult as JSON with streaming support"""
+    if isinstance(result, CollectionResult):
+        _stream_collection_as_json(result, indent=4)
+    elif isinstance(result, (ObjectResult, MessageResult)):
+        json.dump(result, sys.stdout, cls=StreamingJSONEncoder, indent=4)
+    else:
+        json.dump(result, sys.stdout, cls=StreamingJSONEncoder, indent=4)
+
+
+def _print_object_result_as_csv(result: ObjectResult):
+    """Print an ObjectResult as a single-row CSV.
+
+    Converts the object's key-value pairs into a CSV with headers
+    from the keys and a single data row from the values.
+    """
+    data = result.result
     if isinstance(data, dict):
-        writer = csv.DictWriter(sys.stdout, [*data], lineterminator="\n")
-        writer.writeheader()
-        writer.writerow(data)
-    elif isinstance(data, list):
-        if not data:
-            return
-        writer = csv.DictWriter(sys.stdout, [*data[0]], lineterminator="\n")
+        writer = csv.DictWriter(
+            sys.stdout, fieldnames=list(data.keys()), lineterminator="\n"
+        )
         writer.writeheader()
-        for entry in data:
-            writer.writerow(entry)
+        _write_csv_row(writer, data)
+
+
+def _print_message_result_as_csv(result: MessageResult):
+    """Print a MessageResult as CSV with a single 'message' column.
+
+    Creates a simple CSV structure with one column named 'message'
+    containing the sanitized message text.
+    """
+    writer = csv.DictWriter(sys.stdout, fieldnames=["message"], lineterminator="\n")
+    writer.writeheader()
+    writer.writerow({"message": sanitize_for_terminal(result.message)})
+
+
+def _print_csv_result_streaming(result: CommandResult):
+    """Print a single CommandResult as CSV with streaming support"""
+    if isinstance(result, CollectionResult):
+        _stream_collection_as_csv(result)
+    elif isinstance(result, ObjectResult):
+        _print_object_result_as_csv(result)
+    elif isinstance(result, MessageResult):
+        _print_message_result_as_csv(result)
 
 
 def _stream_json(result):

snowflake/cli/_plugins/dbt/commands.py

@@ -19,7 +19,6 @@ from typing import Optional
 
 import typer
 from click import types
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from snowflake.cli._plugins.dbt.constants import (
     DBT_COMMANDS,
     OUTPUT_COLUMN_NAME,
@@ -31,7 +30,9 @@ from snowflake.cli._plugins.object.command_aliases import add_object_command_ali
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli.api.commands.decorators import global_options_with_connection
 from snowflake.cli.api.commands.flags import identifier_argument, like_option
+from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
@@ -59,6 +60,16 @@ DBTNameArgument = identifier_argument(sf_object="DBT Project", example="my_pipel
 DBTNameOrCommandArgument = identifier_argument(
     sf_object="DBT Project", example="my_pipeline", click_type=types.StringParamType()
 )
+DefaultTargetOption = OverrideableOption(
+    None,
+    "--default-target",
+    mutually_exclusive=["unset_default_target"],
+)
+UnsetDefaultTargetOption = OverrideableOption(
+    False,
+    "--unset-default-target",
+    mutually_exclusive=["default_target"],
+)
 
 add_object_command_aliases(
     app=app,
@@ -92,6 +103,21 @@ def deploy_dbt(
         False,
         help="Overwrites conflicting files in the project, if any.",
     ),
+    default_target: Optional[str] = DefaultTargetOption(
+        help="Default target for the dbt project. Mutually exclusive with --unset-default-target.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
+    unset_default_target: Optional[bool] = UnsetDefaultTargetOption(
+        help="Unset the default target for the dbt project. Mutually exclusive with --default-target.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
+    external_access_integrations: Optional[list[str]] = typer.Option(
+        None,
+        "--external-access-integration",
+        show_default=False,
+        help="External access integration to be used by the dbt object.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -99,6 +125,11 @@ def deploy_dbt(
     provided; or create a new one if it doesn't exist; or update files and
     create a new version if it exists.
     """
+    if FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled():
+        default_target = None
+        unset_default_target = False
+        external_access_integrations = None
+
     project_path = SecurePath(source) if source is not None else SecurePath.cwd()
     profiles_dir_path = SecurePath(profiles_dir) if profiles_dir else project_path
     return QueryResult(
@@ -107,6 +138,9 @@ def deploy_dbt(
             project_path.resolve(),
             profiles_dir_path.resolve(),
             force=force,
+            default_target=default_target,
+            unset_default_target=unset_default_target,
+            external_access_integrations=external_access_integrations,
         )
     )
 
@@ -161,13 +195,8 @@ for cmd in DBT_COMMANDS:
                 f"Command submitted. You can check the result with `snow sql -q \"select execution_status from table(information_schema.query_history_by_user()) where query_id in ('{result.sfqid}');\"`"
             )
 
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            transient=True,
-        ) as progress:
-            progress.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
-
+        with cli_console.spinner() as spinner:
+            spinner.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
             result = dbt_manager.execute(*execute_args)
 
             try:

snowflake/cli/_plugins/dbt/manager.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from collections import defaultdict
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import List, Optional, TypedDict
 
 import yaml
 from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
@@ -29,6 +30,11 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.errors import ProgrammingError
+
+
+class DBTObjectEditableAttributes(TypedDict):
+    default_target: Optional[str]
 
 
 class DBTManager(SqlExecutionMixin):
@@ -42,12 +48,44 @@ class DBTManager(SqlExecutionMixin):
             object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
         )
 
+    @staticmethod
+    def describe(name: FQN) -> SnowflakeCursor:
+        return ObjectManager().describe(
+            object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
+        )
+
+    @staticmethod
+    def get_dbt_object_attributes(name: FQN) -> Optional[DBTObjectEditableAttributes]:
+        """Get editable attributes of an existing DBT project, or None if it doesn't exist."""
+        try:
+            cursor = DBTManager().describe(name)
+        except ProgrammingError as exc:
+            if "DBT PROJECT" in exc.msg and "does not exist" in exc.msg:
+                return None
+            raise exc
+
+        rows = list(cursor)
+        if not rows:
+            return None
+
+        row = rows[0]
+        # Convert row to dict using column names
+        columns = [desc[0] for desc in cursor.description]
+        row_dict = dict(zip(columns, row))
+
+        return DBTObjectEditableAttributes(
+            default_target=row_dict.get("default_target")
+        )
+
     def deploy(
         self,
         fqn: FQN,
         path: SecurePath,
         profiles_path: SecurePath,
         force: bool,
+        default_target: Optional[str] = None,
+        unset_default_target: bool = False,
+        external_access_integrations: Optional[List[str]] = None,
     ) -> SnowflakeCursor:
         dbt_project_path = path / "dbt_project.yml"
         if not dbt_project_path.exists():
@@ -62,13 +100,13 @@ class DBTManager(SqlExecutionMixin):
             except KeyError:
                 raise CliError("`profile` is not defined in dbt_project.yml")
 
-        self._validate_profiles(profiles_path, profile)
+        self._validate_profiles(profiles_path, profile, default_target)
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            stage_fqn = FQN.from_string(f"dbt_{fqn.name}_stage").using_context()
-            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
+            stage_fqn = FQN.from_resource(ObjectType.DBT_PROJECT, fqn, "STAGE")
             stage_manager.create(stage_fqn, temporary=True)
+            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
 
         with cli_console.phase("Copying project files to stage"):
             with TemporaryDirectory() as tmp:
@@ -86,22 +124,109 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating DBT project"):
             if force is True:
-                query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
-            elif self.exists(name=fqn):
-                query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+                return self._deploy_create_or_replace(
+                    fqn, stage_name, default_target, external_access_integrations
+                )
             else:
-                query = f"CREATE DBT PROJECT {fqn}"
-            query += f"\nFROM {stage_name}"
-            return self.execute_query(query)
+                dbt_object_attributes = self.get_dbt_object_attributes(fqn)
+                if dbt_object_attributes is not None:
+                    return self._deploy_alter(
+                        fqn,
+                        stage_name,
+                        dbt_object_attributes,
+                        default_target,
+                        unset_default_target,
+                        external_access_integrations,
+                    )
+                else:
+                    return self._deploy_create(
+                        fqn, stage_name, default_target, external_access_integrations
+                    )
+
+    def _deploy_alter(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        dbt_object_attributes: DBTObjectEditableAttributes,
+        default_target: Optional[str],
+        unset_default_target: bool,
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+        query += f"\nFROM {stage_name}"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        result = self.execute_query(query)
+        current_default_target = dbt_object_attributes.get("default_target")
+        if unset_default_target and current_default_target is not None:
+            unset_query = f"ALTER DBT PROJECT {fqn} UNSET DEFAULT_TARGET"
+            self.execute_query(unset_query)
+        elif default_target and (
+            current_default_target is None
+            or current_default_target.lower() != default_target.lower()
+        ):
+            set_default_query = (
+                f"ALTER DBT PROJECT {fqn} SET DEFAULT_TARGET='{default_target}'"
+            )
+            self.execute_query(set_default_query)
+        return result
+
+    def _deploy_create(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        # Project doesn't exist - create new one
+        query = f"CREATE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        return self.execute_query(query)
+
+    @staticmethod
+    def _handle_external_access_integrations_query(
+        query: str, external_access_integrations: Optional[List[str]]
+    ) -> str:
+        if external_access_integrations:
+            integrations_str = ", ".join(external_access_integrations)
+            query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ({integrations_str})"
+        return query
+
+    def _deploy_create_or_replace(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        return self.execute_query(query)
 
     @staticmethod
-    def _validate_profiles(profiles_path: SecurePath, target_profile: str) -> None:
+    def _validate_profiles(
+        profiles_path: SecurePath,
+        target_profile: str,
+        default_target: str | None = None,
+    ) -> None:
         """
         Validates that:
          * profiles.yml exists
          * contain profile specified in dbt_project.yml
          * no other profiles are defined there
          * does not contain any confidential data like passwords
+         * default_target (if specified) exists in the profile's outputs
         """
         profiles_file = profiles_path / PROFILES_FILENAME
         if not profiles_file.exists():
@@ -152,6 +277,15 @@ class DBTManager(SqlExecutionMixin):
                     f"Value for type field is invalid. Should be set to `snowflake` in target {target_name}"
                 )
 
+        if default_target is not None:
+            available_targets = set(profiles[target_profile]["outputs"].keys())
+            if default_target not in available_targets:
+                available_targets_str = ", ".join(sorted(available_targets))
+                errors["default_target"].append(
+                    f"Default target '{default_target}' is not defined in profile '{target_profile}'. "
+                    f"Available targets: {available_targets_str}"
+                )
+
         if errors:
             message = f"Found following errors in {PROFILES_FILENAME}. Please fix them before proceeding:"
             for target, issues in errors.items():