You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by be...@apache.org on 2025/11/24 20:57:15 UTC

(superset) branch explorable-protocol updated (ed680f0407 -> ca5f456a1c)

This is an automated email from the ASF dual-hosted git repository.

beto pushed a change to branch explorable-protocol
in repository https://gitbox.apache.org/repos/asf/superset.git


 discard ed680f0407 Fix lint
     new ca5f456a1c Fix lint

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (ed680f0407)
            \
             N -- N -- N   refs/heads/explorable-protocol (ca5f456a1c)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 superset/explorables/base.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)


(superset) 01/01: Fix lint

Posted by be...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

beto pushed a commit to branch explorable-protocol
in repository https://gitbox.apache.org/repos/asf/superset.git

commit ca5f456a1cc988898801fdbc7e18d2c728997449
Author: Beto Dealmeida <ro...@dealmeida.net>
AuthorDate: Mon Nov 24 15:54:22 2025 -0500

    Fix lint
---
 .../chart/data/streaming_export_command.py         |  9 ++-
 superset/common/query_actions.py                   |  4 +-
 superset/common/query_context_factory.py           |  2 +-
 superset/common/query_context_processor.py         |  2 +-
 superset/connectors/sqla/models.py                 | 26 ++++++++
 superset/explorables/base.py                       | 53 ++++++++++++++--
 superset/security/manager.py                       | 74 +++++++++++++++-------
 superset/thumbnails/digest.py                      |  2 +-
 superset/utils/core.py                             |  8 ++-
 tests/unit_tests/common/test_time_shifts.py        | 34 ++++------
 10 files changed, 155 insertions(+), 59 deletions(-)

diff --git a/superset/commands/chart/data/streaming_export_command.py b/superset/commands/chart/data/streaming_export_command.py
index b6ec3a3669..28764c3ae8 100644
--- a/superset/commands/chart/data/streaming_export_command.py
+++ b/superset/commands/chart/data/streaming_export_command.py
@@ -68,7 +68,14 @@ class StreamingCSVExportCommand(BaseStreamingCSVExportCommand):
         query_obj = self._query_context.queries[0]
         sql_query = datasource.get_query_str(query_obj.to_dict())
 
