altimate-datapilot-cli 0.0.13__tar.gz → 0.0.15__tar.gz

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.13
+current_version = 0.0.15
 commit = True
 tag = True
 

{altimate-datapilot-cli-0.0.13/src/altimate_datapilot_cli.egg-info → altimate-datapilot-cli-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: altimate-datapilot-cli
-Version: 0.0.13
+Version: 0.0.15
 Summary: Assistant for Data Teams
 Home-page: https://github.com/AltimateAI/datapilot-cli
 Author: Altimate Inc

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/docs/conf.py

@@ -15,7 +15,7 @@ project = "datapilot-cli"
 year = "2024"
 author = "Altimate Inc."
 copyright = f"{year}, {author}"
-version = release = "0.0.13"
+version = release = "0.0.15"
 
 pygments_style = "trac"
 templates_path = ["."]

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/setup.py

@@ -13,7 +13,7 @@ def read(*names, **kwargs):
 
 setup(
     name="altimate-datapilot-cli",
-    version="0.0.13",
+    version="0.0.15",
     license="MIT",
     description="Assistant for Data Teams",
     long_description="{}\n{}".format(
@@ -62,11 +62,12 @@ setup(
     ],
     python_requires=">=3.8",
     install_requires=[
-        "click==8.1.7",
-        "dbt-artifacts-parser==0.6.0",
-        "ruamel.yaml==0.18.6",
-        "tabulate==0.9.0",
-        "requests==2.31.0",
+        "click~=8.1.7",
+        "dbt-artifacts-parser~=0.8.1",
+        "ruamel.yaml~=0.18.6",
+        "tabulate~=0.9.0",
+        "requests~=2.31.0",
+        "sqlglot~=25.30.0",
     ],
     extras_require={
         # eg:

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15/src/altimate_datapilot_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: altimate-datapilot-cli
-Version: 0.0.13
+Version: 0.0.15
 Summary: Assistant for Data Teams
 Home-page: https://github.com/AltimateAI/datapilot-cli
 Author: Altimate Inc

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/altimate_datapilot_cli.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ src/altimate_datapilot_cli.egg-info/requires.txt
 src/altimate_datapilot_cli.egg-info/top_level.txt
 src/datapilot/__init__.py
 src/datapilot/__main__.py
+src/datapilot/constants.py
 src/datapilot/cli/__init__.py
 src/datapilot/cli/main.py
 src/datapilot/clients/__init__.py
@@ -146,6 +147,9 @@ src/datapilot/core/platforms/dbt/insights/performance/__init__.py
 src/datapilot/core/platforms/dbt/insights/performance/base.py
 src/datapilot/core/platforms/dbt/insights/performance/chain_view_linking.py
 src/datapilot/core/platforms/dbt/insights/performance/exposure_parent_materializations.py
+src/datapilot/core/platforms/dbt/insights/sql/__init__.py
+src/datapilot/core/platforms/dbt/insights/sql/base.py
+src/datapilot/core/platforms/dbt/insights/sql/sql_check.py
 src/datapilot/core/platforms/dbt/insights/structure/__init__.py
 src/datapilot/core/platforms/dbt/insights/structure/base.py
 src/datapilot/core/platforms/dbt/insights/structure/model_directories_structure.py

altimate-datapilot-cli-0.0.15/src/altimate_datapilot_cli.egg-info/requires.txt

@@ -0,0 +1,6 @@
+click~=8.1.7
+dbt-artifacts-parser~=0.8.1
+ruamel.yaml~=0.18.6
+tabulate~=0.9.0
+requests~=2.31.0
+sqlglot~=25.30.0

altimate-datapilot-cli-0.0.15/src/datapilot/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.15"

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/clients/altimate/client.py

@@ -44,7 +44,7 @@ class APIClient:
             return response.json()
 
         except HTTPError as http_err:
-            self.logger.error(f"{http_err.response.json()} - Status code: {response.status_code}")
+            self.logger.debug(f"HTTP Error: {http_err.response.json()} - Status code: {response.status_code}")
         except ConnectionError as conn_err:
             self.logger.error(f"Connection error occurred: {conn_err}")
         except Timeout as timeout_err:
@@ -84,6 +84,23 @@ class APIClient:
         endpoint = "/dbt/v3/validate-credentials"
         return self.get(endpoint)
 
+    def validate_upload_to_integration(self):
+        endpoint = "/dbt/v1/validate-permissions"
+        return self.get(endpoint)
+
     def start_dbt_ingestion(self, params=None):
         endpoint = "/dbt/v1/start_dbt_ingestion"
         return self.post(endpoint, data=params)
+
+    def get_project_governance_llm_checks(self, params=None):
+        endpoint = "/project_governance/checks"
+        return self.get(endpoint, params=params)
+
+    def run_project_governance_llm_checks(self, manifest, catalog, check_names):
+        endpoint = "/project_governance/check/run"
+        data = {
+            "manifest": manifest,
+            "catalog": catalog,
+            "check_names": check_names,
+        }
+        return self.post(endpoint, data=data)

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/clients/altimate/utils.py

@@ -46,6 +46,15 @@ def validate_credentials(
     return api_client.validate_credentials()
 
 
+def validate_permissions(
+    token,
+    backend_url,
+    tenant,
+) -> Response:
+    api_client = APIClient(api_token=token, base_url=backend_url, tenant=tenant)
+    return api_client.validate_upload_to_integration()
+
+
 def onboard_file(api_token, tenant, dbt_core_integration_id, dbt_core_integration_environment, file_type, file_path, backend_url) -> Dict:
     api_client = APIClient(api_token, base_url=backend_url, tenant=tenant)
 
@@ -94,3 +103,24 @@ def start_dbt_ingestion(api_token, tenant, dbt_core_integration_id, dbt_core_int
             "ok": False,
             "message": "Error starting dbt ingestion worker.                                                                                                                              ",
         }
+
+
+def get_project_governance_llm_checks(
+    api_token,
+    tenant,
+    backend_url,
+):
+    api_client = APIClient(api_token=api_token, base_url=backend_url, tenant=tenant)
+    return api_client.get_project_governance_llm_checks()
+
+
+def run_project_governance_llm_checks(
+    api_token,
+    tenant,
+    backend_url,
+    manifest,
+    catalog,
+    check_names,
+):
+    api_client = APIClient(api_token=api_token, base_url=backend_url, tenant=tenant)
+    return api_client.run_project_governance_llm_checks(manifest, catalog, check_names)

altimate-datapilot-cli-0.0.15/src/datapilot/constants.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Extra(str, Enum):
+    allow = "allow"
+    forbid = "forbid"
+    ignore = "ignore"

altimate-datapilot-cli-0.0.15/src/datapilot/core/insights/sql/base/insight.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod
+
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+
+
+class SqlInsight(ChecksInsight):
+    NAME = "SqlInsight"
+
+    @abstractmethod
+    def generate(self, *args, **kwargs) -> dict:
+        pass

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/cli/cli.py

@@ -6,6 +6,7 @@ from datapilot.clients.altimate.utils import check_token_and_instance
 from datapilot.clients.altimate.utils import onboard_file
 from datapilot.clients.altimate.utils import start_dbt_ingestion
 from datapilot.clients.altimate.utils import validate_credentials
+from datapilot.clients.altimate.utils import validate_permissions
 from datapilot.config.config import load_config
 from datapilot.core.platforms.dbt.constants import MODEL
 from datapilot.core.platforms.dbt.constants import PROJECT
@@ -27,6 +28,8 @@ def dbt():
 
 
 @dbt.command("project-health")
+@click.option("--token", required=False, help="Your API token for authentication.")
+@click.option("--instance-name", required=False, help="Your tenant ID.")
 @click.option(
     "--manifest-path",
     required=True,
@@ -48,7 +51,10 @@ def dbt():
     default=None,
     help="Selective model testing. Specify one or more models to run tests on.",
 )
-def project_health(manifest_path, catalog_path, config_path=None, select=None):
+@click.option("--backend-url", required=False, help="Altimate's Backend URL", default="https://api.myaltimate.com")
+def project_health(
+    token, instance_name, manifest_path, catalog_path, config_path=None, select=None, backend_url="https://api.myaltimate.com"
+):
     """
     Validate the DBT project's configuration and structure.
     :param manifest_path: Path to the DBT manifest file.
@@ -61,7 +67,16 @@ def project_health(manifest_path, catalog_path, config_path=None, select=None):
         selected_models = select.split(" ")
     manifest = load_manifest(manifest_path)
     catalog = load_catalog(catalog_path) if catalog_path else None
-    insight_generator = DBTInsightGenerator(manifest=manifest, catalog=catalog, config=config, selected_models=selected_models)
+
+    insight_generator = DBTInsightGenerator(
+        manifest=manifest,
+        catalog=catalog,
+        config=config,
+        selected_models=selected_models,
+        token=token,
+        instance_name=instance_name,
+        backend_url=backend_url,
+    )
     reports = insight_generator.run()
 
     package_insights = reports[PROJECT]
@@ -111,6 +126,10 @@ def onboard(
         click.echo("Error: Invalid credentials.")
         return
 
+    if not validate_permissions(token, backend_url, instance_name):
+        click.echo("Error: You don't have permission to perform this action.")
+        return
+
     # This will throw error if manifest file is incorrect
     try:
         load_manifest(manifest_path)

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/constants.py

@@ -4,6 +4,8 @@ TEST = "test"
 MODEL = "model"
 SOURCE = "source"
 
+LLM = "llm"
+
 
 PROJECT = "project"
 SQL = "sql"

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/executor.py

@@ -5,11 +5,16 @@ from typing import Dict
 from typing import List
 from typing import Optional
 
+from datapilot.clients.altimate.utils import get_project_governance_llm_checks
+from datapilot.clients.altimate.utils import run_project_governance_llm_checks
+from datapilot.core.platforms.dbt.constants import LLM
 from datapilot.core.platforms.dbt.constants import MODEL
 from datapilot.core.platforms.dbt.constants import PROJECT
 from datapilot.core.platforms.dbt.exceptions import AltimateCLIArgumentError
 from datapilot.core.platforms.dbt.factory import DBTFactory
 from datapilot.core.platforms.dbt.insights import INSIGHTS
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
 from datapilot.core.platforms.dbt.schemas.manifest import Catalog
 from datapilot.core.platforms.dbt.schemas.manifest import Manifest
 from datapilot.core.platforms.dbt.utils import get_models
@@ -29,11 +34,19 @@ class DBTInsightGenerator:
         target: str = "dev",
         selected_models: Optional[str] = None,
         selected_model_ids: Optional[List[str]] = None,
+        token: Optional[str] = None,
+        instance_name: Optional[str] = None,
+        backend_url: Optional[str] = None,
     ):
         self.run_results_path = run_results_path
         self.target = target
         self.env = env
         self.config = config or {}
+        self.token = token
+        self.instance_name = instance_name
+        self.backend_url = backend_url
+        self.manifest = manifest
+        self.catalog = catalog
 
         self.manifest_wrapper = DBTFactory.get_manifest_wrapper(manifest)
         self.manifest_present = True
@@ -51,6 +64,7 @@ class DBTInsightGenerator:
         self.macros = self.manifest_wrapper.get_macros()
         self.sources = self.manifest_wrapper.get_sources()
         self.exposures = self.manifest_wrapper.get_exposures()
+        self.adapter_type = self.manifest_wrapper.get_adapter_type()
         self.seeds = self.manifest_wrapper.get_seeds()
         self.children_map = self.manifest_wrapper.parent_to_child_map(self.nodes)
         self.tests = self.manifest_wrapper.get_tests()
@@ -85,6 +99,22 @@ class DBTInsightGenerator:
                 return True
         return False
 
+    def run_llm_checks(self):
+        llm_checks = get_project_governance_llm_checks(self.token, self.instance_name, self.backend_url)
+        check_names = [check["name"] for check in llm_checks if check["alias"] not in self.config.get("disabled_insights", [])]
+        if len(check_names) == 0:
+            return {"results": []}
+
+        llm_check_results = run_project_governance_llm_checks(
+            self.token,
+            self.instance_name,
+            self.backend_url,
+            self.manifest.json() if self.manifest else "",
+            self.catalog.json() if self.catalog else "",
+            check_names,
+        )
+        return llm_check_results
+
     def run(self):
         reports = {
             MODEL: {},
@@ -112,6 +142,7 @@ class DBTInsightGenerator:
                     children_map=self.children_map,
                     tests=self.tests,
                     project_name=self.project_name,
+                    adapter_type=self.adapter_type,
                     config=self.config,
                     selected_models=self.selected_models,
                     excluded_models=self.excluded_models,
@@ -154,4 +185,42 @@ class DBTInsightGenerator:
             else:
                 self.logger.info(color_text(f"Skipping insight {insight_class.NAME} as {message}", YELLOW))
 
+        if self.token and self.instance_name and self.backend_url:
+            llm_check_results = self.run_llm_checks()
+            llm_reports = llm_check_results.get("results", [])
+            llm_insights = {}
+            for report in llm_reports:
+                for answer in report["answer"]:
+                    location = answer["unique_id"]
+                    if location not in llm_insights:
+                        llm_insights[location] = []
+                        metadata = answer.get("metadata", {})
+                        metadata["source"] = LLM
+                        metadata["teammate_check_id"] = report["id"]
+                        metadata["category"] = report["type"]
+                    llm_insights[location].append(
+                        DBTModelInsightResponse(
+                            insight=DBTInsightResult(
+                                type="Custom",
+                                name=report["name"],
+                                message=answer["message"],
+                                reason_to_flag=answer["reason_to_flag"],
+                                recommendation=answer["recommendation"],
+                                metadata=metadata,
+                            ),
+                            severity=answer["severity"],
+                            path=answer["path"] if answer.get("path") else "",
+                            original_file_path=answer["original_file_path"] if answer.get("original_file_path") else "",
+                            package_name=answer["package_name"] if answer.get("package_name") else "",
+                            unique_id=answer["unique_id"],
+                        )
+                    )
+
+            if llm_insights:
+                for key, value in llm_insights.items():
+                    if key in reports[MODEL]:
+                        reports[MODEL][key].extend(value)
+                    else:
+                        reports[MODEL][key] = value
+
         return reports

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/__init__.py

@@ -51,6 +51,7 @@ from datapilot.core.platforms.dbt.insights.modelling.staging_model_dependent_on_
 from datapilot.core.platforms.dbt.insights.modelling.unused_sources import DBTUnusedSources
 from datapilot.core.platforms.dbt.insights.performance.chain_view_linking import DBTChainViewLinking
 from datapilot.core.platforms.dbt.insights.performance.exposure_parent_materializations import DBTExposureParentMaterialization
+from datapilot.core.platforms.dbt.insights.sql.sql_check import SqlCheck
 from datapilot.core.platforms.dbt.insights.structure.model_directories_structure import DBTModelDirectoryStructure
 from datapilot.core.platforms.dbt.insights.structure.model_naming_conventions import DBTModelNamingConvention
 from datapilot.core.platforms.dbt.insights.structure.source_directories_structure import DBTSourceDirectoryStructure
@@ -112,4 +113,5 @@ INSIGHTS = [
     CheckSourceHasTests,
     CheckSourceTableHasDescription,
     CheckSourceTags,
+    SqlCheck,
 ]

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/base.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import ClassVar
 from typing import Dict
 from typing import List
+from typing import Optional
 from typing import Union
 
 from datapilot.config.utils import get_insight_config
@@ -33,6 +34,7 @@ class DBTInsight(Insight):
         macros: Dict[str, AltimateManifestMacroNode],
         children_map: Dict[str, List[str]],
         project_name: str,
+        adapter_type: Optional[str],
         selected_models: Union[List[str], None] = None,
         excluded_models: Union[List[str], None] = None,
         *args,
@@ -47,6 +49,7 @@ class DBTInsight(Insight):
         self.seeds = seeds
         self.children_map = children_map
         self.project_name = project_name
+        self.adapter_type = adapter_type
         self.selected_models = selected_models
         self.excluded_models = excluded_models
         super().__init__(*args, **kwargs)

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/checks/check_model_has_labels_keys.py

@@ -76,7 +76,7 @@ class CheckModelHasLabelsKeys(ChecksInsight):
     def _check_labels_keys(self, node_id) -> Tuple[int, Set[str]]:
         status_code = 0
         missing_keys = set(self.labels_keys) - set(self.get_node(node_id).label)
-        config = self.get_node(node_id).config.dict() if self.get_node(node_id).config else {}
+        config = self.get_node(node_id).config.model_dump() if self.get_node(node_id).config else {}
         labels = config.get("labels", {})
         label_keys = set(labels.keys())
         extra_keys = set()

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/checks/check_model_has_meta_keys.py

@@ -72,7 +72,7 @@ class CheckModelHasMetaKeys(ChecksInsight):
     def _check_meta_keys(self, node_id) -> Tuple[int, Set[str], Set[str]]:
         status_code = 0
         model = self.get_node(node_id)
-        meta = model.meta.dict() if model.meta else {}
+        meta = model.meta if model.meta else {}
         model_meta_keys = set(meta.keys())
         missing_keys = None
         extra_keys = None

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/checks/check_source_has_freshness.py

@@ -61,7 +61,7 @@ class CheckSourceHasFreshness(ChecksInsight):
 
     def _check_source_has_freshness(self, source_id: str) -> List[str]:
         source = self.get_node(source_id)
-        freshness = source.freshness.dict() if source.freshness else {}
+        freshness = source.freshness.model_dump() if source.freshness else {}
 
         if not freshness:
             return False

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/checks/check_source_has_labels_keys.py

@@ -74,7 +74,7 @@ class CheckSourceHasLabelsKeys(ChecksInsight):
     def _check_labels_keys(self, node_id) -> Tuple[int, Set[str]]:
         status_code = 0
         missing_keys = set(self.labels_keys) - set(self.get_node(node_id).label)
-        config = self.get_node(node_id).config.dict() if self.get_node(node_id).config else {}
+        config = self.get_node(node_id).config.model_dump() if self.get_node(node_id).config else {}
         labels = config.get("labels", {})
         label_keys = set(labels.keys())
         extra_keys = set()

{altimate-datapilot-cli-0.0.13 → altimate-datapilot-cli-0.0.15}/src/datapilot/core/platforms/dbt/insights/checks/check_source_has_meta_keys.py

@@ -81,7 +81,7 @@ class CheckSourceHasMetaKeys(ChecksInsight):
     def _check_source_has_meta_keys(self, source_unique_id: str):
         status_code = 0
         model = self.get_node(source_unique_id)
-        meta = model.meta.dict() if model.meta else {}
+        meta = model.meta if model.meta else {}
         model_meta_keys = set(meta.keys())
         missing_keys = None
         extra_keys = None

altimate-datapilot-cli-0.0.15/src/datapilot/core/platforms/dbt/insights/sql/base.py

@@ -0,0 +1,23 @@
+from abc import abstractmethod
+from typing import Tuple
+
+from datapilot.core.platforms.dbt.insights.base import DBTInsight
+
+
+class SqlInsight(DBTInsight):
+    TYPE = "governance"
+
+    @abstractmethod
+    def generate(self, *args, **kwargs) -> dict:
+        pass
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: bool, **kwargs) -> Tuple[bool, str]:
+        """
+        Check if all required data is available for the insight to run.
+        :param has_manifest: A boolean indicating if manifest is available.
+        :return: A boolean indicating if all required data is available.
+        """
+        if not has_manifest:
+            return False, "manifest is required for insight to run."
+        return True, ""

altimate-datapilot-cli-0.0.15/src/datapilot/core/platforms/dbt/insights/sql/sql_check.py

@@ -0,0 +1,101 @@
+import inspect
+from typing import List
+
+from sqlglot import parse_one
+from sqlglot.optimizer.eliminate_ctes import eliminate_ctes
+from sqlglot.optimizer.eliminate_joins import eliminate_joins
+from sqlglot.optimizer.eliminate_subqueries import eliminate_subqueries
+from sqlglot.optimizer.normalize import normalize
+from sqlglot.optimizer.pushdown_projections import pushdown_projections
+from sqlglot.optimizer.qualify import qualify
+from sqlglot.optimizer.unnest_subqueries import unnest_subqueries
+
+from datapilot.core.insights.sql.base.insight import SqlInsight
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+
+RULES = (
+    pushdown_projections,
+    normalize,
+    unnest_subqueries,
+    eliminate_subqueries,
+    eliminate_joins,
+    eliminate_ctes,
+)
+
+
+class SqlCheck(SqlInsight):
+    """
+    This class identifies DBT models with SQL optimization issues.
+    """
+
+    NAME = "sql optimization issues"
+    ALIAS = "check_sql_optimization"
+    DESCRIPTION = "Checks if the model has SQL optimization issues. "
+    REASON_TO_FLAG = "The query can be optimized."
+    FAILURE_MESSAGE = "The query for model `{model_unique_id}` has optimization opportunities:\n{rule_name}. "
+    RECOMMENDATION = "Please adapt the query of the model `{model_unique_id}` as in following example:\n{optimized_sql}"
+
+    def _build_failure_result(self, model_unique_id: str, rule_name: str, optimized_sql: str) -> DBTInsightResult:
+        """
+        Constructs a failure result for a given model with sql optimization issues.
+        :param model_unique_id: The unique id of the dbt model.
+        :param rule_name: The rule that generated this failure result.
+        :param optimized_sql: The optimized sql.
+        :return: An instance of DBTInsightResult containing failure details.
+        """
+        failure_message = self.FAILURE_MESSAGE.format(model_unique_id=model_unique_id, rule_name=rule_name)
+        recommendation = self.RECOMMENDATION.format(model_unique_id=model_unique_id, optimized_sql=optimized_sql)
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id, "rule_name": rule_name},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generates insights for each DBT model in the project, focusing on sql optimization issues.
+
+        :return: A list of DBTModelInsightResponse objects with insights for each model.
+        """
+        self.logger.debug("Generating sql insights for DBT models")
+        insights = []
+
+        possible_kwargs = {
+            "db": None,
+            "catalog": None,
+            "dialect": self.adapter_type,
+            "isolate_tables": True,  # needed for other optimizations to perform well
+            "quote_identifiers": False,
+            **kwargs,
+        }
+        for node_id, node in self.nodes.items():
+            try:
+                compiled_query = node.compiled_code
+                if compiled_query:
+                    parsed_query = parse_one(compiled_query, dialect=self.adapter_type)
+                    qualified = qualify(parsed_query, **possible_kwargs)
+                    changed = qualified.copy()
+                    for rule in RULES:
+                        original = changed.copy()
+                        rule_params = inspect.getfullargspec(rule).args
+                        rule_kwargs = {param: possible_kwargs[param] for param in rule_params if param in possible_kwargs}
+                        changed = rule(changed, **rule_kwargs)
+                        if changed.sql() != original.sql():
+                            insights.append(
+                                DBTModelInsightResponse(
+                                    unique_id=node_id,
+                                    package_name=node.package_name,
+                                    path=node.original_file_path,
+                                    original_file_path=node.original_file_path,
+                                    insight=self._build_failure_result(node_id, rule.__name__, changed.sql()),
+                                    severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                                )
+                            )
+            except Exception as e:
+                self.logger.error(e)
+        return insights