MindsDB 25.7.2.0__py3-none-any.whl → 25.7.4.0__py3-none-any.whl

mindsdb/interfaces/database/database.py

@@ -18,18 +18,30 @@ class DatabaseController:
         self.logs_db_controller = LogDBController()
         self.information_schema_controller = None
 
-    def delete(self, name: str):
+    def delete(self, name: str, strict_case: bool = False) -> None:
+        """Delete a database (project or integration) by name.
+
+        Args:
+            name (str): The name of the database to delete.
+            strict_case (bool, optional): If True, the database name is case-sensitive. Defaults to False.
+
+        Raises:
+            EntityNotExistsError: If the database does not exist.
+            Exception: If the database cannot be deleted.
+
+        Returns:
+            None
+        """
         databases = self.get_dict()
-        name = name.lower()
-        if name not in databases:
+        if name.lower() not in databases:
             raise EntityNotExistsError("Database does not exists", name)
-        db_type = databases[name]["type"]
+        db_type = databases[name.lower()]["type"]
         if db_type == "project":
-            project = self.get_project(name)
+            project = self.get_project(name, strict_case)
             project.delete()
             return
         elif db_type == "data":
-            self.integration_controller.delete(name)
+            self.integration_controller.delete(name, strict_case)
             return
         else:
             raise Exception(f"Database with type '{db_type}' cannot be deleted")
@@ -81,9 +93,9 @@ class DatabaseController:
 
         return result
 
-    def get_dict(self, filter_type: Optional[str] = None):
+    def get_dict(self, filter_type: Optional[str] = None, lowercase: bool = True):
         return OrderedDict(
-            (x["name"].lower(), {"type": x["type"], "engine": x["engine"], "id": x["id"]})
+            (x["name"].lower() if lowercase else x["name"], {"type": x["type"], "engine": x["engine"], "id": x["id"]})
             for x in self.get_list(filter_type=filter_type)
         )
 
@@ -98,8 +110,17 @@ class DatabaseController:
     def exists(self, db_name: str) -> bool:
         return db_name.lower() in self.get_dict()
 
-    def get_project(self, name: str):
-        return self.project_controller.get(name=name)
+    def get_project(self, name: str, strict_case: bool = False):
+        """Get a project by name.
+
+        Args:
+            name (str): The name of the project to retrieve.
+            strict_case (bool, optional): If True, the project name is case-sensitive. Defaults to False.
+
+        Returns:
+            Project: The project instance matching the given name.
+        """
+        return self.project_controller.get(name=name, strict_case=strict_case)
 
     def get_system_db(self, name: str):
         if name == "log":
@@ -112,19 +133,21 @@ class DatabaseController:
         else:
             raise Exception(f"Database '{name}' does not exists")
 
-    def update(self, name: str, data: dict):
+    def update(self, name: str, data: dict, strict_case: bool = False):
         """
         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.
+            strict_case (bool): if True, then name is case-sesitive
 
         Raises:
             EntityNotExistsError: If the database does not exist.
         """
-        databases = self.get_dict()
-        name = name.lower()
+        databases = self.get_dict(lowercase=(not strict_case))
+        if not strict_case:
+            name = name.lower()
         if name not in databases:
             raise EntityNotExistsError("Database does not exist.", name)
 
@@ -133,6 +156,8 @@ class DatabaseController:
             # Only the name of the project can be updated.
             if {"name"} != set(data):
                 raise ValueError("Only the 'name' field can be updated for projects.")
+            if not data["name"].islower():
+                raise ValueError("New name must be in lower case.")
             self.project_controller.update(name=name, new_name=str(data["name"]))
             return
 

mindsdb/interfaces/database/integrations.py

@@ -161,7 +161,7 @@ class IntegrationController:
         db.session.commit()
         return integration_record.id
 
-    def add(self, name, engine, connection_args):
+    def add(self, name: str, engine, connection_args):
         logger.debug(
             "%s: add method calling name=%s, engine=%s, connection_args=%s, company_id=%s",
             self.__class__.__name__,
@@ -172,6 +172,9 @@ class IntegrationController:
         )
         handler_meta = self.get_handler_meta(engine)
 