-        return sql_query, datasource.database
+        # Chart export is SQL-specific, so we check for BaseDatasource
+        from superset.connectors.sqla.models import BaseDatasource
+
+        database = (
+            datasource.database if isinstance(datasource, BaseDatasource) else None
+        )
+
+        return sql_query, database
 
     def _get_row_limit(self) -> int | None:
         """
diff --git a/superset/common/query_actions.py b/superset/common/query_actions.py
index ef7485842e..d59804ff61 100644
--- a/superset/common/query_actions.py
+++ b/superset/common/query_actions.py
@@ -38,9 +38,7 @@ if TYPE_CHECKING:
     from superset.common.query_object import QueryObject
 
 
-def _get_datasource(
-    query_context: QueryContext, query_obj: QueryObject
-) -> Explorable:
+def _get_datasource(query_context: QueryContext, query_obj: QueryObject) -> Explorable:
     return query_obj.datasource or query_context.datasource
 
 
diff --git a/superset/common/query_context_factory.py b/superset/common/query_context_factory.py
index 52884365ff..7b61cf6ea9 100644
--- a/superset/common/query_context_factory.py
+++ b/superset/common/query_context_factory.py
@@ -16,7 +16,7 @@
 # under the License.
 from __future__ import annotations
 
-from typing import Any, TYPE_CHECKING
+from typing import Any
 
 from flask import current_app
 
diff --git a/superset/common/query_context_processor.py b/superset/common/query_context_processor.py
index 615984e13d..eec2275a23 100644
--- a/superset/common/query_context_processor.py
+++ b/superset/common/query_context_processor.py
@@ -30,13 +30,13 @@ from superset.common.query_actions import get_query_results
 from superset.common.utils.query_cache_manager import QueryCacheManager
 from superset.common.utils.time_range_utils import get_since_until_from_time_range
 from superset.constants import CACHE_DISABLED_TIMEOUT, CacheRegion
-from superset.explorables.base import Explorable
 from superset.daos.annotation_layer import AnnotationLayerDAO
 from superset.daos.chart import ChartDAO
 from superset.exceptions import (
     QueryObjectValidationError,
     SupersetException,
 )
+from superset.explorables.base import Explorable
 from superset.extensions import cache_manager, security_manager
 from superset.models.helpers import QueryResult
 from superset.superset_typing import AdhocColumn, AdhocMetric
diff --git a/superset/connectors/sqla/models.py b/superset/connectors/sqla/models.py
index 1cdce4f78b..0ed18ed851 100644
--- a/superset/connectors/sqla/models.py
+++ b/superset/connectors/sqla/models.py
@@ -234,6 +234,32 @@ class BaseDatasource(
         """Set the datasource-specific cache timeout."""
         self._cache_timeout = value
 
+    def has_drill_by_columns(self, column_names: list[str]) -> bool:
+        """
+        Check if the specified columns support drill-by operations.
+
+        For SQL datasources, drill-by is supported on columns that are marked
+        as groupable in the metadata. This allows users to navigate from
+        aggregated views to detailed data by grouping on these dimensions.
+
+        :param column_names: List of column names to check
+        :return: True if all columns support drill-by, False otherwise
+        """
+        if not column_names:
+            return False
+
+        # Get all groupable column names for this datasource
+        drillable_columns = {
+            row[0]
+            for row in db.session.query(TableColumn.column_name)
+            .filter(TableColumn.table_id == self.id)
+            .filter(TableColumn.groupby)
+            .all()
+        }
+
+        # Check if all requested columns are drillable
+        return set(column_names).issubset(drillable_columns)
+
     @property
     def kind(self) -> DatasourceKind:
         return DatasourceKind.VIRTUAL if self.sql else DatasourceKind.PHYSICAL
diff --git a/superset/explorables/base.py b/superset/explorables/base.py
index 716964fbd4..eb1d678d56 100644
--- a/superset/explorables/base.py
+++ b/superset/explorables/base.py
@@ -262,10 +262,26 @@ class Explorable(Protocol):
         Example return value:
         ```python
         [
-            {"name": "Second", "function": "DATE_TRUNC('second', {col})", "duration": "PT1S"},
-            {"name": "Minute", "function": "DATE_TRUNC('minute', {col})", "duration": "PT1M"},
-            {"name": "Hour", "function": "DATE_TRUNC('hour', {col})", "duration": "PT1H"},
-            {"name": "Day", "function": "DATE_TRUNC('day', {col})", "duration": "P1D"},
+            {
+                "name": "Second",
+                "function": "DATE_TRUNC('second', {col})",
+                "duration": "PT1S",
+            },
+            {
+                "name": "Minute",
+                "function": "DATE_TRUNC('minute', {col})",
+                "duration": "PT1M",
+            },
+            {
+                "name": "Hour",
+                "function": "DATE_TRUNC('hour', {col})",
+                "duration": "PT1H",
+            },
+            {
+                "name": "Day",
+                "function": "DATE_TRUNC('day', {col})",
+                "duration": "P1D",
+            },
         ]
         ```
 
@@ -276,17 +292,42 @@ class Explorable(Protocol):
     # Optional Properties
     # =========================================================================
 
+    # =========================================================================
+    # Required Methods
+    # =========================================================================
+
+    def has_drill_by_columns(self, column_names: list[str]) -> bool:
+        """
+        Check if the specified columns support drill-by operations.
+
+        Drill-by allows users to navigate from aggregated views to detailed
+        data by grouping on specific dimensions. This method determines whether
+        the given columns can be used for drill-by in the current datasource.
+
+        For SQL datasources, this typically checks if columns are marked as
+        groupable in the metadata. For semantic views, it checks against the
+        semantic layer's dimension definitions.
+
+        :param column_names: List of column names to check
+        :return: True if all columns support drill-by, False otherwise
+        """
+
+    # =========================================================================
+    # Optional Properties
+    # =========================================================================
+
     @property
     def is_rls_supported(self) -> bool:
         """
         Whether this explorable supports Row Level Security.
 
         Row Level Security (RLS) allows filtering data based on user identity.
