sqlmesh 0.227.2.dev11__tar.gz → 0.227.2.dev13__tar.gz

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.227.2.dev11
+Version: 0.227.2.dev13
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.227.2.dev11'
-__version_tuple__ = version_tuple = (0, 227, 2, 'dev11')
+__version__ = version = '0.227.2.dev13'
+__version_tuple__ = version_tuple = (0, 227, 2, 'dev13')
 
-__commit_id__ = commit_id = 'gf9fb3cdab'
+__commit_id__ = commit_id = 'g31bc00d54'

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/core/config/connection.py

@@ -238,6 +238,7 @@ class DuckDBAttachOptions(BaseConfig):
     data_path: t.Optional[str] = None
     encrypted: bool = False
     data_inlining_row_limit: t.Optional[int] = None
+    metadata_schema: t.Optional[str] = None
 
     def to_sql(self, alias: str) -> str:
         options = []
@@ -259,6 +260,8 @@ class DuckDBAttachOptions(BaseConfig):
                 options.append("ENCRYPTED")
             if self.data_inlining_row_limit is not None:
                 options.append(f"DATA_INLINING_ROW_LIMIT {self.data_inlining_row_limit}")
+            if self.metadata_schema is not None:
+                options.append(f"METADATA_SCHEMA '{self.metadata_schema}'")
 
         options_sql = f" ({', '.join(options)})" if options else ""
         alias_sql = ""

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/core/context.py

