chore: Migrate /superset/tables/* to API v1 (#22501)

superset/databases/api.py

@@ -44,11 +44,13 @@ from superset.databases.commands.exceptions import (
     DatabaseDeleteFailedError,
     DatabaseInvalidError,
     DatabaseNotFoundError,
+    DatabaseTablesUnexpectedError,
     DatabaseUpdateFailedError,
     InvalidParametersError,
 )
 from superset.databases.commands.export import ExportDatabasesCommand
 from superset.databases.commands.importers.dispatcher import ImportDatabasesCommand
+from superset.databases.commands.tables import TablesDatabaseCommand
 from superset.databases.commands.test_connection import TestConnectionDatabaseCommand
 from superset.databases.commands.update import UpdateDatabaseCommand
 from superset.databases.commands.validate import ValidateDatabaseParametersCommand
@@ -58,10 +60,12 @@ from superset.databases.decorators import check_datasource_access
 from superset.databases.filters import DatabaseFilter, DatabaseUploadEnabledFilter
 from superset.databases.schemas import (
     database_schemas_query_schema,
+    database_tables_query_schema,
     DatabaseFunctionNamesResponse,
     DatabasePostSchema,
     DatabasePutSchema,
     DatabaseRelatedObjectsResponse,
+    DatabaseTablesResponse,
     DatabaseTestConnectionSchema,
     DatabaseValidateParametersSchema,
     get_export_ids_schema,
@@ -104,6 +108,7 @@ class DatabaseRestApi(BaseSupersetModelRestApi):
     include_route_methods = RouteMethod.REST_MODEL_VIEW_CRUD_SET | {
         RouteMethod.EXPORT,
         RouteMethod.IMPORT,
+        "tables",
         "table_metadata",
         "table_extra_metadata",
         "select_star",
@@ -210,6 +215,7 @@ class DatabaseRestApi(BaseSupersetModelRestApi):
 
     apispec_parameter_schemas = {
         "database_schemas_query_schema": database_schemas_query_schema,
+        "database_tables_query_schema": database_tables_query_schema,
         "get_export_ids_schema": get_export_ids_schema,
     }
 
@@ -217,6 +223,7 @@ class DatabaseRestApi(BaseSupersetModelRestApi):
     openapi_spec_component_schemas = (
         DatabaseFunctionNamesResponse,
         DatabaseRelatedObjectsResponse,
+        DatabaseTablesResponse,
         DatabaseTestConnectionSchema,
         DatabaseValidateParametersSchema,
         TableExtraMetadataResponseSchema,
@@ -555,6 +562,73 @@ class DatabaseRestApi(BaseSupersetModelRestApi):
         except SupersetException as ex:
             return self.response(ex.status, message=ex.message)
 
+    @expose("/<int:pk>/tables/")
+    @protect()
+    @safe
+    @rison(database_tables_query_schema)
+    @statsd_metrics
+    @event_logger.log_this_with_context(
+        action=lambda self, *args, **kwargs: f"{self.__class__.__name__}" f".tables",
+        log_to_statsd=False,
+    )
+    def tables(self, pk: int, **kwargs: Any) -> FlaskResponse:
+        """Get a list of tables for given database
+        ---
+        get:
+          summary: Get a list of tables for given database
+          parameters:
+          - in: path
+            schema:
+              type: integer
+            name: pk
+            description: The database id
+          - in: query
+            name: q
+            content:
+              application/json:
+                schema:
+                  $ref: '#/components/schemas/database_tables_query_schema'
+          responses:
+            200:
+              description: Tables list
+              content:
+                application/json:
+                  schema:
+                    type: object
+                    properties:
+                      count:
+                        type: integer
+                      result:
+                        description: >-
+                          A List of tables for given database
+                        type: array
+                        items:
+                          $ref: '#/components/schemas/DatabaseTablesResponse'
+            400:
+              $ref: '#/components/responses/400'
+            401:
+              $ref: '#/components/responses/401'
+            404:
+              $ref: '#/components/responses/404'
+            422:
+              $ref: '#/components/responses/422'
+            500:
+              $ref: '#/components/responses/500'
+        """
+        force = kwargs["rison"].get("force", False)
+        schema_name = kwargs["rison"].get("schema_name", "")
+
+        try:
+            command = TablesDatabaseCommand(pk, schema_name, force)
+            payload = command.run()
+            return self.response(200, **payload)
+        except DatabaseNotFoundError:
+            return self.response_404()
+        except SupersetException as ex:
+            return self.response(ex.status, message=ex.message)
+        except DatabaseTablesUnexpectedError as ex:
+            return self.response_422(ex.message)
+
     @expose("/<int:pk>/table/<table_name>/<schema_name>/", methods=["GET"])
     @protect()
     @check_datasource_access

superset/databases/commands/exceptions.py

@@ -137,6 +137,11 @@ class DatabaseTestConnectionUnexpectedError(SupersetErrorsException):
     message = _("Unexpected error occurred, please check your logs for details")
 
 
+class DatabaseTablesUnexpectedError(Exception):
+    status = 422
+    message = _("Unexpected error occurred, please check your logs for details")
+
+
 class NoValidatorConfigFoundError(SupersetErrorException):
     status = 422
     message = _("no SQL validator is configured")

superset/databases/commands/tables.py

@@ -0,0 +1,113 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import logging
+from typing import Any, cast, Dict
+
+from superset.commands.base import BaseCommand
+from superset.connectors.sqla.models import SqlaTable
+from superset.databases.commands.exceptions import (
+    DatabaseNotFoundError,
+    DatabaseTablesUnexpectedError,
+)
+from superset.databases.dao import DatabaseDAO
+from superset.exceptions import SupersetException
+from superset.extensions import db, security_manager
+from superset.models.core import Database
+from superset.utils.core import DatasourceName
+
+logger = logging.getLogger(__name__)
+
+
+class TablesDatabaseCommand(BaseCommand):
+    _model: Database
+
+    def __init__(self, db_id: int, schema_name: str, force: bool):
+        self._db_id = db_id
+        self._schema_name = schema_name
+        self._force = force
+
+    def run(self) -> Dict[str, Any]:
+        self.validate()
+        try:
+            tables = security_manager.get_datasources_accessible_by_user(
+                database=self._model,
+                schema=self._schema_name,
+                datasource_names=sorted(
+                    DatasourceName(*datasource_name)
+                    for datasource_name in self._model.get_all_table_names_in_schema(
+                        schema=self._schema_name,
+                        force=self._force,
+                        cache=self._model.table_cache_enabled,
+                        cache_timeout=self._model.table_cache_timeout,
+                    )
+                ),
+            )
+
+            views = security_manager.get_datasources_accessible_by_user(
+                database=self._model,
+                schema=self._schema_name,
+                datasource_names=sorted(
+                    DatasourceName(*datasource_name)
+                    for datasource_name in self._model.get_all_view_names_in_schema(
+                        schema=self._schema_name,
+                        force=self._force,
+                        cache=self._model.table_cache_enabled,
+                        cache_timeout=self._model.table_cache_timeout,
+                    )
+                ),
+            )
+
+            extra_dict_by_name = {
+                table.name: table.extra_dict
+                for table in (
+                    db.session.query(SqlaTable).filter(
+                        SqlaTable.database_id == self._model.id,
+                        SqlaTable.schema == self._schema_name,
+                    )
+                ).all()
+            }
+
+            options = sorted(
+                [
+                    {
+                        "value": table.table,
+                        "type": "table",
+                        "extra": extra_dict_by_name.get(table.table, None),
+                    }
+                    for table in tables
+                ]
+                + [
+                    {
+                        "value": view.table,
+                        "type": "view",
+                    }
+                    for view in views
+                ],
+                key=lambda item: item["value"],
+            )
+
+            payload = {"count": len(tables) + len(views), "result": options}
+            return payload
+        except SupersetException as ex:
+            raise ex
+        except Exception as ex:
+            raise DatabaseTablesUnexpectedError(ex) from ex
+
+    def validate(self) -> None:
+        self._model = cast(Database, DatabaseDAO.find_by_id(self._db_id))
+        if not self._model:
+            raise DatabaseNotFoundError()

superset/databases/schemas.py

@@ -43,6 +43,15 @@ database_schemas_query_schema = {
     "properties": {"force": {"type": "boolean"}},
 }
 
+database_tables_query_schema = {
+    "type": "object",
+    "properties": {
+        "force": {"type": "boolean"},
+        "schema_name": {"type": "string"},
+    },
+    "required": ["schema_name"],
+}
+
 database_name_description = "A database name to identify this connection."
 port_description = "Port number for the database connection."
 cache_timeout_description = (
@@ -573,6 +582,12 @@ class SchemasResponseSchema(Schema):
     result = fields.List(fields.String(description="A database schema name"))
 
 
+class DatabaseTablesResponse(Schema):
+    extra = fields.Dict(description="Extra data used to specify column metadata")
+    type = fields.String(description="table or view")
+    value = fields.String(description="The table or view name")
+
+
 class ValidateSQLRequest(Schema):
     sql = fields.String(required=True, description="SQL statement to validate")
     schema = fields.String(required=False, allow_none=True)