+        if not name.islower():
+            raise ValueError(f"The name must be in lower case: {name}")
+
         accept_connection_args = handler_meta.get("connection_args")
         logger.debug("%s: accept_connection_args - %s", self.__class__.__name__, accept_connection_args)
 
@@ -210,20 +213,32 @@ class IntegrationController:
         integration_record.data = data
         db.session.commit()
 
-    def delete(self, name):
-        if name in ("files", "lightwood"):
+    def delete(self, name: str, strict_case: bool = False) -> None:
+        """Delete an integration by name.
+
+        Args:
+            name (str): The name of the integration to delete.
+            strict_case (bool, optional): If True, the integration name is case-sensitive. Defaults to False.
+
+        Raises:
+            Exception: If the integration cannot be deleted (system, permanent, demo, in use, or has active models).
+
+        Returns:
+            None
+        """
+        if name == "files":
             raise Exception("Unable to drop: is system database")
 
         self.handlers_cache.delete(name)
 
         # check permanent integration
-        if name in self.handler_modules:
+        if name.lower() in self.handler_modules:
             handler = self.handler_modules[name]
 
             if getattr(handler, "permanent", False) is True:
                 raise Exception("Unable to drop permanent integration")
 
-        integration_record = self._get_integration_record(name)
+        integration_record = self._get_integration_record(name, case_sensitive=strict_case)
         if isinstance(integration_record.data, dict) and integration_record.data.get("is_demo") is True:
             raise Exception("Unable to drop demo object")
 

mindsdb/interfaces/database/projects.py

@@ -94,14 +94,26 @@ class Project:
     def drop_model(self, name: str):
         ModelController().delete_model(name, project_name=self.name)
 
-    def drop_view(self, name: str):
-        ViewController().delete(name, project_name=self.name)
+    def drop_view(self, name: str, strict_case: bool = False) -> None:
+        """Remove a view with the specified name from the current project.
+
+        Args:
+            name (str): The name of the view to remove.
+            strict_case (bool, optional): If True, the view name is case-sensitive. Defaults to False.
+
+        Raises:
+            EntityNotExistsError: If the view does not exist.
+
+        Returns:
+            None
+        """
+        ViewController().delete(name, project_name=self.name, strict_case=strict_case)
 
     def create_view(self, name: str, query: str):
         ViewController().add(name, query=query, project_name=self.name)
 
-    def update_view(self, name: str, query: str):
-        ViewController().update(name, query=query, project_name=self.name)
+    def update_view(self, name: str, query: str, strict_case: bool = False):
+        ViewController().update(name, query=query, project_name=self.name, strict_case=strict_case)
 
     def delete_view(self, name: str):
         ViewController().delete(name, project_name=self.name)
@@ -279,18 +291,29 @@ class Project:
         ]
         return data
 
