MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/interfaces/data_catalog/data_catalog_loader.py

@@ -120,7 +120,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the column metadata from the handler.
         """
         self.logger.info(f"Loading columns for {self.database_name}")
-        response = self.data_handler.meta_get_columns(self.table_names)
+        response = self.data_handler.meta_get_columns([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load columns for {self.database_name}: {response.error_message}")
             return []
@@ -168,7 +168,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the column statistics metadata from the handler.
         """
         self.logger.info(f"Loading column statistics for {self.database_name}")
-        response = self.data_handler.meta_get_column_statistics(self.table_names)
+        response = self.data_handler.meta_get_column_statistics([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load column statistics for {self.database_name}: {response.error_message}")
             return
@@ -233,7 +233,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the primary keys metadata from the handler.
         """
         self.logger.info(f"Loading primary keys for {self.database_name}")
-        response = self.data_handler.meta_get_primary_keys(self.table_names)
+        response = self.data_handler.meta_get_primary_keys([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load primary keys for {self.database_name}: {response.error_message}")
             return
@@ -285,7 +285,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the foreign keys metadata from the handler.
         """
         self.logger.info(f"Loading foreign keys for {self.database_name}")
-        response = self.data_handler.meta_get_foreign_keys(self.table_names)
+        response = self.data_handler.meta_get_foreign_keys([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to foreign keys for {self.database_name}: {response.error_message}")
             return

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

@@ -3,11 +3,12 @@ from copy import deepcopy
 from typing import List, Optional
 from collections import OrderedDict
 
+import pandas as pd
 import sqlalchemy as sa
 import numpy as np
 
 from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb_sql_parser.ast import Select, Star, Constant, Identifier
+from mindsdb_sql_parser.ast import Select, Star, Constant, Identifier, BinaryOperation
 from mindsdb_sql_parser import parse_sql
 
 from mindsdb.interfaces.storage import db
@@ -94,14 +95,38 @@ 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, session):
+        ast_query = parse_sql(query)
+
+        if isinstance(ast_query, Select):
+            # check create view sql
+            ast_query.limit = Constant(1)
+
+            query_context_controller.set_context(query_context_controller.IGNORE_CONTEXT)
+            try:
+                SQLQuery(ast_query, session=session, database=self.name)
+            finally:
+                query_context_controller.release_context(query_context_controller.IGNORE_CONTEXT)
 
-    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)
@@ -112,21 +137,112 @@ class Project:
         view_meta["query_ast"] = parse_sql(view_meta["query"])
         return view_meta
 
-    def query_view(self, query, session):
+    @staticmethod
+    def combine_view_select(view_query: Select, query: Select) -> Select:
+        """
+        Create a combined query from view's query and outer query.
+        """
+
+        # apply optimizations
+        if query.where is not None:
+            # Get conditions that can be duplicated into view's query
+            # It has to be simple condition with identifier and constant
+            # Also it shouldn't be under the OR condition
+
+            def get_conditions_to_move(node):
+                if not isinstance(node, BinaryOperation):
+                    return []
+                op = node.op.upper()
+                if op == "AND":
+                    conditions = []
+                    conditions.extend(get_conditions_to_move(node.args[0]))
+                    conditions.extend(get_conditions_to_move(node.args[1]))
+                    return conditions
+
+                if op == "OR":
+                    return []
+                if isinstance(node.args[0], (Identifier, Constant)) and isinstance(
+                    node.args[1], (Identifier, Constant)
+                ):
+                    return [node]
+
+            conditions = get_conditions_to_move(query.where)
+
+            if conditions:
+                # analyse targets
+                # if target element has alias
+                #    if element is not identifier or the name is not equal to alias:
+                #         add alias to black list
+                # white list:
+                #     all targets that are identifiers with no alias or equal to its alias
+                # condition can be moved if
+                #     column is not in black list AND (query has star(*) OR column in white list)
+
+                has_star = False
+                white_list, black_list = [], []
+                for target in view_query.targets:
+                    if isinstance(target, Star):
+                        has_star = True
+                    if isinstance(target, Identifier):
+                        name = target.parts[-1].lower()
+                        if target.alias is None or target.alias.parts[-1].lower() == name:
+                            white_list.append(name)
+                    elif target.alias is not None:
+                        black_list.append(target.alias.parts[-1].lower())
+
+                view_where = view_query.where
+                for condition in conditions:
+                    arg1, arg2 = condition.args
+
+                    if isinstance(arg1, Identifier):
+                        name = arg1.parts[-1].lower()
+                        if name in black_list or not (has_star or name in white_list):
+                            continue
+                    if isinstance(arg2, Identifier):
+                        name = arg2.parts[-1].lower()
+                        if name in black_list or not (has_star or name in white_list):
+                            continue
+
+                    # condition can be moved into view
+                    condition2 = BinaryOperation(condition.op, [arg1, arg2])
+                    if view_where is None:
+                        view_where = condition2
+                    else:
+                        view_where = BinaryOperation("AND", args=[view_where, condition2])
+
+                    # disable outer condition
+                    condition.op = "="
+                    condition.args = [Constant(0), Constant(0)]
+
+                view_query.where = view_where
+
+        # combine outer query with view's query
+        view_query.parentheses = True
+        query.from_table = view_query
+        return query
+
+    def query_view(self, query: Select, session) -> pd.DataFrame:
         view_meta = self.get_view_meta(query)
 
         query_context_controller.set_context("view", view_meta["id"])
-
+        query_applied = False
         try:
-            sqlquery = SQLQuery(view_meta["query_ast"], session=session)
+            view_query = view_meta["query_ast"]
+            if isinstance(view_query, Select):
+                view_query = self.combine_view_select(view_query, query)
+                query_applied = True
+
+            sqlquery = SQLQuery(view_query, session=session)
             df = sqlquery.fetched_data.to_df()
         finally:
             query_context_controller.release_context("view", view_meta["id"])
 
         # remove duplicated columns
         df = df.loc[:, ~df.columns.duplicated()]
-
-        return query_df(df, query, session=session)
+        if query_applied:
+            return df
+        else:
+            return query_df(df, query, session=session)
 
     @staticmethod
     def _get_model_data(predictor_record, integraion_record, with_secrets: bool = True):
@@ -279,18 +395,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 +512,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 +544,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]