-        SQL-based datasources typically support this, while semantic layers
-        may handle security at a different level.
+        SQL-based datasources typically support this via SQL queries, while
+        semantic layers may handle security at the semantic layer level.
 
         :return: True if RLS is supported, False otherwise
         """
+        return False
 
     @property
     def query_language(self) -> str | None:
diff --git a/superset/security/manager.py b/superset/security/manager.py
index dc41a5b99b..6ffef7fcdd 100644
--- a/superset/security/manager.py
+++ b/superset/security/manager.py
@@ -632,10 +632,10 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
 
         :param form_data: The form_data included in the request.
         :param dashboard: The dashboard the user is drilling from.
-        :returns: Whether the user has drill byaccess.
+        :param datasource: The datasource being queried
+        :returns: Whether the user has drill by access.
         """
 
-        from superset.connectors.sqla.models import TableColumn
         from superset.models.slice import Slice
 
         return bool(
@@ -650,17 +650,7 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
             and slc in dashboard.slices
             and slc.datasource == datasource
             and (dimensions := form_data.get("groupby"))
-            and (datasource_id := getattr(datasource, "id", None))
-            and (
-                drillable_columns := {
-                    row[0]
-                    for row in self.session.query(TableColumn.column_name)
-                    .filter(TableColumn.table_id == datasource_id)
-                    .filter(TableColumn.groupby)
-                    .all()
-                }
-            )
-            and set(dimensions).issubset(drillable_columns)
+            and datasource.has_drill_by_columns(dimensions)
         )
 
     def can_access_dashboard(self, dashboard: "Dashboard") -> bool:
@@ -726,7 +716,9 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
         )
 
     @staticmethod
-    def get_datasource_access_error_msg(datasource: "BaseDatasource | Explorable") -> str:
+    def get_datasource_access_error_msg(
+        datasource: "BaseDatasource | Explorable",
+    ) -> str:
         """
         Return the error message for the denied Superset datasource.
 
@@ -734,7 +726,11 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
         :returns: The error message
         """
 
-        datasource_id = getattr(datasource, "id", datasource.data.get("id") if hasattr(datasource, "data") else None)
+        datasource_id = getattr(
+            datasource,
+            "id",
+            datasource.data.get("id") if hasattr(datasource, "data") else None,
+        )
         return (
             f"This endpoint requires the datasource {datasource_id}, "
             "database or `all_datasource_access` permission"
@@ -768,8 +764,18 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
             level=ErrorLevel.WARNING,
             extra={
                 "link": self.get_datasource_access_link(datasource),
-                "datasource": getattr(datasource, "id", datasource.data.get("id") if hasattr(datasource, "data") else None),
-                "datasource_name": getattr(datasource, "name", datasource.data.get("name") if hasattr(datasource, "data") else None),
+                "datasource": getattr(
+                    datasource,
+                    "id",
+                    datasource.data.get("id") if hasattr(datasource, "data") else None,
+                ),
+                "datasource_name": getattr(
+                    datasource,
+                    "name",
+                    datasource.data.get("name")
+                    if hasattr(datasource, "data")
+                    else None,
+                ),
             },
         )
 
@@ -2367,8 +2373,11 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
                 # If the DB engine spec doesn't implement the logic the schema is read
                 # from the SQLAlchemy URI if possible; if not, we use the SQLAlchemy
                 # inspector to read it.
