WIP

Author: z3z1ma

src/dbt_core_interface/project.py

@@ -324,32 +324,24 @@ def source(self, source_name: str, table_name: str) -> SourceDefinition | None:
         """
         return self.manifest.source_lookup.find(f"{source_name}.{table_name}", None, self.manifest)
 
-    def execute_sql(self, sql: str) -> ExecutionResult:
-        """Execute Jinja SQL against the database."""
-        with self._manifest_lock:
-            temp_node, cleanup = self._create_temp_node(sql)
-            try:
-                compiled_result = self.compile_from_node(temp_node, update_depends_on=False)
-                response, table = self.adapter.execute(
-                    compiled_result.compiled_code, auto_begin=False, fetch=True
-                )
-                return ExecutionResult(
-                    adapter_response=response,  # pyright: ignore[reportUnknownArgumentType]
-                    table=table,  # pyright: ignore[reportUnknownArgumentType]
-                    raw_code=sql,
-                    compiled_code=compiled_result.compiled_code,
-                )
-            finally:
-                cleanup()
+    def execute_sql(self, sql: str, compile: bool = True) -> ExecutionResult:
+        """Execute SQL against the database via the adapter optionally compiling it."""
+        raw_code = compiled_code = sql
+        if compile:
+            with self._manifest_lock:
+                temp_node, cleanup = self._create_temp_node(sql)
+                try:
+                    compiled_result = self.compile_node(temp_node, update_depends_on=False)
+                    compiled_code = compiled_result.compiled_code
+                finally:
+                    cleanup()
 
-    def execute_raw_sql(self, sql: str) -> ExecutionResult:
-        """Execute raw SQL against the database."""
-        response, table = self.adapter.execute(sql, auto_begin=False, fetch=True)
+        response, table = self.adapter.execute(compiled_code, auto_begin=False, fetch=True)
         return ExecutionResult(
             adapter_response=response,  # pyright: ignore[reportUnknownArgumentType]
             table=table,  # pyright: ignore[reportUnknownArgumentType]
-            raw_code=sql,
-            compiled_code=sql,
+            raw_code=raw_code,
+            compiled_code=compiled_code,
         )
 
     def compile_sql(self, sql: str) -> CompilationResult:
@@ -362,17 +354,15 @@ def compile_sql(self, sql: str) -> CompilationResult:
         with self._manifest_lock:
             temp_node, cleanup = self._create_temp_node(sql)
             try:
-                response = self.compile_from_node(temp_node, update_depends_on=False)
+                response = self.compile_node(temp_node, update_depends_on=False)
                 self.__compilation_cache[sql] = response
                 if len(self.__compilation_cache) > 128:
                     _ = self.__compilation_cache.pop(next(iter(self.__compilation_cache)))
                 return response
             finally:
                 cleanup()
 
-    def compile_from_node(
-        self, node: ManifestNode, update_depends_on: bool = True
-    ) -> CompilationResult:
+    def compile_node(self, node: ManifestNode, update_depends_on: bool = True) -> CompilationResult:
         """Compile a manifest node."""
         with contextlib.suppress(Exception):
             node.compiled_code = None  # pyright: ignore[reportAttributeAccessIssue]
@@ -453,20 +443,6 @@ def macro_parser(self) -> SqlMacroParser:
             )
         return self._macro_parser
 
-    def recycle_adapter(self) -> None:
-        """Force refresh the adapter (useful for long-running processes)."""
-        with self._adapter_lock:
-            if self._adapter:
-                try:
-                    self._adapter.connections.cleanup_all()
-                except Exception as e:
-                    logger.warning(f"Error during adapter cleanup: {e}")
-            self._adapter = None
-            self._adapter_created_at = 0
-
-        _ = self.adapter
-        logger.info("Adapter refreshed")
-
     def get_node_by_path(self, path: Path | str) -> ManifestNode | None:
         """Get a node by its path on disk."""
         path = Path(path)
@@ -546,7 +522,7 @@ def update_nodes_by_paths(self, *paths: Path | str) -> dict[str, bool]:
             results[str(path)] = self.update_node_from_content(path)
         return results
 
-    def detect_new_files(self) -> list[Path]:
+    def detect_new_project_resources(self) -> list[Path]:
         """Detect new dbt files that aren't in the manifest."""
         known_files = set()
 
@@ -564,10 +540,10 @@ def detect_new_files(self) -> list[Path]:
 
         return discovered
 
-    def add_new_files(self, *paths: Path | str) -> dict[str, bool]:
+    def add_project_resources(self, *paths: Path | str) -> dict[str, bool]:
         """Add new files to the manifest."""
         if not paths:
-            paths = tuple(self.detect_new_files())
+            paths = tuple(self.detect_new_project_resources())
 
         results = {}
         for path in paths:
@@ -759,10 +735,10 @@ def _check_for_changes(self) -> None:
     def _check_for_new_files(self) -> None:
         """Check for new dbt files."""
         try:
-            added_files = self.project.detect_new_files()
+            added_files = self.project.detect_new_project_resources()
             if added_files:
                 logger.info(f"Detected {len(added_files)} new files")
-                results = self.project.add_new_files(*added_files)
+                results = self.project.add_project_resources(*added_files)
 
                 for path, success in results.items():
                     if success: