New command: dbt show

.changes/unreleased/Features-20230324-123621.yaml

@@ -0,0 +1,6 @@
+kind: Features
+body: 'New command: dbt show'
+time: 2023-03-24T12:36:21.173419-07:00
+custom:
+  Author: aranke
+  Issue: 7207 7179 6359

core/dbt/cli/main.py

@@ -13,6 +13,7 @@
 from dbt.task.debug import DebugTask
 from dbt.task.run import RunTask
 from dbt.task.serve import ServeTask
+from dbt.task.show import ShowTask
 from dbt.task.test import TestTask
 from dbt.task.snapshot import SnapshotTask
 from dbt.task.seed import SeedTask
@@ -262,6 +263,7 @@ def docs_serve(ctx, **kwargs):
 @p.favor_state
 @p.deprecated_favor_state
 @p.full_refresh
+@p.show_output_format
 @p.indirect_selection
 @p.introspect
 @p.parse_only
@@ -298,6 +300,52 @@ def compile(ctx, **kwargs):
     return results, success
 
 
+# dbt show
+@cli.command("show")
+@click.pass_context
+@p.defer
+@p.deprecated_defer
+@p.exclude
+@p.favor_state
+@p.deprecated_favor_state
+@p.full_refresh
+@p.show_output_format
+@p.show_limit
+@p.indirect_selection
+@p.introspect
+@p.parse_only
+@p.profile
+@p.profiles_dir
+@p.project_dir
+@p.select
+@p.selector
+@p.inline
+@p.state
+@p.deprecated_state
+@p.target
+@p.target_path
+@p.threads
+@p.vars
+@p.version_check
+@requires.preflight
+@requires.profile
+@requires.project
+@requires.runtime_config
+@requires.manifest
+def show(ctx, **kwargs):
+    """Generates executable SQL for a named resource or inline query, runs that SQL, and returns a preview of the
+    results. Does not materialize anything to the warehouse."""
+    task = ShowTask(
+        ctx.obj["flags"],
+        ctx.obj["runtime_config"],
+        ctx.obj["manifest"],
+    )
+
+    results = task.run()
+    success = task.interpret_results(results)
+    return results, success
+
+
 # dbt debug
 @cli.command("debug")
 @click.pass_context

core/dbt/cli/params.py

@@ -6,7 +6,6 @@
 from dbt.cli.resolvers import default_project_dir, default_profiles_dir
 from dbt.version import get_version_information
 
-
 args = click.option(
     "--args",
     envvar=None,
@@ -187,6 +186,22 @@
     default="selector",
 )
 
+show_output_format = click.option(
+    "--output",
+    envvar=None,
+    help="Output format for dbt compile and dbt show",
+    type=click.Choice(["json", "text"], case_sensitive=False),
+    default="text",
+)
+
+show_limit = click.option(
+    "--limit",
+    envvar=None,
+    help="Limit the number of results returned by dbt show",
+    type=click.INT,
+    default=5,
+)
+
 output_keys = click.option(
     "--output-keys",
     envvar=None,
@@ -335,7 +350,7 @@
     "type": tuple,
 }
 
-inline = click.option("--inline", envvar=None, help="Pass SQL inline to dbt compile and preview")
+inline = click.option("--inline", envvar=None, help="Pass SQL inline to dbt compile and show")
 
 # `--select` and `--models` are analogous for most commands except `dbt list` for legacy reasons.
 # Most CLI arguments should use the combined `select` option that aliases `--models` to `--select`.

core/dbt/events/types.proto

@@ -1643,17 +1643,6 @@ message ConcurrencyLineMsg {
     ConcurrencyLine data = 2;
 }
 
-// Q028
-message CompiledNode {
-    string node_name = 1;
-    string compiled = 2;
-}
-
-message CompiledNodeMsg {
-    EventInfo info = 1;
-    CompiledNode data = 2;
-}
-
 // Q029
 message WritingInjectedSQLForNode {
     NodeInfo node_info = 1;
@@ -1781,6 +1770,32 @@ message CommandCompletedMsg {
     CommandCompleted data = 2;
 }
 
+// Q041
+message ShowNode {
+    string node_name = 1;
+    string preview = 2;
+    bool is_inline = 3;
+    string output_format = 4;
+}
+
+message ShowNodeMsg {
+    EventInfo info = 1;
+    ShowNode data = 2;
+}
+
+// Q042
+message CompiledNode {
+    string node_name = 1;
+    string compiled = 2;
+    bool is_inline = 3;
+    string output_format = 4;
+}
+
+message CompiledNodeMsg {
+    EventInfo info = 1;
+    CompiledNode data = 2;
+}
+
 // W - Node testing
 
 // Skipped W001

core/dbt/events/types.py

@@ -1,3 +1,5 @@
+import json
+
 from dbt.ui import line_wrap_message, warning_tag, red, green, yellow
 from dbt.constants import MAXIMUM_SEED_SIZE_NAME, PIN_PACKAGE_URL
 from dbt.events.base_types import (
@@ -1605,14 +1607,6 @@ def message(self) -> str:
         return f"Concurrency: {self.num_threads} threads (target='{self.target_name}')"
 
 
-class CompiledNode(InfoLevel):
-    def code(self):
-        return "Q028"
-
-    def message(self) -> str:
-        return f"Compiled node '{self.node_name}' is:\n{self.compiled}"
-
-
 class WritingInjectedSQLForNode(DebugLevel):
     def code(self):
         return "Q029"
@@ -1719,6 +1713,42 @@ def message(self) -> str:
         return f"Command `{self.command}` {status} at {self.completed_at} after {self.elapsed:0.2f} seconds"
 
 
+class ShowNode(InfoLevel):
+    def code(self):
+        return "Q041"
+
+    def message(self) -> str:
+        if self.output_format == "json":
+            if self.is_inline:
+                return json.dumps({"show": json.loads(self.preview)}, indent=2)
+            else:
+                return json.dumps(
+                    {"node": self.node_name, "show": json.loads(self.preview)}, indent=2
+                )
+        else:
+            if self.is_inline:
+                return f"Previewing inline node:\n{self.preview}"
+            else:
+                return f"Previewing node '{self.node_name}':\n{self.preview}"
+
+
+class CompiledNode(InfoLevel):
+    def code(self):
+        return "Q042"
+
+    def message(self) -> str:
+        if self.output_format == "json":
+            if self.is_inline:
+                return json.dumps({"compiled": self.compiled}, indent=2)
+            else:
+                return json.dumps({"node": self.node_name, "compiled": self.compiled}, indent=2)
+        else:
+            if self.is_inline:
+                return f"Compiled inline node is:\n{self.compiled}"
+            else:
+                return f"Compiled node '{self.node_name}' is:\n{self.compiled}"
+
+
 # =======================================================
 # W - Node testing
 # =======================================================

core/dbt/task/base.py

@@ -4,11 +4,14 @@
 import traceback
 from abc import ABCMeta, abstractmethod
 from contextlib import nullcontext
-from typing import Type, Union, Dict, Any, Optional
 from datetime import datetime
+from typing import Type, Union, Dict, Any, Optional
 
+import dbt.exceptions
 from dbt import tracking
-from dbt.flags import get_flags
+from dbt.adapters.factory import get_adapter
+from dbt.config import RuntimeConfig, Project
+from dbt.config.profile import read_profile
 from dbt.contracts.graph.manifest import Manifest
 from dbt.contracts.results import (
     NodeStatus,
@@ -17,13 +20,7 @@
     RunStatus,
     RunningStatus,
 )
-from dbt.exceptions import (
-    NotImplementedError,
-    CompilationError,
-    DbtRuntimeError,
-    DbtInternalError,
-)
-from dbt.logger import log_manager
+from dbt.events.contextvars import get_node_info
 from dbt.events.functions import fire_event
 from dbt.events.types import (
     LogDbtProjectError,
@@ -38,14 +35,16 @@
     NodeCompiling,
     NodeExecuting,
 )
-from dbt.events.contextvars import get_node_info
-from .printer import print_run_result_error
-
-from dbt.adapters.factory import get_adapter
-from dbt.config import RuntimeConfig, Project
-from dbt.config.profile import read_profile
-import dbt.exceptions
+from dbt.exceptions import (
+    NotImplementedError,
+    CompilationError,
+    DbtRuntimeError,
+    DbtInternalError,
+)
+from dbt.flags import get_flags
 from dbt.graph import Graph
+from dbt.logger import log_manager
+from .printer import print_run_result_error
 
 
 class NoneConfig:
@@ -204,6 +203,8 @@ def __init__(self, config, adapter, node, node_index, num_nodes):
         self.skip = False
         self.skip_cause: Optional[RunResult] = None
 
+        self.run_ephemeral_models = False
+
     @abstractmethod
     def compile(self, manifest: Manifest) -> Any:
         pass
@@ -325,7 +326,7 @@ def compile_and_execute(self, manifest, ctx):
             ctx.timing.append(timing_info)
 
             # for ephemeral nodes, we only want to compile, not run
-            if not ctx.node.is_ephemeral_model:
+            if not ctx.node.is_ephemeral_model or self.run_ephemeral_models:
                 ctx.node.update_event_status(node_status=RunningStatus.Executing)
                 fire_event(
                     NodeExecuting(

core/dbt/task/compile.py

@@ -4,7 +4,7 @@
 from dbt.contracts.graph.manifest import WritableManifest
 from dbt.contracts.results import RunStatus, RunResult
 from dbt.events.functions import fire_event
-from dbt.events.types import CompileComplete, CompiledNode
+from dbt.events.types import CompiledNode
 from dbt.exceptions import DbtInternalError, DbtRuntimeError
 from dbt.graph import ResourceTypeSelector
 from dbt.node_types import NodeType
@@ -61,23 +61,27 @@ def get_runner_type(self, _):
         return CompileRunner
 
     def task_end_messages(self, results):
-        if getattr(self.args, "inline", None):
-            result = results[0]
-            fire_event(
-                CompiledNode(node_name=result.node.name, compiled=result.node.compiled_code)
-            )
+        is_inline = bool(getattr(self.args, "inline", None))
 
-        if self.selection_arg:
+        if is_inline:
+            matched_results = [result for result in results if result.node.name == "inline_query"]
+        elif self.selection_arg:
             matched_results = [
-                result for result in results if result.node.name == self.selection_arg[0]
+                result for result in results if result.node.name in self.selection_arg
             ]
-            if len(matched_results) == 1:
-                result = matched_results[0]
-                fire_event(
-                    CompiledNode(node_name=result.node.name, compiled=result.node.compiled_code)
-                )
+        # No selector passed, compiling all nodes
+        else:
+            matched_results = []
 
-        fire_event(CompileComplete())
+        for result in matched_results:
+            fire_event(
+                CompiledNode(
+                    node_name=result.node.name,
+                    compiled=result.node.compiled_code,
+                    is_inline=is_inline,
+                    output_format=self.args.output,
+                )
+            )
 
     def _get_deferred_manifest(self) -> Optional[WritableManifest]:
         if not self.args.defer:
@@ -119,3 +123,13 @@ def _runtime_initialize(self):
             process_node(self.config, self.manifest, sql_node)
 
         super()._runtime_initialize()
+
+    def _handle_result(self, result):
+        super()._handle_result(result)
+
+        if (
+            result.node.is_ephemeral_model
+            and type(self) is CompileTask
+            and (self.args.select or getattr(self.args, "inline", None))
+        ):
+            self.node_results.append(result)