+                from superset.models.sql_lab import Query
+
                 default_schema = database.get_default_schema_for_query(
-                    query, template_params  # type: ignore[arg-type]
+                    cast(Query, query),
+                    template_params,
                 )
                 tables = {
                     table_.qualify(
@@ -2480,7 +2489,14 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
                             and dashboard_.json_metadata
                             and (json_metadata := json.loads(dashboard_.json_metadata))
                             and any(
-                                target.get("datasetId") == getattr(datasource, "id", datasource.data.get("id") if hasattr(datasource, "data") else None)
+                                target.get("datasetId")
+                                == getattr(
+                                    datasource,
+                                    "id",
+                                    datasource.data.get("id")
+                                    if hasattr(datasource, "data")
+                                    else None,
+                                )
                                 for fltr in json_metadata.get(
                                     "native_filter_configuration",
                                     [],
@@ -2594,7 +2610,11 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
         :return: A list of filters
         """
         if guest_user := self.get_current_guest_user_if_guest():
-            dataset_id = getattr(dataset, "id", dataset.data.get("id") if hasattr(dataset, "data") else None)
+            dataset_id = getattr(
+                dataset,
+                "id",
+                dataset.data.get("id") if hasattr(dataset, "data") else None,
+            )
             return [
                 rule
                 for rule in guest_user.rls
@@ -2639,7 +2659,9 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
             )
             .filter(RLSFilterRoles.c.role_id.in_(user_roles))
         )
-        table_id = getattr(table, "id", table.data.get("id") if hasattr(table, "data") else None)
+        table_id = getattr(
+            table, "id", table.data.get("id") if hasattr(table, "data") else None
+        )
         filter_tables = self.session.query(RLSFilterTables.c.rls_filter_id).filter(
             RLSFilterTables.c.table_id == table_id
         )
@@ -2667,7 +2689,9 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
         )
         return query.all()
 
-    def get_rls_sorted(self, table: "BaseDatasource | Explorable") -> list["RowLevelSecurityFilter"]:
+    def get_rls_sorted(
+        self, table: "BaseDatasource | Explorable"
+    ) -> list["RowLevelSecurityFilter"]:
         """
         Retrieves a list RLS filters sorted by ID for
         the current user and the passed table.
@@ -2679,12 +2703,14 @@ class SupersetSecurityManager(  # pylint: disable=too-many-public-methods
         filters.sort(key=lambda f: f.id)
         return filters
 
-    def get_guest_rls_filters_str(self, table: "BaseDatasource | Explorable") -> list[str]:
+    def get_guest_rls_filters_str(
+        self, table: "BaseDatasource | Explorable"
+    ) -> list[str]:
         return [f.get("clause", "") for f in self.get_guest_rls_filters(table)]
 
     def get_rls_cache_key(self, datasource: "Explorable | BaseDatasource") -> list[str]:
         rls_clauses_with_group_key = []
-        if hasattr(datasource, "is_rls_supported") and datasource.is_rls_supported:
+        if datasource.is_rls_supported:
             rls_clauses_with_group_key = [
                 f"{f.clause}-{f.group_key or ''}"
                 for f in self.get_rls_sorted(datasource)
diff --git a/superset/thumbnails/digest.py b/superset/thumbnails/digest.py
index 31a179fd93..f83a50d23c 100644
--- a/superset/thumbnails/digest.py
+++ b/superset/thumbnails/digest.py
@@ -72,7 +72,7 @@ def _adjust_string_with_rls(
             for datasource in datasources:
                 if (
                     datasource
-                    and hasattr(datasource, "is_rls_supported")
+                    and isinstance(datasource, BaseDatasource)
                     and datasource.is_rls_supported
                 ):
                     rls_filters = datasource.get_sqla_row_level_filters()
diff --git a/superset/utils/core.py b/superset/utils/core.py
index 7ff6021f06..bf0b97bbb4 100644
--- a/superset/utils/core.py
+++ b/superset/utils/core.py
@@ -1657,7 +1657,9 @@ def map_sql_type_to_inferred_type(sql_type: Optional[str]) -> str:
     return "string"  # If no match is found, return "string" as default
 
 
-def get_metric_type_from_column(column: Any, datasource: BaseDatasource | Explorable | Query) -> str:
+def get_metric_type_from_column(
+    column: Any, datasource: BaseDatasource | Explorable | Query
+) -> str:
     """
     Determine the metric type from a given column in a datasource.
 
@@ -1778,7 +1780,9 @@ def get_time_filter_status(
     applied_time_extras: dict[str, str],
 ) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
     temporal_columns: set[Any] = {
-        (col.column_name if hasattr(col, "column_name") else col.get("column_name")) for col in datasource.columns if (col.is_dttm if hasattr(col, "is_dttm") else col.get("is_dttm"))
+        (col.column_name if hasattr(col, "column_name") else col.get("column_name"))
+        for col in datasource.columns
+        if (col.is_dttm if hasattr(col, "is_dttm") else col.get("is_dttm"))
     }
     applied: list[dict[str, str]] = []
     rejected: list[dict[str, str]] = []
diff --git a/tests/unit_tests/common/test_time_shifts.py b/tests/unit_tests/common/test_time_shifts.py
index f65b9d93ee..08b6478c48 100644
--- a/tests/unit_tests/common/test_time_shifts.py
+++ b/tests/unit_tests/common/test_time_shifts.py
@@ -39,32 +39,26 @@ processor = QueryContextProcessor(
 )
 
 # Bind ExploreMixin methods to datasource for testing
-processor._qc_datasource.add_offset_join_column = (
-    ExploreMixin.add_offset_join_column.__get__(processor._qc_datasource)
+# Type annotation needed because _qc_datasource is typed as Explorable in protocol
+_datasource: BaseDatasource = processor._qc_datasource  # type: ignore
+_datasource.add_offset_join_column = ExploreMixin.add_offset_join_column.__get__(
+    _datasource
 )
-processor._qc_datasource.join_offset_dfs = ExploreMixin.join_offset_dfs.__get__(
-    processor._qc_datasource
+_datasource.join_offset_dfs = ExploreMixin.join_offset_dfs.__get__(_datasource)
+_datasource.is_valid_date_range = ExploreMixin.is_valid_date_range.__get__(_datasource)
+_datasource._determine_join_keys = ExploreMixin._determine_join_keys.__get__(
+    _datasource
 )
-processor._qc_datasource.is_valid_date_range = ExploreMixin.is_valid_date_range.__get__(
-    processor._qc_datasource
-)
-processor._qc_datasource._determine_join_keys = (
-    ExploreMixin._determine_join_keys.__get__(processor._qc_datasource)
-)
-processor._qc_datasource._perform_join = ExploreMixin._perform_join.__get__(
-    processor._qc_datasource
-)
-processor._qc_datasource._apply_cleanup_logic = (
-    ExploreMixin._apply_cleanup_logic.__get__(processor._qc_datasource)
+_datasource._perform_join = ExploreMixin._perform_join.__get__(_datasource)
+_datasource._apply_cleanup_logic = ExploreMixin._apply_cleanup_logic.__get__(
+    _datasource
 )
 # Static methods don't need binding - assign directly
-processor._qc_datasource.generate_join_column = ExploreMixin.generate_join_column
-processor._qc_datasource.is_valid_date_range_static = (
-    ExploreMixin.is_valid_date_range_static
-)
+_datasource.generate_join_column = ExploreMixin.generate_join_column
+_datasource.is_valid_date_range_static = ExploreMixin.is_valid_date_range_static
 
 # Convenience reference for backward compatibility in tests
-query_context_processor = processor._qc_datasource
+query_context_processor = _datasource
 
 
 @fixture