-    def get_view(self, name):
-        view_record = (
-            db.session.query(db.View)
-            .filter(
-                db.View.project_id == self.id,
-                db.View.company_id == ctx.company_id,
-                sa.func.lower(db.View.name) == name.lower(),
-            )
-            .one_or_none()
+    def get_view(self, name: str, strict_case: bool = False) -> dict | None:
+        """Get a view by name from the current project.
+
+        Args:
+            name (str): The name of the view to retrieve.
+            strict_case (bool, optional): If True, the view name is case-sensitive. Defaults to False.
+
+        Returns:
+            dict | None: A dictionary with view information if found, otherwise None.
+        """
+        query = db.session.query(db.View).filter(
+            db.View.project_id == self.id,
+            db.View.company_id == ctx.company_id,
         )
+        if strict_case:
+            query = query.filter(db.View.name == name)
+        else:
+            query = query.filter(sa.func.lower(db.View.name) == name.lower())
+
+        view_record = query.one_or_none()
+
         if view_record is None:
-            return view_record
+            return None
         return {
             "name": view_record.name,
             "query": view_record.query,
@@ -385,8 +408,29 @@ class ProjectController:
         return [Project.from_record(x) for x in records]
 
     def get(
-        self, id: Optional[int] = None, name: Optional[str] = None, deleted: bool = False, is_default: bool = False
+        self,
+        id: int | None = None,
+        name: str | None = None,
+        deleted: bool = False,
+        is_default: bool = False,
+        strict_case: bool = False,
     ) -> Project:
+        """Get a project by id or name.
+
+        Args:
+            id (int | None, optional): The id of the project to retrieve. Cannot be used with 'name'.
+            name (str | None, optional): The name of the project to retrieve. Cannot be used with 'id'.
+            deleted (bool, optional): If True, include deleted projects. Defaults to False.
+            is_default (bool, optional): If True, only return the default project. Defaults to False.
+            strict_case (bool, optional): If True, the project name is case-sensitive. Defaults to False.
+
+        Raises:
+            ValueError: If both 'id' and 'name' are provided.
+            EntityNotExistsError: If the project is not found.
+
+        Returns:
+            Project: The project instance matching the given criteria.
+        """
         if id is not None and name is not None:
             raise ValueError("Both 'id' and 'name' can't be provided at the same time")
 
@@ -396,7 +440,10 @@ class ProjectController:
         if id is not None:
             q = q.filter_by(id=id)
         elif name is not None:
-            q = q.filter((sa.func.lower(db.Project.name) == sa.func.lower(name)))
+            if strict_case:
+                q = q.filter((db.Project.name == name))
+            else:
+                q = q.filter((sa.func.lower(db.Project.name) == sa.func.lower(name)))
 
         if deleted is True:
             q = q.filter((db.Project.deleted_at != sa.null()))

mindsdb/interfaces/database/views.py

@@ -12,64 +12,90 @@ class ViewController:
         from mindsdb.interfaces.database.database import DatabaseController
 
         database_controller = DatabaseController()
-        project_databases_dict = database_controller.get_dict(filter_type='project')
+        project_databases_dict = database_controller.get_dict(filter_type="project")
 
         if project_name not in project_databases_dict:
-            raise EntityNotExistsError('Can not find project', project_name)
+            raise EntityNotExistsError("Can not find project", project_name)
 
-        project_id = project_databases_dict[project_name]['id']
+        project_id = project_databases_dict[project_name]["id"]
         view_record = (
             db.session.query(db.View.id)
             .filter(
-                func.lower(db.View.name) == name,
-                db.View.company_id == ctx.company_id,
-                db.View.project_id == project_id
-            ).first()
+                func.lower(db.View.name) == name, db.View.company_id == ctx.company_id, db.View.project_id == project_id
+            )
+            .first()
         )
         if view_record is not None:
-            raise EntityExistsError('View already exists', name)
+            raise EntityExistsError("View already exists", name)
 
-        view_record = db.View(
-            name=name,
-            company_id=ctx.company_id,
-            query=query,
-            project_id=project_id
-        )
+        view_record = db.View(name=name, company_id=ctx.company_id, query=query, project_id=project_id)
         db.session.add(view_record)
         db.session.commit()
 
-    def update(self, name, query, project_name):
-        name = name.lower()
+    def update(self, name: str, query: str, project_name: str, strict_case: bool = False):
+        """Update the SQL query of an existing view in the specified project.
+
+        Args:
+            name (str): The name of the view to update.
+            query (str): The new SQL query for the view.
+            project_name (str): The name of the project containing the view.
+            strict_case (bool, optional): If True, the view name is case-sensitive. If False, the name comparison is case-insensitive. Defaults to False.
+
+        Raises:
+            EntityNotExistsError: If the view with the specified name does not exist in the given project.
+
+        Returns:
+            None
+        """
         project_record = get_project_record(project_name)
 
-        rec = db.session.query(db.View).filter(
-            func.lower(db.View.name) == name,
-            db.View.company_id == ctx.company_id,
-            db.View.project_id == project_record.id
-        ).first()
+        q = db.session.query(db.View).filter(
+            db.View.company_id == ctx.company_id, db.View.project_id == project_record.id
+        )
+        if strict_case:
+            q = q.filter(db.View.name == name)
+        else:
+            q = q.filter(func.lower(db.View.name) == func.lower(name))
+
+        rec = q.first()
         if rec is None:
-            raise EntityNotExistsError('View not found', name)
+            raise EntityNotExistsError("View not found", name)
         rec.query = query
         db.session.commit()
 
-    def delete(self, name, project_name):
-        name = name.lower()
+    def delete(self, name: str, project_name: str, strict_case: bool = False) -> None:
+        """Remove a view with the specified name from the given project.
+
+        Args:
+            name (str): The name of the view to remove.
+            project_name (str): The name of the project containing the view.
+            strict_case (bool, optional): If True, the view name is case-sensitive. Defaults to False.
+
+        Raises:
+            EntityNotExistsError: If the view does not exist.
+
+        Returns:
+            None
+        """
         project_record = get_project_record(project_name)
 
-        rec = db.session.query(db.View).filter(
-            func.lower(db.View.name) == name,
-            db.View.company_id == ctx.company_id,
-            db.View.project_id == project_record.id
-        ).first()
-        if rec is None:
-            raise EntityNotExistsError('View not found', name)
-        db.session.delete(rec)
+        query = db.session.query(db.View).filter(
+            db.View.company_id == ctx.company_id, db.View.project_id == project_record.id
+        )
+        if strict_case:
+            query = query.filter(db.View.name == name)
+        else:
+            query = query.filter(func.lower(db.View.name) == func.lower(name))
+
+        record = query.first()
+        if record is None:
+            raise EntityNotExistsError("View not found", name)
+        db.session.delete(record)
         db.session.commit()
 
-        query_context_controller.drop_query_context('view', rec.id)
+        query_context_controller.drop_query_context("view", record.id)
 
     def list(self, project_name):
-
         project_names = {}
         for project in get_project_records():
             if project_name is not None and project.name != project_name:
@@ -77,49 +103,49 @@ class ViewController:
             project_names[project.id] = project.name
 
         query = db.session.query(db.View).filter(
-            db.View.company_id == ctx.company_id,
-            db.View.project_id.in_(list(project_names.keys()))
+            db.View.company_id == ctx.company_id, db.View.project_id.in_(list(project_names.keys()))
         )
 
         data = []
 
         for record in query:
-
-            data.append({
-                'id': record.id,
-                'name': record.name,
-                'project': project_names[record.project_id],
-                'query': record.query,
-            })
+            data.append(
+                {
+                    "id": record.id,
+                    "name": record.name,
+                    "project": project_names[record.project_id],
+                    "query": record.query,
+                }
+            )
 
         return data
 
     def _get_view_record_data(self, record):
-        return {
-            'id': record.id,
-            'name': record.name,
-            'query': record.query
-        }
+        return {"id": record.id, "name": record.name, "query": record.query}
 
     def get(self, id=None, name=None, project_name=None):
         project_record = get_project_record(project_name)
 
         if id is not None:
-            records = db.session.query(db.View).filter_by(
-                id=id,
-                project_id=project_record.id,
-                company_id=ctx.company_id
-            ).all()
+            records = (
+                db.session.query(db.View)
+                .filter_by(id=id, project_id=project_record.id, company_id=ctx.company_id)
+                .all()
+            )
         elif name is not None:
-            records = db.session.query(db.View).filter(
-                func.lower(db.View.name) == name.lower(),
-                db.View.project_id == project_record.id,
-                db.View.company_id == ctx.company_id,
-            ).all()
+            records = (
+                db.session.query(db.View)
+                .filter(
+                    func.lower(db.View.name) == name.lower(),
+                    db.View.project_id == project_record.id,
+                    db.View.company_id == ctx.company_id,
+                )
+                .all()
+            )
         if len(records) == 0:
             if name is None:
-                name = f'id={id}'
-            raise EntityNotExistsError("Can't find view", f'{project_name}.{name}')
+                name = f"id={id}"
+            raise EntityNotExistsError("Can't find view", f"{project_name}.{name}")
         elif len(records) > 1:
             raise Exception(f"There are multiple views with name/id: {name}/{id}")
         record = records[0]