MindsDB 25.4.3.2__py3-none-any.whl → 25.4.5.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.4.3.2'
+__version__ = '25.4.5.0'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

mindsdb/__main__.py

@@ -25,7 +25,7 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.utilities.starters import (
     start_http, start_mysql, start_mongo, start_postgres, start_ml_task_queue, start_scheduler, start_tasks,
-    start_mcp
+    start_mcp, start_litellm
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 from mindsdb.utilities.functions import get_versions_where_predictors_become_obsolete
@@ -59,6 +59,7 @@ class TrunkProcessEnum(Enum):
     TASKS = 'tasks'
     ML_TASK_QUEUE = 'ml_task_queue'
     MCP = 'mcp'
+    LITELLM = 'litellm'
 
     @classmethod
     def _missing_(cls, value):
@@ -408,9 +409,11 @@ if __name__ == '__main__':
 
     clean_process_marks()
 
-    http_api_config = config['api']['http']
-    mysql_api_config = config['api']['mysql']
-    mcp_api_config = config['api']['mcp']
+    # Get config values for APIs
+    http_api_config = config.get('api', {}).get('http', {})
+    mysql_api_config = config.get('api', {}).get('mysql', {})
+    mcp_api_config = config.get('api', {}).get('mcp', {})
+    litellm_api_config = config.get('api', {}).get('litellm', {})
     trunc_processes_struct = {
         TrunkProcessEnum.HTTP: TrunkProcessData(
             name=TrunkProcessEnum.HTTP.value,
@@ -471,6 +474,17 @@ if __name__ == '__main__':
             max_restart_interval_seconds=mcp_api_config.get(
                 'max_restart_interval_seconds', TrunkProcessData.max_restart_interval_seconds
             )
+        ),
+        TrunkProcessEnum.LITELLM: TrunkProcessData(
+            name=TrunkProcessEnum.LITELLM.value,
+            entrypoint=start_litellm,
+            port=litellm_api_config.get('port', 8000),
+            args=(config.cmd_args.verbose,),
+            restart_on_failure=litellm_api_config.get('restart_on_failure', False),
+            max_restart_count=litellm_api_config.get('max_restart_count', TrunkProcessData.max_restart_count),
+            max_restart_interval_seconds=litellm_api_config.get(
+                'max_restart_interval_seconds', TrunkProcessData.max_restart_interval_seconds
+            )
         )
     }
 

mindsdb/api/executor/command_executor.py

@@ -585,6 +585,8 @@ class ExecuteCommands:
             )
         elif statement_type is Insert:
             query = SQLQuery(statement, session=self.session, database=database_name)
+            if query.fetched_data.length() > 0:
+                return self.answer_select(query)
             return ExecuteAnswer(
                 affected_rows=query.fetched_data.affected_rows
             )
@@ -670,7 +672,7 @@ class ExecuteCommands:
         command = target.op.lower()
         args = [arg.value for arg in target.args if isinstance(arg, Constant)]
         if command == 'query_resume':
-            ret = SQLQuery(None, session=self.session, database=database_name, query_id=args[0])
+            ret = SQLQuery(None, session=self.session, query_id=args[0])
             return self.answer_select(ret)
 
         elif command == 'query_cancel':
@@ -868,13 +870,21 @@ class ExecuteCommands:
             else:
                 raise WrongArgumentError(f'Unknown describe type: {obj_type}')
 
-        name = obj_name.parts[-1]
+        parts = obj_name.parts
+        if len(parts) > 2:
+            raise WrongArgumentError(
+                f"Invalid object name: {obj_name.to_string()}.\n"
+                "Only models support three-part namespaces."
+            )
+
+        name = parts[-1]
         where = BinaryOperation(op='=', args=[
             Identifier('name'),
             Constant(name)
         ])
 
         if obj_type in project_objects:
