MindsDB 25.5.4.2__py3-none-any.whl → 25.6.2.0__py3-none-any.whl

mindsdb/interfaces/data_catalog/data_catalog_reader.py

@@ -0,0 +1,34 @@
+from mindsdb.interfaces.data_catalog.base_data_catalog import BaseDataCatalog
+from mindsdb.interfaces.storage import db
+
+
+class DataCatalogReader(BaseDataCatalog):
+    """
+    This class is responsible for reading the metadata from the data catalog and providing it in a structured format.
+    """
+
+    def read_metadata_as_string(self) -> str:
+        """
+        Read the metadata from the data catalog and return it as a string.
+        """
+        if not self.is_data_catalog_supported():
+            return f"Data catalog is not supported for database '{self.database_name}'."
+        tables = self._read_metadata()
+        if not tables:
+            self.logger.warning(f"No metadata found for database '{self.database_name}'")
+            return f"No metadata found for database '{self.database_name}'"
+        metadata_str = "Data Catalog: \n"
+        for table in tables:
+            metadata_str += table.as_string() + "\n\n"
+        return metadata_str
+
+    def _read_metadata(self) -> list:
+        """
+        Read the metadata from the data catalog and return it in a structured format.
+        """
+        query = db.session.query(db.MetaTables).filter_by(integration_id=self.integration_id)
+        if self.table_names:
+            cleaned_table_names = [name.strip("`").split(".")[-1] for name in self.table_names]
+            query = query.filter(db.MetaTables.name.in_(cleaned_table_names))
+        tables = query.all()
+        return tables

mindsdb/interfaces/database/database.py

@@ -11,6 +11,7 @@ from mindsdb.interfaces.database.log import LogDBController
 class DatabaseController:
     def __init__(self):
         from mindsdb.interfaces.database.integrations import integration_controller
+
         self.integration_controller = integration_controller
         self.project_controller = ProjectController()
 
@@ -21,13 +22,13 @@ class DatabaseController:
         databases = self.get_dict()
         name = name.lower()
         if name not in databases:
-            raise EntityNotExistsError('Database does not exists', name)
-        db_type = databases[name]['type']
-        if db_type == 'project':
+            raise EntityNotExistsError("Database does not exists", name)
+        db_type = databases[name]["type"]
+        if db_type == "project":
             project = self.get_project(name)
             project.delete()
             return
-        elif db_type == 'data':
+        elif db_type == "data":
             self.integration_controller.delete(name)
             return
         else:
@@ -37,59 +38,52 @@ class DatabaseController:
     def get_list(self, filter_type: Optional[str] = None, with_secrets: Optional[bool] = True):
         projects = self.project_controller.get_list()
         integrations = self.integration_controller.get_all(show_secrets=with_secrets)
-        result = [{
-            'name': 'information_schema',
-            'type': 'system',
-            'id': None,
-            'engine': None,
-            'visible': True,
-            'deletable': False
-        }, {
-            'name': 'log',
-            'type': 'system',
-            'id': None,
-            'engine': None,
-            'visible': True,
-            'deletable': False
-        }]
+        result = [
+            {
+                "name": "information_schema",
+                "type": "system",
+                "id": None,
+                "engine": None,
+                "visible": True,
+                "deletable": False,
+            },
+            {"name": "log", "type": "system", "id": None, "engine": None, "visible": True, "deletable": False},
+        ]
         for x in projects:
-            result.append({
-                'name': x.name,
-                'type': 'project',
-                'id': x.id,
-                'engine': None,
-                'visible': True,
-                'deletable': x.name.lower() != config.get('default_project')
-            })
+            result.append(
+                {
+                    "name": x.name,
+                    "type": "project",
+                    "id": x.id,
+                    "engine": None,
+                    "visible": True,
+                    "deletable": x.name.lower() != config.get("default_project"),
+                }
+            )
         for key, value in integrations.items():
-            db_type = value.get('type', 'data')
-            if db_type != 'ml':
-                result.append({
-                    'name': key,
-                    'type': value.get('type', 'data'),
-                    'id': value.get('id'),
-                    'engine': value.get('engine'),
-                    'class_type': value.get('class_type'),
-                    'connection_data': value.get('connection_data'),
-                    'visible': True,
-                    'deletable': value.get('permanent', False) is False
-                })
+            db_type = value.get("type", "data")
+            if db_type != "ml":
+                result.append(
+                    {
+                        "name": key,
+                        "type": value.get("type", "data"),
+                        "id": value.get("id"),
+                        "engine": value.get("engine"),
+                        "class_type": value.get("class_type"),
+                        "connection_data": value.get("connection_data"),
+                        "visible": True,
+                        "deletable": value.get("permanent", False) is False,
+                    }
+                )
 
         if filter_type is not None:
-            result = [x for x in result if x['type'] == filter_type]
+            result = [x for x in result if x["type"] == filter_type]
 
         return result
 
     def get_dict(self, filter_type: Optional[str] = None):
         return OrderedDict(
-            (
-                x['name'].lower(),
-                {
-                    'type': x['type'],
-                    'engine': x['engine'],
-                    'id': x['id']
-                }
-            )
+            (x["name"].lower(), {"type": x["type"], "engine": x["engine"], "id": x["id"]})
             for x in self.get_list(filter_type=filter_type)
         )
 
@@ -98,13 +92,8 @@ class DatabaseController:
 
         # TODO get directly from db?
         for rec in self.get_list():
-            if rec['id'] == integration_id and rec['type'] == 'data':
-                return {
-                    'name': rec['name'],
-                    'type': rec['type'],
-                    'engine': rec['engine'],
-                    'id': rec['id']
-                }
+            if rec["id"] == integration_id and rec["type"] == "data":
+                return {"name": rec["name"], "type": rec["type"], "engine": rec["engine"], "id": rec["id"]}
 
     def exists(self, db_name: str) -> bool:
         return db_name.lower() in self.get_dict()
@@ -113,11 +102,46 @@ class DatabaseController:
         return self.project_controller.get(name=name)
 
     def get_system_db(self, name: str):
-        if name == 'log':
+        if name == "log":
             return self.logs_db_controller
-        elif name == 'information_schema':
+        elif name == "information_schema":
             from mindsdb.api.executor.controllers.session_controller import SessionController
+
             session = SessionController()
             return session.datahub
         else:
             raise Exception(f"Database '{name}' does not exists")
+
+    def update(self, name: str, data: dict):
+        """
+        Updates the database with the given name using the provided data.
+
+        Parameters:
+            name (str): The name of the database to update.
+            data (dict): The data to update the database with.
+
+        Raises:
+            EntityNotExistsError: If the database does not exist.
+        """
+        databases = self.get_dict()
+        name = name.lower()
+        if name not in databases:
+            raise EntityNotExistsError("Database does not exist.", name)
+
+        db_type = databases[name]["type"]
+        if db_type == "project":
+            # Only the name of the project can be updated.
+            if {"name"} != set(data):
+                raise ValueError("Only the 'name' field can be updated for projects.")
+            self.project_controller.update(name=name, new_name=str(data["name"]))
+            return
+
+        elif db_type == "data":
+            # Only the parameters (connection data) of the integration can be updated.
+            if {"parameters"} != set(data):
+                raise ValueError("Only the 'parameters' field can be updated for integrations.")
+            self.integration_controller.modify(name, data["parameters"])
+            return
+
+        else:
+            raise ValueError(f"Database with type '{db_type}' cannot be updated")