@@ -147,8 +147,8 @@ if t.TYPE_CHECKING:
     from typing_extensions import Literal
 
     from sqlmesh.core.engine_adapter._typing import (
-        DF,
         BigframeSession,
+        DF,
         PySparkDataFrame,
         PySparkSession,
         SnowparkSession,
@@ -403,6 +403,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         self._model_test_metadata_path_index: t.Dict[Path, t.List[ModelTestMetadata]] = {}
         self._model_test_metadata_fully_qualified_name_index: t.Dict[str, ModelTestMetadata] = {}
         self._models_with_tests: t.Set[str] = set()
+
         self._macros: UniqueKeyDict[str, ExecutableOrMacro] = UniqueKeyDict("macros")
         self._metrics: UniqueKeyDict[str, Metric] = UniqueKeyDict("metrics")
         self._jinja_macros = JinjaMacroRegistry()
@@ -656,6 +657,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             self._requirements.update(project.requirements)
             self._excluded_requirements.update(project.excluded_requirements)
             self._environment_statements.extend(project.environment_statements)
+
             self._model_test_metadata.extend(project.model_test_metadata)
             for metadata in project.model_test_metadata:
                 if metadata.path not in self._model_test_metadata_path_index:
@@ -2243,9 +2245,7 @@ class GenericContext(BaseContext, t.Generic[C]):
 
             pd.set_option("display.max_columns", None)
 
-        test_meta = self._select_tests(
-            test_meta=self._model_test_metadata, tests=tests, patterns=match_patterns
-        )
+        test_meta = self.select_tests(tests=tests, patterns=match_patterns)
 
         result = run_tests(
             model_test_metadata=test_meta,
@@ -2807,33 +2807,6 @@ class GenericContext(BaseContext, t.Generic[C]):
             raise SQLMeshError(f"Gateway '{gateway}' not found in the available engine adapters.")
         return self.engine_adapter
 
-    def _select_tests(
-        self,
-        test_meta: t.List[ModelTestMetadata],
-        tests: t.Optional[t.List[str]] = None,
-        patterns: t.Optional[t.List[str]] = None,
-    ) -> t.List[ModelTestMetadata]:
-        """Filter pre-loaded test metadata based on tests and patterns."""
-
-        if tests:
-            filtered_tests = []
-            for test in tests:
-                if "::" in test:
-                    if test in self._model_test_metadata_fully_qualified_name_index:
-                        filtered_tests.append(
-                            self._model_test_metadata_fully_qualified_name_index[test]
-                        )
-                else:
-                    test_path = Path(test)
-                    if test_path in self._model_test_metadata_path_index:
-                        filtered_tests.extend(self._model_test_metadata_path_index[test_path])
-            test_meta = filtered_tests
-
-        if patterns:
-            test_meta = filter_tests_by_patterns(test_meta, patterns)
-
-        return test_meta
-
     def _snapshots(
         self, models_override: t.Optional[UniqueKeyDict[str, Model]] = None
     ) -> t.Dict[str, Snapshot]:
@@ -3245,18 +3218,34 @@ class GenericContext(BaseContext, t.Generic[C]):
 
         return all_violations
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
+    def select_tests(
+        self,
+        tests: t.Optional[t.List[str]] = None,
+        patterns: t.Optional[t.List[str]] = None,
     ) -> t.List[ModelTestMetadata]:
-        # If a set of specific test path(s) are provided, we can use a single loader
-        # since it's not required to walk every tests/ folder in each repo
-        loaders = [self._loaders[0]] if tests else self._loaders
+        """Filter pre-loaded test metadata based on tests and patterns."""
+
+        test_meta = self._model_test_metadata
+
+        if tests:
+            filtered_tests = []
+            for test in tests:
+                if "::" in test:
+                    if test in self._model_test_metadata_fully_qualified_name_index:
+                        filtered_tests.append(
+                            self._model_test_metadata_fully_qualified_name_index[test]
+                        )
+                else:
+                    test_path = Path(test)
+                    if test_path in self._model_test_metadata_path_index:
+                        filtered_tests.extend(self._model_test_metadata_path_index[test_path])
+
+            test_meta = filtered_tests
 
-        model_tests = []
-        for loader in loaders:
-            model_tests.extend(loader.load_model_tests(tests=tests, patterns=patterns))
+        if patterns:
+            test_meta = filter_tests_by_patterns(test_meta, patterns)
 
-        return model_tests
+        return test_meta
 
 
 class Context(GenericContext[Config]):

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/core/linter/rules/builtin.py

@@ -130,7 +130,7 @@ class NoMissingAudits(Rule):
 
 
 class NoMissingUnitTest(Rule):
-    """All models must have a unit test found in the test/ directory yaml files"""
+    """All models must have a unit test found in the tests/ directory yaml files"""
 
     def check_model(self, model: Model) -> t.Optional[RuleViolation]:
         #  External models cannot have unit tests

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/core/loader.py

@@ -35,7 +35,7 @@ from sqlmesh.core.model import (
 from sqlmesh.core.model import model as model_registry
 from sqlmesh.core.model.common import make_python_env
 from sqlmesh.core.signal import signal
-from sqlmesh.core.test import ModelTestMetadata, filter_tests_by_patterns
+from sqlmesh.core.test import ModelTestMetadata
 from sqlmesh.utils import UniqueKeyDict, sys_path
 from sqlmesh.utils.errors import ConfigError
 from sqlmesh.utils.jinja import JinjaMacroRegistry, MacroExtractor
@@ -427,9 +427,7 @@ class Loader(abc.ABC):
         """Loads user linting rules"""
         return RuleSet()
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
-    ) -> t.List[ModelTestMetadata]:
+    def load_model_tests(self) -> t.List[ModelTestMetadata]:
         """Loads YAML-based model tests"""
         return []
 
@@ -868,38 +866,23 @@ class SqlMeshLoader(Loader):
 
         return model_test_metadata
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
-    ) -> t.List[ModelTestMetadata]:
+    def load_model_tests(self) -> t.List[ModelTestMetadata]:
         """Loads YAML-based model tests"""
         test_meta_list: t.List[ModelTestMetadata] = []
 
-        if tests:
-            for test in tests:
-                filename, test_name = test.split("::", maxsplit=1) if "::" in test else (test, "")
+        search_path = Path(self.config_path) / c.TESTS
 
-                test_meta = self._load_model_test_file(Path(filename))
-                if test_name:
-                    test_meta_list.append(test_meta[test_name])
-                else:
-                    test_meta_list.extend(test_meta.values())
-        else:
-            search_path = Path(self.config_path) / c.TESTS
-
-            for yaml_file in itertools.chain(
-                search_path.glob("**/test*.yaml"),
-                search_path.glob("**/test*.yml"),
+        for yaml_file in itertools.chain(
+            search_path.glob("**/test*.yaml"),
+            search_path.glob("**/test*.yml"),
+        ):
+            if any(
+                yaml_file.match(ignore_pattern)
+                for ignore_pattern in self.config.ignore_patterns or []
             ):
-                if any(
-                    yaml_file.match(ignore_pattern)
-                    for ignore_pattern in self.config.ignore_patterns or []
-                ):
-                    continue
-
-                test_meta_list.extend(self._load_model_test_file(yaml_file).values())
+                continue
 
-        if patterns:
-            test_meta_list = filter_tests_by_patterns(test_meta_list, patterns)
+            test_meta_list.extend(self._load_model_test_file(yaml_file).values())
 
         return test_meta_list
 

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/lsp/context.py

@@ -72,7 +72,7 @@ class LSPContext:
 
     def list_workspace_tests(self) -> t.List[TestEntry]:
         """List all tests in the workspace."""
-        tests = self.context.load_model_tests()
+        tests = self.context.select_tests()
 
         # Use a set to ensure unique URIs
         unique_test_uris = {URI.from_path(test.path).value for test in tests}
@@ -81,7 +81,9 @@ class LSPContext:
             test_ranges = get_test_ranges(URI(uri).to_path())
             if uri not in test_uris:
                 test_uris[uri] = {}
+
             test_uris[uri].update(test_ranges)
+
         return [
             TestEntry(
                 name=test.test_name,
@@ -100,7 +102,7 @@ class LSPContext:
         Returns:
             List of TestEntry objects for the specified document.
         """
-        tests = self.context.load_model_tests(tests=[str(uri.to_path())])
+        tests = self.context.select_tests(tests=[str(uri.to_path())])
         test_ranges = get_test_ranges(uri.to_path())
         return [
             TestEntry(

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh/magics.py

@@ -337,7 +337,7 @@ class SQLMeshMagics(Magics):
         if not args.test_name and not args.ls:
             raise MagicError("Must provide either test name or `--ls` to list tests")
 
-        test_meta = context.load_model_tests()
+        test_meta = context.select_tests()
 
         tests: t.Dict[str, t.Dict[str, ModelTestMetadata]] = defaultdict(dict)
         for model_test_metadata in test_meta:

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.227.2.dev11
+Version: 0.227.2.dev13
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.227.2.dev11 → sqlmesh-0.227.2.dev13}/tests/core/test_connection_config.py

@@ -822,6 +822,37 @@ def test_ducklake_attach_add_ducklake_prefix():
     )
 
 
+def test_ducklake_metadata_schema():
+    # Test that metadata_schema parameter is included when specified
+    options = DuckDBAttachOptions(
+        type="ducklake", path="catalog.ducklake", metadata_schema="custom_schema"
+    )
+    assert (
+        options.to_sql(alias="my_ducklake")
+        == "ATTACH IF NOT EXISTS 'ducklake:catalog.ducklake' AS my_ducklake (METADATA_SCHEMA 'custom_schema')"
+    )
+
+    # Test that metadata_schema is not included when not specified (default behavior)
+    options = DuckDBAttachOptions(type="ducklake", path="catalog.ducklake")
+    assert (
+        options.to_sql(alias="my_ducklake")
+        == "ATTACH IF NOT EXISTS 'ducklake:catalog.ducklake' AS my_ducklake"
+    )
+
+    # Test metadata_schema with other ducklake options
+    options = DuckDBAttachOptions(
+        type="ducklake",
+        path="catalog.ducklake",
+        data_path="/path/to/data",
+        encrypted=True,
+        metadata_schema="workspace_schema",
+    )
+    assert (
+        options.to_sql(alias="my_ducklake")
+        == "ATTACH IF NOT EXISTS 'ducklake:catalog.ducklake' AS my_ducklake (DATA_PATH '/path/to/data', ENCRYPTED, METADATA_SCHEMA 'workspace_schema')"
+    )
+
+
 def test_duckdb_config_json_strings(make_config):
     config = make_config(
         type="duckdb",