+            database_name = parts[0] if len(parts) > 1 else database_name
             where = BinaryOperation(op='and', args=[
                 where,
                 BinaryOperation(op='=', args=[Identifier('project'), Constant(database_name)])

mindsdb/api/executor/data_types/response_type.py

@@ -3,6 +3,7 @@ class RESPONSE_TYPE:
     OK = 'ok'
     TABLE = 'table'
     ERROR = 'error'
+    COLUMNS_TABLE = 'columns_table'  # for queries to information_schema.columns
 
 
 RESPONSE_TYPE = RESPONSE_TYPE()

mindsdb/api/executor/datahub/classes/tables_row.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, astuple
 from datetime import datetime
 
 
@@ -12,7 +12,7 @@ class TABLES_ROW_TYPE:
 TABLES_ROW_TYPE = TABLES_ROW_TYPE()
 
 
-@dataclass
+@dataclass(slots=True)
 class TablesRow:
     TABLE_CATALOG: str = 'def'
     TABLE_SCHEMA: str = 'information_schema'
@@ -37,17 +37,10 @@ class TablesRow:
     TABLE_COMMENT: str = ''
 
     def to_list(self) -> list:
-        return [self.TABLE_CATALOG, self.TABLE_SCHEMA, self.TABLE_NAME,
-                self.TABLE_TYPE, self.ENGINE, self.VERSION, self.ROW_FORMAT,
-                self.TABLE_ROWS, self.AVG_ROW_LENGTH, self.DATA_LENGTH,
-                self.MAX_DATA_LENGTH, self.INDEX_LENGTH, self.DATA_FREE,
-                self.AUTO_INCREMENT, self.CREATE_TIME, self.UPDATE_TIME,
-                self.CHECK_TIME, self.TABLE_COLLATION, self.CHECKSUM,
-                self.CREATE_OPTIONS, self.TABLE_COMMENT]
+        return list(astuple(self))
 
     @staticmethod
     def from_dict(data: dict):
-
         del_keys = []
         data = {k.upper(): v for k, v in data.items()}
 

mindsdb/api/executor/datahub/datanodes/datanode.py

@@ -1,3 +1,5 @@
+from pandas import DataFrame
+
 from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 
 
@@ -13,8 +15,11 @@ class DataNode:
     def get_tables(self):
         pass
 
-    def get_table_columns(self, tableName, schema_name=None):
+    def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> DataFrame:
+        pass
+
+    def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
         pass
 
     def query(self, query=None, native_query=None, session=None) -> DataHubResponse:
-        return []
+        pass

mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py

@@ -1,3 +1,4 @@
+from dataclasses import astuple
 
 import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -10,6 +11,7 @@ from mindsdb.api.executor.utilities.sql import query_df
 from mindsdb.api.executor.utilities.sql import get_query_tables
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.api.executor.datahub.classes.response import DataHubResponse
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
 from mindsdb.utilities import log
 
 from .system_tables import (
@@ -111,16 +113,48 @@ class InformationSchemaDataNode(DataNode):
 
         return None
 
-    def get_table_columns(self, tableName, schema_name=None):
-        tn = tableName.upper()
-        if tn in self.tables:
-            return [
-                {'name': name}
-                for name in self.tables[tn].columns
-            ]
-        raise exc.TableNotExistError(
-            f"Table information_schema.{tableName} does not exists"
-        )
+    def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> pd.DataFrame:
+        """Get a DataFrame containing representation of information_schema.columns for the specified table.
+
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): Not in use. The name of the schema to get columns from.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing representation of information_schema.columns for the specified table.
+                          The DataFrame has list of columns as in the integrations.libs.response.INF_SCHEMA_COLUMNS_NAMES
+                          but only 'COLUMN_NAME' column is filled with the actual column names.
+                          Other columns are filled with None.
+        """
+        table_name = table_name.upper()
+        if table_name not in self.tables:
+            raise exc.TableNotExistError(
+                f"Table information_schema.{table_name} does not exists"
+            )
+        table_columns_names = self.tables[table_name].columns
+        df = pd.DataFrame([[table_columns_names]], columns=[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME])
+        for column_name in astuple(INF_SCHEMA_COLUMNS_NAMES):
+            if column_name == INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME:
+                continue
+            df[column_name] = None
+        return df
+
+    def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Get a list of column names for the specified table.
+
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): Not in use. The name of the schema to get columns from.
+
+        Returns:
+            list[str]: A list of column names for the specified table.
+        """
+        table_name = table_name.upper()
+        if table_name not in self.tables:
+            raise exc.TableNotExistError(
+                f"Table information_schema.{table_name} does not exists"
+            )
+        return self.tables[table_name].columns
 
     def get_integrations_names(self):
         integration_names = self.integration_controller.get_all().keys()

mindsdb/api/executor/datahub/datanodes/integration_datanode.py

@@ -1,6 +1,6 @@
 import time
 import inspect
-from typing import Optional
+from dataclasses import astuple
 
 import numpy as np
 from numpy import dtype as np_dtype
@@ -18,11 +18,12 @@ from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
 from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.integrations.libs.response import HandlerResponse, INF_SCHEMA_COLUMNS_NAMES
 from mindsdb.integrations.utilities.utils import get_class_name
 from mindsdb.metrics import metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.profiler import profiler
-from mindsdb.integrations.libs.response import HandlerResponse
+from mindsdb.api.executor.datahub.datanodes.system_tables import infer_mysql_type
 
 logger = log.getLogger(__name__)
 
@@ -55,47 +56,65 @@ class IntegrationDataNode(DataNode):
         else:
             raise Exception(f"Can't get tables: {response.error_message}")
 
-    def get_table_columns(self, table_name: str, schema_name: Optional[str] = None):
+    def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> pd.DataFrame:
+        """Get a DataFrame containing representation of information_schema.columns for the specified table.
+
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): The name of the schema to get columns from.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing representation of information_schema.columns for the specified table.
+                          The DataFrame has list of columns as in the integrations.libs.response.INF_SCHEMA_COLUMNS_NAMES.
+        """
         if 'schema_name' in inspect.signature(self.integration_handler.get_columns).parameters:
             response = self.integration_handler.get_columns(table_name, schema_name)
         else:
             response = self.integration_handler.get_columns(table_name)
-        if response.type == RESPONSE_TYPE.TABLE:
-            df = response.data_frame
-            # case independent
-            columns = [str(c).lower() for c in df.columns]
-            df.columns = columns
-
-            col_name = None
-            # looking for specific column names
-            for col in ('field', 'column_name', 'column', 'name'):
-                if col in columns:
-                    col_name = columns.index(col)
-                    break
-            # if not found - pick first one
-            if col_name is None:
-                col_name = 0
-
-            names = df[df.columns[col_name]]
-
-            # type
-            if 'mysql_data_type' in columns:
-                types = df['mysql_data_type']
-            elif 'type' in columns:
-                types = df['type']
-            else:
-                types = [None] * len(names)
 
-            ret = []
-            for i, name in enumerate(names):
-                ret.append({
-                    'name': name,
-                    'type': types[i]
-                })
+        if response.type == RESPONSE_TYPE.COLUMNS_TABLE:
+            return response.data_frame
+
+        if response.type != RESPONSE_TYPE.TABLE:
+            logger.warning(f"Wrong response type for handler's `get_columns` call: {response.type}")
+            return pd.DataFrame([], columns=astuple(INF_SCHEMA_COLUMNS_NAMES))
+
+        # region fallback for old handlers
+        df = response.data_frame
+        df.columns = [name.upper() for name in df.columns]
+        if 'FIELD' not in df.columns or 'TYPE' not in df.columns:
+            logger.warning(
+                f"Response from the handler's `get_columns` call does not contain required columns: f{df.columns}"
+            )
+            return pd.DataFrame([], columns=astuple(INF_SCHEMA_COLUMNS_NAMES))
+
+        new_df = df[['FIELD', 'TYPE']]
+        new_df.columns = ['COLUMN_NAME', 'DATA_TYPE']
+
+        new_df[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] = new_df[
+            INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE
+        ].apply(lambda x: infer_mysql_type(x).value)
+
+        for column_name in astuple(INF_SCHEMA_COLUMNS_NAMES):
+            if column_name in new_df.columns:
+                continue
+            new_df[column_name] = None
+        # endregion
+
+        return new_df
+
+    def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Get a list of column names for the specified table.
 
-            return ret
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): The name of the schema to get columns from.
 
-        return []
+        Returns:
+            list[str]: A list of column names for the specified table.
+        """
+        df = self.get_table_columns_df(table_name, schema_name)
+        return df[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME].to_list()
 
     def drop_table(self, name: Identifier, if_exists=False):
         drop_ast = DropTables(
@@ -107,7 +126,7 @@ class IntegrationDataNode(DataNode):
             raise Exception(result.error_message)
 
     def create_table(self, table_name: Identifier, result_set: ResultSet = None, columns=None,
-                     is_replace=False, is_create=False) -> DataHubResponse:
+                     is_replace=False, is_create=False, **kwargs) -> DataHubResponse:
         # is_create - create table
         # is_replace - drop table if exists
         # is_create==False and is_replace==False: just insert
@@ -248,7 +267,7 @@ class IntegrationDataNode(DataNode):
         return result
 
     @profiler.profile()
-    def query(self, query: Optional[ASTNode] = None, native_query: Optional[str] = None, session=None) -> DataHubResponse:
+    def query(self, query: ASTNode | None = None, native_query: str | None = None, session=None) -> DataHubResponse:
         try:
             if query is not None:
                 result: HandlerResponse = self._query(query)

mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py

@@ -451,7 +451,8 @@ class ViewsTable(MdbTable):
 
 class QueriesTable(MdbTable):
     name = 'QUERIES'
-    columns = ["ID", "STARTED_AT", "FINISHED_AT", "PROCESSED_ROWS", "ERROR", "SQL", "PARAMETERS", "CONTEXT", "UPDATED_AT"]
+    columns = ["ID", "STARTED_AT", "FINISHED_AT", "PROCESSED_ROWS", "ERROR", "SQL", "DATABASE",
+               "PARAMETERS", "CONTEXT", "UPDATED_AT"]
 
     @classmethod
     def get_data(cls, **kwargs):

mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -1,4 +1,5 @@
 from copy import deepcopy
+from dataclasses import astuple
 
 import pandas as pd
 from mindsdb_sql_parser import parse_sql
@@ -16,6 +17,7 @@ from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
 from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
 from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 from mindsdb.utilities.partitioning import process_dataframe_in_partitions
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
 
 
 class ProjectDataNode(DataNode):
@@ -46,11 +48,41 @@ class ProjectDataNode(DataNode):
         result = [TablesRow.from_dict(row) for row in tables]
         return result
 
-    def get_table_columns(self, table_name, schema_name=None):
-        return [
-            {'name': name}
-            for name in self.project.get_columns(table_name)
-        ]
+    def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> pd.DataFrame:
+        """Get a DataFrame containing representation of information_schema.columns for the specified table.
+
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): Not in use. The name of the schema to get columns from.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing representation of information_schema.columns for the specified table.
+                          The DataFrame has list of columns as in the integrations.libs.response.INF_SCHEMA_COLUMNS_NAMES
+                          but only 'COLUMN_NAME' column is filled with the actual column names.
+                          Other columns are filled with None.
+        """
+        columns = self.project.get_columns(table_name)
+
+        data = []
+        row = {name: None for name in astuple(INF_SCHEMA_COLUMNS_NAMES)}
+        for column_name in columns:
+            r = row.copy()
+            r[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME] = column_name
+            data.append(r)
+
+        return pd.DataFrame(data, columns=astuple(INF_SCHEMA_COLUMNS_NAMES))
+
+    def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Get a list of column names for the specified table.
+
+        Args:
+            table_name (str): The name of the table to get columns from.
+            schema_name (str | None): Not in use. The name of the schema to get columns from.
+
+        Returns:
+            list[str]: A list of column names for the specified table.
+        """
+        return self.project.get_columns(table_name)
 
     def predict(self, model_name: str, df, version=None, params=None):
         model_metadata = self.project.get_model(model_name)
@@ -148,7 +180,7 @@ class ProjectDataNode(DataNode):
         else:
             raise NotImplementedError(f"Query not supported {query}")
 
-    def create_table(self, table_name: Identifier, result_set=None, is_replace=False, **kwargs) -> DataHubResponse:
+    def create_table(self, table_name: Identifier, result_set=None, is_replace=False, params=None, **kwargs) -> DataHubResponse:
         # is_create - create table
         # is_replace - drop table if exists
         # is_create==False and is_replace==False: just insert
@@ -164,6 +196,6 @@ class ProjectDataNode(DataNode):
                 kb_table.clear()
 
             df = result_set.to_df()
-            kb_table.insert(df)
+            kb_table.insert(df, params=params)
             return DataHubResponse()
         raise NotImplementedError(f"Can't create table {table_name}")