sqlmesh 0.210.1.dev7__tar.gz → 0.210.1.dev9__tar.gz

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/PKG-INFO

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

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.210.1.dev7'
-__version_tuple__ = version_tuple = (0, 210, 1, 'dev7')
+__version__ = version = '0.210.1.dev9'
+__version_tuple__ = version_tuple = (0, 210, 1, 'dev9')
 
-__commit_id__ = commit_id = 'gd3eae73fd'
+__commit_id__ = commit_id = 'g4fc3ba684'

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/basemodel.py

@@ -313,33 +313,21 @@ class BaseModelConfig(GeneralConfig):
         """Get common sqlmesh model parameters"""
         self.remove_tests_with_invalid_refs(context)
         self.check_for_circular_test_refs(context)
+
+        dependencies = self.dependencies.copy()
+        if dependencies.has_dynamic_var_names:
+            # Include ALL variables as dependencies since we couldn't determine
+            # precisely which variables are referenced in the model
+            dependencies.variables |= set(context.variables)
+
         model_dialect = self.dialect(context)
         model_context = context.context_for_dependencies(
-            self.dependencies.union(self.tests_ref_source_dependencies)
+            dependencies.union(self.tests_ref_source_dependencies)
         )
         jinja_macros = model_context.jinja_macros.trim(
-            self.dependencies.macros, package=self.package_name
-        )
-
-        model_node: AttributeDict[str, t.Any] = AttributeDict(
-            {
-                k: v
-                for k, v in context._manifest._manifest.nodes[self.node_name].to_dict().items()
-                if k in self.dependencies.model_attrs
-            }
-            if context._manifest and self.node_name in context._manifest._manifest.nodes
-            else {}
-        )
-
-        jinja_macros.add_globals(
-            {
-                "this": self.relation_info,
-                "model": model_node,
-                "schema": self.table_schema,
-                "config": self.config_attribute_dict,
-                **model_context.jinja_globals,  # type: ignore
-            }
+            dependencies.macros, package=self.package_name
         )
