snowflake-cli-labs 2.3.0rc0__tar.gz → 2.3.1__tar.gz

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli-labs
-Version: 2.3.0rc0
+Version: 2.3.1
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/RELEASE-NOTES.md

@@ -1,4 +1,4 @@
-# Unreleased version
+# v2.3.1
 ## Backward incompatibility
 
 ## Deprecations
@@ -6,7 +6,8 @@
 ## New additions
 
 ## Fixes and improvements
-
+* Improved support for quoted identifiers.
+* Fixed bugs in source artifact mapping logic for native applications
 
 # v2.3.0
 
@@ -15,9 +16,8 @@
 ## Deprecations
 
 ## New additions
-* `snow sql` command supports now client-side templating of queries
 * New `snow sql` functionality:
-  * `-D/--data` allows variable substitutions in a SQL input (client-side query templating)
+  * `-D/--variable` allows variable substitutions in a SQL input (client-side query templating)
 * New `snow app deploy` functionality:
   * Passing files and directories as arguments syncs these only: `snow app deploy some-file some-dir`.
   * `--recursive` syncs all files and subdirectories recursively.

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/src/snowflake/cli/__about__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-VERSION = "2.3.0rc0"
+VERSION = "2.3.1"

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/src/snowflake/cli/plugins/nativeapp/constants.py

@@ -7,6 +7,7 @@ NAME_COL = "name"
 COMMENT_COL = "comment"
 OWNER_COL = "owner"
 VERSION_COL = "version"
+PATCH_COL = "patch"
 
 INTERNAL_DISTRIBUTION = "internal"
 EXTERNAL_DISTRIBUTION = "external"

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/src/snowflake/cli/plugins/nativeapp/run_processor.py

@@ -7,10 +7,16 @@ from click import UsageError
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
+from snowflake.cli.api.project.util import (
+    identifier_to_show_like_pattern,
+    unquote_identifier,
+)
+from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
     LOOSE_FILES_MAGIC_VERSION,
+    PATCH_COL,
     SPECIAL_COMMENT,
     VERSION_COL,
 )
@@ -28,7 +34,7 @@ from snowflake.cli.plugins.nativeapp.policy import PolicyBase
 from snowflake.cli.plugins.stage.diff import DiffResult
 from snowflake.cli.plugins.stage.manager import StageManager
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 UPGRADE_RESTRICTION_CODES = {93044, 93055, 93045, 93046}
 
@@ -134,24 +140,34 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
 
     def get_existing_version_info(self, version: str) -> Optional[dict]:
         """
-        Get an existing version, if defined, by the same name in an application package.
-        It executes a 'show versions like ... in application package' query and returns the result as single row, if one exists.
+        Get the latest patch on an existing version by name in the application package.
+        Executes 'show versions like ... in application package' query and returns
+        the latest patch in the version as a single row, if one exists. Otherwise,
+        returns None.
         """
         with self.use_role(self.package_role):
             try:
-                version_obj = self.show_specific_object(
-                    "versions",
-                    version,
-                    name_col=VERSION_COL,
-                    in_clause=f"in application package {self.package_name}",
+                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {self.package_name}"
+                cursor = self._execute_query(query, cursor_class=DictCursor)
+
+                if cursor.rowcount is None:
+                    raise SnowflakeSQLExecutionError(query)
+
+                matching_rows = find_all_rows(
+                    cursor, lambda row: row[VERSION_COL] == unquote_identifier(version)
                 )
+
+                if not matching_rows:
+                    return None
+
+                return max(matching_rows, key=lambda row: row[PATCH_COL])
+
             except ProgrammingError as err:
                 if err.msg.__contains__("does not exist or not authorized"):
                     raise ApplicationPackageDoesNotExistError(self.package_name)
                 else:
                     generic_sql_error_handler(err=err, role=self.package_role)
-
-            return version_obj
+                    return None
 
     def drop_application_before_upgrade(self, policy: PolicyBase, is_interactive: bool):
         """

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/src/snowflake/cli/plugins/sql/commands.py

@@ -45,7 +45,7 @@ def execute_sql(
     ),
     data_override: List[str] = typer.Option(
         None,
-        "--data",
+        "--variable",
         "-D",
         help="String in format of key=value. If provided the SQL content will "
         "be treated as template and rendered using provided data.",

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/tests/__snapshots__/test_help_messages.ambr

@@ -5083,7 +5083,7 @@
   │ --filename  -f      FILE  File to execute. [default: None]                   │
   │ --stdin     -i            Read the query from standard input. Use it when    │
   │                           piping input to this command.                      │
-  │ --data      -D      TEXT  String in format of key=value. If provided the SQL │
+  │ --variable  -D      TEXT  String in format of key=value. If provided the SQL │
   │                           content will be treated as template and rendered   │
   │                           using provided data.                               │
   │                           [default: None]                                    │

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/tests/nativeapp/test_run_processor.py

@@ -1242,6 +1242,7 @@ def test_get_existing_version_info(mock_execute, temp_dir, mock_cursor):
                             "comment": "some comment",
                             "owner": "PACKAGE_ROLE",
                             "version": version,
+                            "patch": 0,
                         }
                     ],
                     [],

snowflake_cli_labs-2.3.1/tests_integration/nativeapp/test_version.py

@@ -0,0 +1,218 @@
+import uuid
+
+from snowflake.cli.api.project.util import generate_user_env
+
+from tests.project.fixtures import *
+from tests_integration.test_utils import (
+    contains_row_with,
+    not_contains_row_with,
+    row_from_snowflake_session,
+    pushd,
+)
+
+USER_NAME = f"user_{uuid.uuid4().hex}"
+TEST_ENV = generate_user_env(USER_NAME)
+
+
+# Tests a simple flow of an existing project, executing snow app version create, drop and teardown, all with distribution=internal
+@pytest.mark.integration
+@pytest.mark.parametrize("project_definition_files", ["integration"], indirect=True)
+def test_nativeapp_version_create_and_drop(
+    runner,
+    snowflake_session,
+    project_definition_files: List[Path],
+):
+    project_name = "integration"
+    project_dir = project_definition_files[0].parent
+    with pushd(project_dir):
+        result_create = runner.invoke_with_connection_json(
+            ["app", "version", "create", "v1", "--force", "--skip-git-check"],
+            env=TEST_ENV,
+        )
+        assert result_create.exit_code == 0
+
+        try:
+            # package exist
+            package_name = f"{project_name}_pkg_{USER_NAME}".upper()
+            assert contains_row_with(
+                row_from_snowflake_session(
+                    snowflake_session.execute_string(
+                        f"show application packages like '{package_name}'",
+                    )
+                ),
+                dict(name=package_name),
+            )
+
+            # app package contains version v1
+            expect = snowflake_session.execute_string(
+                f"show versions in application package {package_name}"
+            )
+            actual = runner.invoke_with_connection_json(
+                ["app", "version", "list"], env=TEST_ENV
+            )
+            assert actual.json == row_from_snowflake_session(expect)
+
+            result_drop = runner.invoke_with_connection_json(
+                ["app", "version", "drop", "v1", "--force"],
+                env=TEST_ENV,
+            )
+            assert result_drop.exit_code == 0
+            actual = runner.invoke_with_connection_json(
+                ["app", "version", "list"], env=TEST_ENV
+            )
+            assert len(actual.json) == 0
+
+            # make sure we always delete the package
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0
+
+            expect = snowflake_session.execute_string(
+                f"show application packages like '{package_name}'"
+            )
+            assert not_contains_row_with(
+                row_from_snowflake_session(expect), {"name": package_name}
+            )
+
+        finally:
+            # teardown is idempotent, so we can execute it again with no ill effects
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown", "--force"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0
+
+
+# Tests upgrading an app from an existing loose files installation to versioned installation.
+@pytest.mark.integration
+@pytest.mark.parametrize("project_definition_files", ["integration"], indirect=True)
+def test_nativeapp_upgrade(
+    runner,
+    snowflake_session,
+    project_definition_files: List[Path],
+):
+    project_name = "integration"
+    project_dir = project_definition_files[0].parent
+    with pushd(project_dir):
+        runner.invoke_with_connection_json(
+            ["app", "run"],
+            env=TEST_ENV,
+        )
+        runner.invoke_with_connection_json(
+            ["app", "version", "create", "v1", "--force", "--skip-git-check"],
+            env=TEST_ENV,
+        )
+
+        try:
+            # package exist
+            package_name = f"{project_name}_pkg_{USER_NAME}".upper()
+            app_name = f"{project_name}_{USER_NAME}".upper()
+            # app package contains version v1
+            expect = snowflake_session.execute_string(
+                f"show versions in application package {package_name}"
+            )
+            actual = runner.invoke_with_connection_json(
+                ["app", "version", "list"], env=TEST_ENV
+            )
+            assert actual.json == row_from_snowflake_session(expect)
+
+            runner.invoke_with_connection_json(
+                ["app", "run", "--version", "v1", "--force"], env=TEST_ENV
+            )
+
+            expect = row_from_snowflake_session(
+                snowflake_session.execute_string(f"desc application {app_name}")
+            )
+            assert contains_row_with(expect, {"property": "name", "value": app_name})
+            assert contains_row_with(expect, {"property": "version", "value": "V1"})
+            assert contains_row_with(expect, {"property": "patch", "value": "0"})
+
+            runner.invoke_with_connection_json(
+                ["app", "version", "drop", "v1", "--force"],
+                env=TEST_ENV,
+            )
+
+            # make sure we always delete the package
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0
+
+        finally:
+            # teardown is idempotent, so we can execute it again with no ill effects
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown", "--force"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0
+
+
+# Make sure we can create 3+ patches on the same version
+@pytest.mark.integration
+@pytest.mark.parametrize("project_definition_files", ["integration"], indirect=True)
+def test_nativeapp_version_create_3_patches(
+    runner,
+    snowflake_session,
+    project_definition_files: List[Path],
+):
+    project_name = "integration"
+    project_dir = project_definition_files[0].parent
+    with pushd(project_dir):
+        try:
+            package_name = f"{project_name}_pkg_{USER_NAME}".upper()
+
+            # create three patches (deploys too)
+            for _ in range(3):
+                result = runner.invoke_with_connection_json(
+                    ["app", "version", "create", "v1", "--force", "--skip-git-check"],
+                    env=TEST_ENV,
+                )
+                assert result.exit_code == 0
+
+            # app package contains 3 patches for version v1
+            expect = row_from_snowflake_session(
+                snowflake_session.execute_string(
+                    f"show versions in application package {package_name}"
+                )
+            )
+            assert contains_row_with(expect, {"version": "V1", "patch": 0})
+            assert contains_row_with(expect, {"version": "V1", "patch": 1})
+            assert contains_row_with(expect, {"version": "V1", "patch": 2})
+
+            # drop the version
+            result_drop = runner.invoke_with_connection_json(
+                ["app", "version", "drop", "v1", "--force"],
+                env=TEST_ENV,
+            )
+            assert result_drop.exit_code == 0
+
+            # ensure there are no versions now
+            actual = runner.invoke_with_connection_json(
+                ["app", "version", "list"], env=TEST_ENV
+            )
+            assert len(actual.json) == 0
+
+            # make sure we always delete the package
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0
+
+            expect = snowflake_session.execute_string(
+                f"show application packages like '{package_name}'"
+            )
+            assert not_contains_row_with(
+                row_from_snowflake_session(expect), {"name": package_name}
+            )
+
+        finally:
+            # teardown is idempotent, so we can execute it again with no ill effects
+            result = runner.invoke_with_connection_json(
+                ["app", "teardown", "--force"],
+                env=TEST_ENV,
+            )
+            assert result.exit_code == 0

{snowflake_cli_labs-2.3.0rc0 → snowflake_cli_labs-2.3.1}/tests_integration/test_utils.py

@@ -1,4 +1,7 @@
 import datetime
+import os
+from contextlib import contextmanager
+from pathlib import Path
 from typing import Any, Dict, List
 
 from snowflake.connector.cursor import SnowflakeCursor
@@ -51,3 +54,13 @@ def not_contains_row_with(rows: List[Dict[str, Any]], values: Dict[str, Any]) ->
         if row.items() >= values_items:
             return False
     return True
+
+
+@contextmanager
+def pushd(directory: Path):
+    cwd = os.getcwd()
+    os.chdir(directory)
+    try:
+        yield directory
+    finally:
+        os.chdir(cwd)