+        jinja_macros.add_globals(self._model_jinja_context(model_context, dependencies))
         return {
             "audits": [(test.name, {}) for test in self.tests],
             "columns": column_types_to_sqlmesh(
@@ -369,3 +357,23 @@ class BaseModelConfig(GeneralConfig):
         virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default,
     ) -> Model:
         """Convert DBT model into sqlmesh Model"""
+
+    def _model_jinja_context(
+        self, context: DbtContext, dependencies: Dependencies
+    ) -> t.Dict[str, t.Any]:
+        model_node: AttributeDict[str, t.Any] = AttributeDict(
+            {
+                k: v
+                for k, v in context._manifest._manifest.nodes[self.node_name].to_dict().items()
+                if k in dependencies.model_attrs
+            }
+            if context._manifest and self.node_name in context._manifest._manifest.nodes
+            else {}
+        )
+        return {
+            "this": self.relation_info,
+            "model": model_node,
+            "schema": self.table_schema,
+            "config": self.config_attribute_dict,
+            **context.jinja_globals,
+        }

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/common.py

@@ -184,6 +184,8 @@ class Dependencies(PydanticModel):
     variables: t.Set[str] = set()
     model_attrs: t.Set[str] = set()
 
+    has_dynamic_var_names: bool = False
+
     def union(self, other: Dependencies) -> Dependencies:
         return Dependencies(
             macros=list(set(self.macros) | set(other.macros)),
@@ -191,6 +193,7 @@ class Dependencies(PydanticModel):
             refs=self.refs | other.refs,
             variables=self.variables | other.variables,
             model_attrs=self.model_attrs | other.model_attrs,
+            has_dynamic_var_names=self.has_dynamic_var_names or other.has_dynamic_var_names,
         )
 
     @field_validator("macros", mode="after")

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/context.py

@@ -8,6 +8,7 @@ from dbt.adapters.base import BaseRelation
 
 from sqlmesh.core.config import Config as SQLMeshConfig
 from sqlmesh.dbt.builtin import _relation_info_to_relation
+from sqlmesh.dbt.common import Dependencies
 from sqlmesh.dbt.manifest import ManifestHelper
 from sqlmesh.dbt.target import TargetConfig
 from sqlmesh.utils import AttributeDict
@@ -22,7 +23,6 @@ from sqlmesh.utils.jinja import (
 if t.TYPE_CHECKING:
     from jinja2 import Environment
 
-    from sqlmesh.dbt.basemodel import Dependencies
     from sqlmesh.dbt.model import ModelConfig
     from sqlmesh.dbt.relation import Policy
     from sqlmesh.dbt.seed import SeedConfig
@@ -101,8 +101,6 @@ class DbtContext:
         self._jinja_environment = None
 
     def set_and_render_variables(self, variables: t.Dict[str, t.Any], package: str) -> None:
-        self.variables = variables
-
         jinja_environment = self.jinja_macros.build_environment(**self.jinja_globals)
 
         def _render_var(value: t.Any) -> t.Any:

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/loader.py

@@ -124,8 +124,6 @@ class DbtLoader(Loader):
             )
 
         for project in self._load_projects():
-            context = project.context.copy()
-
             macros_max_mtime = self._macros_max_mtime
             yaml_max_mtimes = self._compute_yaml_max_mtime_per_subfolder(
                 project.context.project_root
@@ -135,12 +133,13 @@ class DbtLoader(Loader):
             logger.debug("Converting models to sqlmesh")
             # Now that config is rendered, create the sqlmesh models
             for package in project.packages.values():
-                context.set_and_render_variables(package.variables, package.name)
+                package_context = project.context.copy()
+                package_context.set_and_render_variables(package.variables, package.name)
                 package_models: t.Dict[str, BaseModelConfig] = {**package.models, **package.seeds}
 
                 for model in package_models.values():
                     sqlmesh_model = cache.get_or_load_models(
-                        model.path, loader=lambda: [_to_sqlmesh(model, context)]
+                        model.path, loader=lambda: [_to_sqlmesh(model, package_context)]
                     )[0]
 
                     models[sqlmesh_model.fqn] = sqlmesh_model
@@ -155,15 +154,14 @@ class DbtLoader(Loader):
         audits: UniqueKeyDict = UniqueKeyDict("audits")
 
         for project in self._load_projects():
-            context = project.context
-
             logger.debug("Converting audits to sqlmesh")
             for package in project.packages.values():
-                context.set_and_render_variables(package.variables, package.name)
+                package_context = project.context.copy()
+                package_context.set_and_render_variables(package.variables, package.name)
                 for test in package.tests.values():
                     logger.debug("Converting '%s' to sqlmesh format", test.name)
                     try:
-                        audits[test.name] = test.to_sqlmesh(context)
+                        audits[test.name] = test.to_sqlmesh(package_context)
                     except MissingModelError as e:
                         logger.warning(
                             "Skipping audit '%s' because model '%s' is not a valid ref",
@@ -244,9 +242,9 @@ class DbtLoader(Loader):
         project_names: t.Set[str] = set()
         dialect = self.config.dialect
         for project in self._load_projects():
-            context = project.context
             for package_name, package in project.packages.items():
-                context.set_and_render_variables(package.variables, package_name)
+                package_context = project.context.copy()
+                package_context.set_and_render_variables(package.variables, package_name)
                 on_run_start: t.List[str] = [
                     on_run_hook.sql
                     for on_run_hook in sorted(package.on_run_start.values(), key=lambda h: h.index)
@@ -261,7 +259,7 @@ class DbtLoader(Loader):
                     for hook in [*package.on_run_start.values(), *package.on_run_end.values()]:
                         dependencies = dependencies.union(hook.dependencies)
 
-                    statements_context = context.context_for_dependencies(dependencies)
+                    statements_context = package_context.context_for_dependencies(dependencies)
                     jinja_registry = make_jinja_registry(
                         statements_context.jinja_macros, package_name, set(dependencies.macros)
                     )

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/manifest.py

@@ -554,6 +554,9 @@ class ManifestHelper:
                 args = [jinja_call_arg_name(arg) for arg in node.args]
                 if args and args[0]:
                     dependencies.variables.add(args[0])
+                else:
+                    # We couldn't determine the var name statically
+                    dependencies.has_dynamic_var_names = True
                 dependencies.macros.append(MacroReference(name="var"))
             elif len(call_name) == 1:
                 macro_name = call_name[0]

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh/dbt/project.py

@@ -55,9 +55,6 @@ class Project:
             raise ConfigError(f"Could not find {PROJECT_FILENAME} in {context.project_root}")
         project_yaml = load_yaml(project_file_path)
 
-        variable_overrides = variables
-        variables = {**project_yaml.get("vars", {}), **(variables or {})}
-
         project_name = context.render(project_yaml.get("name", ""))
         context.project_name = project_name
         if not context.project_name:
@@ -69,6 +66,7 @@ class Project:
         profile = Profile.load(context, context.target_name)
         context.target = profile.target
 
+        variable_overrides = variables or {}
         context.manifest = ManifestHelper(
             project_file_path.parent,
             profile.path.parent,
@@ -101,13 +99,17 @@ class Project:
             package = package_loader.load(path.parent)
             packages[package.name] = package
 
+        all_project_variables = {**project_yaml.get("vars", {}), **(variable_overrides or {})}
         for name, package in packages.items():
-            package_vars = variables.get(name)
+            package_vars = all_project_variables.get(name)
 
             if isinstance(package_vars, dict):
                 package.variables.update(package_vars)
 
-            package.variables.update(variables)
+            if name == context.project_name:
+                package.variables.update(all_project_variables)
+            else:
+                package.variables.update(variable_overrides)
 
         return Project(context, profile, packages)
 

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh.egg-info/PKG-INFO

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

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh.egg-info/SOURCES.txt

@@ -501,6 +501,7 @@ sqlmesh_dbt/cli.py
 sqlmesh_dbt/console.py
 sqlmesh_dbt/error.py
 sqlmesh_dbt/operations.py
+sqlmesh_dbt/selectors.py
 tests/.gitignore
 tests/__init__.py
 tests/conftest.py
@@ -615,6 +616,7 @@ tests/dbt/cli/test_global_flags.py
 tests/dbt/cli/test_list.py
 tests/dbt/cli/test_operations.py
 tests/dbt/cli/test_run.py
+tests/dbt/cli/test_selectors.py
 tests/dbt/cli/fixtures/jaffle_shop_duckdb/dbt_project.yml
 tests/dbt/cli/fixtures/jaffle_shop_duckdb/profiles.yml
 tests/dbt/cli/fixtures/jaffle_shop_duckdb/models/customers.sql

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh_dbt/cli.py

@@ -12,6 +12,18 @@ def _get_dbt_operations(ctx: click.Context) -> DbtOperations:
     return ctx.obj
 
 
+select_option = click.option(
+    "-s",
+    "-m",
+    "--select",
+    "--models",
+    "--model",
+    multiple=True,
+    help="Specify the nodes to include.",
+)
+exclude_option = click.option("--exclude", multiple=True, help="Specify the nodes to exclude.")
+
+
 @click.group(invoke_without_command=True)
 @click.option("--profile", help="Which existing profile to load. Overrides output.profile")
 @click.option("-t", "--target", help="Which target to load for the given profile")
@@ -38,23 +50,26 @@ def dbt(
 
 
 @dbt.command()
-@click.option("-s", "-m", "--select", "--models", "--model", help="Specify the nodes to include.")
+@select_option
+@exclude_option
 @click.option(
     "-f",
     "--full-refresh",
     help="If specified, dbt will drop incremental models and fully-recalculate the incremental table from the model definition.",
 )
 @click.pass_context
-def run(ctx: click.Context, select: t.Optional[str], full_refresh: bool) -> None:
+def run(ctx: click.Context, **kwargs: t.Any) -> None:
     """Compile SQL and execute against the current target database."""
-    _get_dbt_operations(ctx).run(select=select, full_refresh=full_refresh)
+    _get_dbt_operations(ctx).run(**kwargs)
 
 
 @dbt.command(name="list")
+@select_option
+@exclude_option
 @click.pass_context
-def list_(ctx: click.Context) -> None:
+def list_(ctx: click.Context, **kwargs: t.Any) -> None:
     """List the resources in your project"""
-    _get_dbt_operations(ctx).list_()
+    _get_dbt_operations(ctx).list_(**kwargs)
 
 
 @dbt.command(name="ls", hidden=True)  # hidden alias for list

sqlmesh-0.210.1.dev9/sqlmesh_dbt/console.py

@@ -0,0 +1,27 @@
+import typing as t
+from sqlmesh.core.console import TerminalConsole
+from sqlmesh.core.model import Model
+from rich.tree import Tree
+
+
+class DbtCliConsole(TerminalConsole):
+    def print(self, msg: str) -> None:
+        return self._print(msg)
+
+    def list_models(
+        self, models: t.List[Model], list_parents: bool = True, list_audits: bool = True
+    ) -> None:
+        model_list = Tree("[bold]Models in project:[/bold]")
+
+        for model in models:
+            model_tree = model_list.add(model.name)
+
+            if list_parents:
+                for parent in model.depends_on:
+                    model_tree.add(f"depends_on: {parent}")
+
+            if list_audits:
+                for audit_name in model.audit_definitions:
+                    model_tree.add(f"audit: {audit_name}")
+
+        self._print(model_list)

{sqlmesh-0.210.1.dev7 → sqlmesh-0.210.1.dev9}/sqlmesh_dbt/operations.py

@@ -2,12 +2,17 @@ from __future__ import annotations
 import typing as t
 from rich.progress import Progress
 from pathlib import Path
+import logging
+from sqlmesh_dbt import selectors
 
 if t.TYPE_CHECKING:
     # important to gate these to be able to defer importing sqlmesh until we need to
     from sqlmesh.core.context import Context
     from sqlmesh.dbt.project import Project
     from sqlmesh_dbt.console import DbtCliConsole
+    from sqlmesh.core.model import Model
+
+logger = logging.getLogger(__name__)
 
 
 class DbtOperations:
@@ -15,22 +20,28 @@ class DbtOperations:
         self.context = sqlmesh_context
         self.project = dbt_project
 
-    def list_(self) -> None:
-        for _, model in self.context.models.items():
-            self.console.print(model.name)
-
-    def run(self, select: t.Optional[str] = None, full_refresh: bool = False) -> None:
-        # A dbt run both updates data and changes schemas and has no way of rolling back so more closely maps to a SQLMesh forward-only plan
-        # TODO: if --full-refresh specified, mark incrementals as breaking instead of forward_only?
-
-        # TODO: we need to either convert DBT selector syntax to SQLMesh selector syntax
-        # or make the model selection engine configurable
+    def list_(
+        self,
+        select: t.Optional[t.List[str]] = None,
+        exclude: t.Optional[t.List[str]] = None,
+    ) -> None:
+        # dbt list prints:
+        # - models
+        # - "data tests" (audits) for those models
+        # it also applies selectors which is useful for testing selectors
+        selected_models = list(self._selected_models(select, exclude).values())
+        self.console.list_models(selected_models)
+
+    def run(
+        self,
+        select: t.Optional[t.List[str]] = None,
+        exclude: t.Optional[t.List[str]] = None,
+        full_refresh: bool = False,
+    ) -> None:
         select_models = None
-        if select:
-            if "," in select:
-                select_models = select.split(",")
-            else:
-                select_models = select.split(" ")
+
+        if sqlmesh_selector := selectors.to_sqlmesh(select or [], exclude or []):
+            select_models = [sqlmesh_selector]
 
         self.context.plan(
             select_models=select_models,
@@ -40,6 +51,21 @@ class DbtOperations:
             auto_apply=True,
         )
 
+    def _selected_models(
+        self, select: t.Optional[t.List[str]] = None, exclude: t.Optional[t.List[str]] = None
+    ) -> t.Dict[str, Model]:
+        if sqlmesh_selector := selectors.to_sqlmesh(select or [], exclude or []):
+            model_selector = self.context._new_selector()
+            selected_models = {
+                fqn: model
+                for fqn, model in self.context.models.items()
+                if fqn in model_selector.expand_model_selections([sqlmesh_selector])
+            }
+        else:
+            selected_models = dict(self.context.models)
+
+        return selected_models
+
     @property
     def console(self) -> DbtCliConsole:
         console = self.context.console

sqlmesh-0.210.1.dev9/sqlmesh_dbt/selectors.py

@@ -0,0 +1,130 @@
+import typing as t
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def to_sqlmesh(dbt_select: t.Collection[str], dbt_exclude: t.Collection[str]) -> t.Optional[str]:
+    """
+    Given selectors defined in the format of the dbt cli --select and --exclude arguments, convert them into a selector expression that
+    the SQLMesh selector engine can understand.
+
+    The main things being mapped are:
+        - set union (" " between items within the same selector string OR multiple --select arguments) is mapped to " | "
+        - set intersection ("," between items within the same selector string) is mapped to " & "
+        - `--exclude`. The SQLMesh selector engine does not treat this as a separate parameter and rather treats exclusion as a normal selector
+          that just happens to contain negation syntax, so we generate these by negating each expression and then intersecting the result
+          with any --select expressions
+
+    Things that are *not* currently being mapped include:
+        - selectors based on file paths
+        - selectors based on partially qualified names like "model_a". The SQLMesh selector engine requires either:
+            - wildcards, eg "*model_a*"
+            - the full model name qualified with the schema, eg "staging.model_a"
+
+    Examples:
+        --select "model_a"
+            -> "model_a"
+        --select "main.model_a"
+            -> "main.model_a"
+        --select "main.model_a" --select "main.model_b"
+            -> "main.model_a | main.model_b"
+        --select "main.model_a main.model_b"
+            -> "main.model_a | main.model_b"
+        --select "(main.model_a+ & ^main.model_b)"
+            -> "(main.model_a+ & ^main.model_b)"
+        --select "+main.model_a" --exclude "raw.src_data"
+            -> "+main.model_a & ^(raw.src_data)"
+        --select "+main.model_a" --select "main.*b+" --exclude "raw.src_data"
+            -> "(+main.model_a | main.*b+) & ^(raw.src_data)"
+    """
+    if not dbt_select and not dbt_exclude:
+        return None
+
+    select_expr = " | ".join(_to_sqlmesh(expr) for expr in dbt_select)
+    select_expr = _wrap(select_expr) if dbt_exclude and len(dbt_select) > 1 else select_expr
+
+    exclude_expr = " | ".join(_to_sqlmesh(expr, negate=True) for expr in dbt_exclude)
+    exclude_expr = _wrap(exclude_expr) if dbt_select and len(dbt_exclude) > 1 else exclude_expr
+
+    main_expr = " & ".join([expr for expr in [select_expr, exclude_expr] if expr])
+
+    logger.debug(
+        f"Expanded dbt select: {dbt_select}, exclude: {dbt_exclude} into SQLMesh: {main_expr}"
+    )
+
+    return main_expr
+
+
+def _to_sqlmesh(selector_str: str, negate: bool = False) -> str:
+    unions, intersections = _split_unions_and_intersections(selector_str)
+
+    if negate:
+        unions = [_negate(u) for u in unions]
+        intersections = [_negate(i) for i in intersections]
+
+    union_expr = " | ".join(unions)
+    intersection_expr = " & ".join(intersections)
+
+    if len(unions) > 1 and intersections:
+        union_expr = f"({union_expr})"
+
+    if len(intersections) > 1 and unions:
+        intersection_expr = f"({intersection_expr})"
+
+    return " | ".join([expr for expr in [union_expr, intersection_expr] if expr])
+
+
+def _split_unions_and_intersections(selector_str: str) -> t.Tuple[t.List[str], t.List[str]]:
+    # break space-separated items like: "my_first_model my_second_model" into a list of selectors to union
+    # and comma-separated items like: "my_first_model,my_second_model" into a list of selectors to intersect
+    # but, take into account brackets, eg "(my_first_model & my_second_model)" should not be split
+
+    def _split_by(input: str, delimiter: str) -> t.Iterator[str]:
+        buf = ""
+        depth = 0
+
+        for char in input:
+            if char == delimiter and depth <= 0:
+                # only split on a space if we are not within parenthesis
+                yield buf
+                buf = ""
+                continue
+            elif char == "(":
+                depth += 1
+            elif char == ")":
+                depth -= 1
+
+            buf += char
+
+        if buf:
+            yield buf
+
+    # first, break up based on spaces
+    segments = list(_split_by(selector_str, " "))
+
+    # then, within each segment, identify the unions and intersections
+    unions = []
+    intersections = []
+
+    for segment in segments:
+        maybe_intersections = list(_split_by(segment, ","))
+        if len(maybe_intersections) > 1:
+            intersections.extend(maybe_intersections)
+        else:
+            unions.append(segment)
+
+    return unions, intersections
+
+
+def _negate(expr: str) -> str:
+    return f"^{_wrap(expr)}"
+
+
+def _wrap(expr: str) -> str:
+    already_wrapped = expr.strip().startswith("(") and expr.strip().endswith(")")
+
+    if expr and not already_wrapped:
+        return f"({expr})"
+
+    return expr

sqlmesh-0.210.1.dev9/tests/dbt/cli/test_list.py

@@ -0,0 +1,48 @@
+import typing as t
+import pytest
+from pathlib import Path
+from click.testing import Result
+
+pytestmark = pytest.mark.slow
+
+
+def test_list(jaffle_shop_duckdb: Path, invoke_cli: t.Callable[..., Result]):
+    result = invoke_cli(["list"])
+
+    assert result.exit_code == 0
+    assert not result.exception
+
+    assert "main.orders" in result.output
+    assert "main.customers" in result.output
+    assert "main.stg_payments" in result.output
+    assert "main.raw_orders" in result.output
+
+
+def test_list_select(jaffle_shop_duckdb: Path, invoke_cli: t.Callable[..., Result]):
+    result = invoke_cli(["list", "--select", "main.raw_customers+"])
+
+    assert result.exit_code == 0
+    assert not result.exception
+
+    assert "main.orders" in result.output
+    assert "main.customers" in result.output
+    assert "main.stg_customers" in result.output
+    assert "main.raw_customers" in result.output
+
+    assert "main.stg_payments" not in result.output
+    assert "main.raw_orders" not in result.output
+
+
+def test_list_select_exclude(jaffle_shop_duckdb: Path, invoke_cli: t.Callable[..., Result]):
+    result = invoke_cli(["list", "--select", "main.raw_customers+", "--exclude", "main.orders"])
+
+    assert result.exit_code == 0
+    assert not result.exception
+
+    assert "main.customers" in result.output
+    assert "main.stg_customers" in result.output
+    assert "main.raw_customers" in result.output
+
+    assert "main.orders" not in result.output
+    assert "main.stg_payments" not in result.output
+    assert "main.raw_orders" not in result.output

sqlmesh-0.210.1.dev9/tests/dbt/cli/test_run.py

@@ -0,0 +1,40 @@
+import typing as t
+import pytest
+from pathlib import Path
+from click.testing import Result
+import time_machine
+from tests.cli.test_cli import FREEZE_TIME
+
+pytestmark = pytest.mark.slow
+
+
+def test_run(jaffle_shop_duckdb: Path, invoke_cli: t.Callable[..., Result]):
+    result = invoke_cli(["run"])
+
+    assert result.exit_code == 0
+    assert not result.exception
+
+    assert "Model batches executed" in result.output
+
+
+def test_run_with_selectors(jaffle_shop_duckdb: Path, invoke_cli: t.Callable[..., Result]):
+    with time_machine.travel(FREEZE_TIME):
+        # do an initial run to create the objects
+        # otherwise the selected subset may depend on something that hasnt been created
+        result = invoke_cli(["run"])
+        assert result.exit_code == 0
+        assert "main.orders" in result.output
+
+    result = invoke_cli(["run", "--select", "main.raw_customers+", "--exclude", "main.orders"])
+
+    assert result.exit_code == 0
+    assert not result.exception
+
+    assert "main.stg_customers" in result.output
+    assert "main.stg_orders" in result.output
+    assert "main.stg_payments" in result.output
+    assert "main.customers" in result.output
+
+    assert "main.orders" not in result.output
+
+    assert "Model batches executed" in result.output