MindsDB 25.3.4.2__py3-none-any.whl → 25.4.2.0__py3-none-any.whl

mindsdb/api/executor/planner/steps.py

@@ -249,11 +249,12 @@ class SubSelectStep(PlanStep):
 
 
 class QueryStep(PlanStep):
-    def __init__(self, query, from_table=None, *args, **kwargs):
+    def __init__(self, query, from_table=None, *args, strict_where=True, **kwargs):
         """Performs query using injected dataframe"""
         super().__init__(*args, **kwargs)
         self.query = query
         self.from_table = from_table
+        self.strict_where = strict_where
 
 
 class DataStep(PlanStep):

mindsdb/api/executor/sql_query/result_set.py

@@ -50,13 +50,14 @@ def rename_df_columns(df: pd.DataFrame, names: Optional[List] = None) -> None:
 
 
 class ResultSet:
-    def __init__(self, columns=None, values: List[List] = None, df: pd.DataFrame = None):
-        '''
-
-        :param columns: list of Columns
-        :param values: data of resultSet, have to be list of lists with length equal to column
-        :param df: injected dataframe, have to have enumerated columns and length equal to columns
-        '''
+    def __init__(self, columns=None, values: List[List] = None, df: pd.DataFrame = None, affected_rows: int = None):
+        """
+        Args:
+            columns: list of Columns
+            values (List[List]): data of resultSet, have to be list of lists with length equal to column
+            df (pd.DataFrame): injected dataframe, have to have enumerated columns and length equal to columns
+            affected_rows (int): number of affected rows
+        """
         if columns is None:
             columns = []
         self._columns = columns
@@ -67,6 +68,8 @@ class ResultSet:
             df = pd.DataFrame(values)
         self._df = df
 
+        self.affected_rows = affected_rows
+
         self.is_prediction = False
 
     def __repr__(self):

mindsdb/api/executor/sql_query/sql_query.py

@@ -8,9 +8,9 @@
  * permission of MindsDB Inc
  *******************************************************
 """
-import re
 import inspect
 from textwrap import dedent
+from typing import Dict
 
 from mindsdb_sql_parser import parse_sql
 from mindsdb.api.executor.planner.steps import (
@@ -23,7 +23,7 @@ from mindsdb.api.executor.planner.exceptions import PlanningException
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.api.executor.planner import query_planner
 
-from mindsdb.api.executor.utilities.sql import query_df, get_query_models
+from mindsdb.api.executor.utilities.sql import get_query_models
 from mindsdb.interfaces.model.functions import get_model_record
 from mindsdb.api.executor.exceptions import (
     BadTableError,
@@ -38,8 +38,6 @@ from . import steps
 from .result_set import ResultSet, Column
 from . steps.base import BaseStepCall
 
-superset_subquery = re.compile(r'from[\s\n]*(\(.*\))[\s\n]*as[\s\n]*virtual_table', flags=re.IGNORECASE | re.MULTILINE | re.S)
-
 
 class SQLQuery:
 
@@ -59,23 +57,13 @@ class SQLQuery:
         }
 
         self.columns_list = None
-        self.steps_data = {}
+        self.steps_data: Dict[int, ResultSet] = {}
 
-        self.planner = None
+        self.planner: query_planner.QueryPlanner = None
         self.parameters = []
-        self.fetched_data = None
-
-        self.outer_query = None
+        self.fetched_data: ResultSet = None
 
         if isinstance(sql, str):
-            # region workaround for subqueries in superset
-            if 'as virtual_table' in sql.lower():
-                subquery = re.findall(superset_subquery, sql)
-                if isinstance(subquery, list) and len(subquery) == 1:
-                    subquery = subquery[0]
-                    self.outer_query = sql.replace(subquery, 'dataframe')
-                    sql = subquery.strip('()')
-            # endregion
             self.query = parse_sql(sql)
             self.context['query_str'] = sql
         else:
@@ -89,7 +77,6 @@ class SQLQuery:
         self.create_planner()
 
         if execute:
-            self.prepare_query(prepare=False)
             self.execute_query()
 
     @classmethod
@@ -190,55 +177,42 @@ class SQLQuery:
             default_namespace=database,
         )
 
-    def fetch(self, view='result_set'):
-        data = self.fetched_data
-
-        if view == 'dataframe':
-            result = data.to_df()
-        else:
-            result = data
+    def prepare_query(self):
+        """it is prepared statement call
+        """
+        try:
+            for step in self.planner.prepare_steps(self.query):
+                data = self.execute_step(step)
+                step.set_result(data)
+                self.steps_data[step.step_num] = data
+        except PlanningException as e:
+            raise LogicError(e)
 
-        return {
-            'success': True,
-            'result': result
-        }
+        statement_info = self.planner.get_statement_info()
 
-    def prepare_query(self, prepare=True):
-        if prepare:
-            # it is prepared statement call
-            try:
-                for step in self.planner.prepare_steps(self.query):
-                    data = self.execute_step(step)
-                    step.set_result(data)
-                    self.steps_data[step.step_num] = data
-            except PlanningException as e:
-                raise LogicError(e)
-
-            statement_info = self.planner.get_statement_info()
-
-            self.columns_list = []
-            for col in statement_info['columns']:
-                self.columns_list.append(
-                    Column(
-                        database=col['ds'],
-                        table_name=col['table_name'],
-                        table_alias=col['table_alias'],
-                        name=col['name'],
-                        alias=col['alias'],
-                        type=col['type']
-                    )
-                )
-
-            self.parameters = [
+        self.columns_list = []
+        for col in statement_info['columns']:
+            self.columns_list.append(
                 Column(
+                    database=col['ds'],
+                    table_name=col['table_name'],
+                    table_alias=col['table_alias'],
                     name=col['name'],
                     alias=col['alias'],
                     type=col['type']
                 )
-                for col in statement_info['parameters']
-            ]
-
-    def execute_query(self, params=None):
+            )
+
+        self.parameters = [
+            Column(
+                name=col['name'],
+                alias=col['alias'],
+                type=col['type']
+            )
+            for col in statement_info['parameters']
+        ]
+
+    def execute_query(self):
         if self.fetched_data is not None:
             # no need to execute
             return
@@ -246,7 +220,7 @@ class SQLQuery:
         step_result = None
         process_mark = None
         try:
-            steps = list(self.planner.execute_steps(params))
+            steps = list(self.planner.execute_steps())
             steps_classes = (x.__class__ for x in steps)
             predict_steps = (ApplyPredictorRowStep, ApplyPredictorStep, ApplyTimeseriesPredictorStep)
             if any(s in predict_steps for s in steps_classes):
@@ -270,27 +244,7 @@ class SQLQuery:
         if len(self.steps_data) == 0:
             return
 
-        try:
-            if self.outer_query is not None:
-                # workaround for subqueries in superset. remove it?
-                # +++
-                # ???
-
-                result = step_result
-                df = result.to_df()
-
-                df2 = query_df(df, self.outer_query)
-
-                result2 = ResultSet().from_df(df2, database='', table_name='')
-
-                self.columns_list = result2.columns
-                self.fetched_data = result2
-
-            else:
-                result = step_result
-                self.fetched_data = result
-        except Exception as e:
-            raise UnknownError("error in preparing result query step") from e
+        self.fetched_data = step_result
 
         try:
             if hasattr(self, 'columns_list') is False:

mindsdb/api/executor/sql_query/steps/delete_step.py

@@ -44,6 +44,5 @@ class DeleteStepCall(BaseStepCall):
 
         query_traversal(query.where, fill_params)
 
-        dn.query(query=query, session=self.session)
-
-        return ResultSet()
+        response = dn.query(query=query, session=self.session)
+        return ResultSet(affected_rows=response.affected_rows)

mindsdb/api/executor/sql_query/steps/fetch_dataframe.py

@@ -89,10 +89,11 @@ class FetchDataframeStepCall(BaseStepCall):
             table_alias = (self.context.get('database'), 'result', 'result')
 
             # fetch raw_query
-            df, columns_info = dn.query(
+            response = dn.query(
                 native_query=step.raw_query,
                 session=self.session
             )
+            df = response.data_frame
         else:
             table_alias = get_table_alias(step.query.from_table, self.context.get('database'))
 
@@ -104,13 +105,14 @@ class FetchDataframeStepCall(BaseStepCall):
 
             query, context_callback = query_context_controller.handle_db_context_vars(query, dn, self.session)
 
-            df, columns_info = dn.query(
+            response = dn.query(
                 query=query,
                 session=self.session
             )
+            df = response.data_frame
 
             if context_callback:
-                context_callback(df, columns_info)
+                context_callback(df, response.columns)
 
         result = ResultSet()
 

mindsdb/api/executor/sql_query/steps/insert_step.py

@@ -91,13 +91,13 @@ class InsertToTableCall(BaseStepCall):
             else:
                 col_names.add(col.alias)
 
-        dn.create_table(
+        response = dn.create_table(
             table_name=table_name,
             result_set=data,
             is_replace=is_replace,
             is_create=is_create
         )
-        return ResultSet()
+        return ResultSet(affected_rows=response.affected_rows)
 
 
 class SaveToTableCall(InsertToTableCall):

mindsdb/api/executor/sql_query/steps/prepare_steps.py

@@ -47,10 +47,10 @@ class GetTableColumnsCall(BaseStepCall):
         dn = self.session.datahub.get(step.namespace)
         ds_query = Select(from_table=Identifier(table), targets=[Star()], limit=Constant(0))
 
-        data, columns_info = dn.query(ds_query, session=self.session)
+        response = dn.query(ds_query, session=self.session)
 
         data = ResultSet()
-        for column in columns_info:
+        for column in response.columns:
             data.add_column(Column(
                 name=column['name'],
                 type=column.get('type'),

mindsdb/api/executor/sql_query/steps/subselect_step.py

@@ -3,13 +3,7 @@ from collections import defaultdict
 import pandas as pd
 
 from mindsdb_sql_parser.ast import (
-    Identifier,
-    Select,
-    Star,
-    Constant,
-    Parameter,
-    Function,
-    Variable
+    Identifier, Select, Star, Constant, Parameter, Function, Variable, BinaryOperation
 )
 
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import SERVER_VARIABLES
@@ -87,7 +81,7 @@ class QueryStepCall(BaseStepCall):
 
     bind = QueryStep
 
-    def call(self, step):
+    def call(self, step: QueryStep):
         query = step.query
 
         if step.from_table is not None:
@@ -190,6 +184,24 @@ class QueryStepCall(BaseStepCall):
         fill_params = get_fill_param_fnc(self.steps_data)
         query_traversal(query, fill_params)
 
+        if not step.strict_where:
+            # remove conditions with not-existed columns.
+            #   these conditions can be already used as input to model or knowledge base
+            #   but can be absent in their output
+
+            def remove_not_used_conditions(node, **kwargs):
+                # find last in where
+                if isinstance(node, BinaryOperation):
+                    for arg in node.args:
+                        if isinstance(arg, Identifier) and len(arg.parts) > 1:
+                            key = tuple(arg.parts[-2:])
+                            if key not in col_idx:
+                                # exclude
+                                node.args = [Constant(0), Constant(0)]
+                                node.op = '='
+
+            query_traversal(query.where, remove_not_used_conditions)
+
         query_traversal(query, check_fields)
         query.where = query_context_controller.remove_lasts(query.where)
 

mindsdb/api/executor/sql_query/steps/update_step.py

@@ -18,8 +18,6 @@ class UpdateToTableCall(BaseStepCall):
     bind = UpdateToTable
 
     def call(self, step):
-        data = ResultSet()
-
         if len(step.table.parts) > 1:
             integration_name = step.table.parts[0]
             table_name_parts = step.table.parts[1:]
@@ -85,8 +83,8 @@ class UpdateToTableCall(BaseStepCall):
 
             if result_step is None:
                 # run as is
-                dn.query(query=update_query, session=self.session)
-                return data
+                response = dn.query(query=update_query, session=self.session)
+                return ResultSet(affected_rows=response.affected_rows)
             result_data = self.steps_data[result_step.result.step_num]
 
             # link nodes with parameters for fast replacing with values
@@ -125,5 +123,5 @@ class UpdateToTableCall(BaseStepCall):
             for param_name, param in params_map_index:
                 param.value = row[param_name]
 
-            dn.query(query=update_query, session=self.session)
-        return data
+            response = dn.query(query=update_query, session=self.session)
+        return ResultSet(affected_rows=response.affected_rows)

mindsdb/api/http/namespaces/sql.py

@@ -59,7 +59,10 @@ class Query(Resource):
                 result = mysql_proxy.process_query(query)
 
                 if result.type == SQL_RESPONSE_TYPE.OK:
-                    query_response = {"type": SQL_RESPONSE_TYPE.OK}
+                    query_response = {
+                        "type": SQL_RESPONSE_TYPE.OK,
+                        "affected_rows": result.affected_rows
+                    }
                 elif result.type == SQL_RESPONSE_TYPE.TABLE:
                     data = result.data.to_lists(json_types=True)
                     query_response = {

mindsdb/api/mcp/start.py

@@ -0,0 +1,152 @@
+from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+
+from mcp.server.fastmcp import FastMCP
+from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
+from mindsdb.utilities import log
+from mindsdb.utilities.config import Config
+from mindsdb.interfaces.storage import db
+
+logger = log.getLogger(__name__)
+
+
+@dataclass
+class AppContext:
+    db: Any
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
+    """Manage application lifecycle with type-safe context"""
+    # Initialize on startup
+    db.init()
+    try:
+        yield AppContext(db=db)
+    finally:
+        # TODO: We need better way to handle this in storage/db.py
+        pass
+
+
+# Configure server with lifespan
+mcp = FastMCP(
+    "MindsDB",
+    lifespan=app_lifespan,
+    dependencies=["mindsdb"]  # Add any additional dependencies
+)
+# MCP Queries
+LISTING_QUERY = "SHOW DATABASES"
+
+
+@mcp.tool()
+def query(query: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+    """
+    Execute a SQL query against MindsDB
+
+    Args:
+        query: The SQL query to execute
+        context: Optional context parameters for the query
+
+    Returns:
+        Dict containing the query results or error information
+    """
+
+    if context is None:
+        context = {}
+
+    logger.debug(f'Incoming MCP query: {query}')
+
+    mysql_proxy = FakeMysqlProxy()
+    mysql_proxy.set_context(context)
+
+    try:
+        result = mysql_proxy.process_query(query)
+
+        if result.type == SQL_RESPONSE_TYPE.OK:
+            return {"type": SQL_RESPONSE_TYPE.OK}
+
+        if result.type == SQL_RESPONSE_TYPE.TABLE:
+            return {
+                "type": SQL_RESPONSE_TYPE.TABLE,
+                "data": result.data.to_lists(json_types=True),
+                "column_names": [
+                    x["alias"] or x["name"] if "alias" in x else x["name"]
+                    for x in result.columns
+                ],
+            }
+        else:
+            return {
+                "type": SQL_RESPONSE_TYPE.ERROR,
+                "error_code": 0,
+                "error_message": "Unknown response type"
+            }
+
+    except Exception as e:
+        logger.error(f"Error processing query: {str(e)}")
+        return {
+            "type": SQL_RESPONSE_TYPE.ERROR,
+            "error_code": 0,
+            "error_message": str(e)
+        }
+
+
+@mcp.tool()
+def list_databases() -> Dict[str, Any]:
+    """
+    List all databases in MindsDB along with their tables
+
+    Returns:
+        Dict containing the list of databases and their tables
+    """
+
+    mysql_proxy = FakeMysqlProxy()
+
+    try:
+        result = mysql_proxy.process_query(LISTING_QUERY)
+        if result.type == SQL_RESPONSE_TYPE.ERROR:
+            return {
+                "type": "error",
+                "error_code": result.error_code,
+                "error_message": result.error_message,
+            }
+
+        elif result.type == SQL_RESPONSE_TYPE.OK:
+            return {"type": "ok"}
+
+        elif result.type == SQL_RESPONSE_TYPE.TABLE:
+            data = result.data.to_lists(json_types=True)
+            return data
+
+    except Exception as e:
+        return {
+            "type": "error",
+            "error_code": 0,
+            "error_message": str(e),
+        }
+
+
+def start(*args, **kwargs):
+    """Start the MCP server
+    Args:
+        host (str): Host to bind to
+        port (int): Port to listen on
+    """
+    config = Config()
+    port = int(config['api'].get('mcp', {}).get('port', 47337))
+    host = config['api'].get('mcp', {}).get('host', '127.0.0.1')
+
+    logger.info(f"Starting MCP server on {host}:{port}")
+    mcp.settings.host = host
+    mcp.settings.port = port
+
+    try:
+        mcp.run(transport="sse")  # Use SSE transport instead of stdio
+    except Exception as e:
+        logger.error(f"Error starting MCP server: {str(e)}")
+        raise
+
+
+if __name__ == "__main__":
+    start()

mindsdb/api/mysql/mysql_proxy/data_types/mysql_packets/ok_packet.py

@@ -40,7 +40,7 @@ class OkPacket(Packet):
     def setup(self):
         eof = self._kwargs.get('eof', False)
         self.ok_header = Datum('int<1>', 0xFE if eof is True else 0)
-        self.affected_rows = Datum('int<lenenc>', self._kwargs.get('affected_rows', 0))
+        self.affected_rows = Datum('int<lenenc>', self._kwargs.get('affected_rows') or 0)
         self.last_insert_id = Datum('int<lenenc>', 0)
         status = self._kwargs.get('status', 0x0002)
         self.server_status = Datum('int<2>', status)

mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py

@@ -4,6 +4,7 @@ from mindsdb.api.executor.planner import utils as planner_utils
 import mindsdb.utilities.profiler as profiler
 from mindsdb.api.executor.sql_query.result_set import Column
 from mindsdb.api.executor.sql_query import SQLQuery
+from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.command_executor import ExecuteCommands
 from mindsdb.api.mysql.mysql_proxy.utilities import ErSqlSyntaxError
 from mindsdb.utilities import log
@@ -12,37 +13,20 @@ logger = log.getLogger(__name__)
 
 
 class Executor:
-    """This class stores initial and intermediate params
-    between different steps of query execution. And it is also
-    creates a separate instance of ExecuteCommands to execute the current
-    query step.
-
-    IMPORTANT: A public API of this class is a contract.
-    And there are at least 2 classes strongly depend on it:
-        ExecuctorClient
-        ExecutorService.
-    These classes do the same work as Executor when
-    MindsDB works in 'modularity' mode.
-    Thus please make sure that IF you change the API,
-    you must update the API of these two classes as well!"""
-
     def __init__(self, session, sqlserver):
         self.session = session
         self.sqlserver = sqlserver
 
         self.query = None
 
-        # returned values
-        # all this attributes needs to be added in
-        # self.json() method
         self.columns = []
         self.params = []
         self.data = None
-        self.state_track = None
         self.server_status = None
         self.is_executed = False
         self.error_message = None
         self.error_code = None
+        self.executor_answer: ExecuteAnswer = None
 
         self.sql = ""
         self.sql_lower = ""
@@ -126,14 +110,7 @@ class Executor:
         if self.is_executed:
             return
 
-        ret = self.command_executor.execute_command(self.query)
-        self.error_code = ret.error_code
-        self.error_message = ret.error_message
+        executor_answer: ExecuteAnswer = self.command_executor.execute_command(self.query)
+        self.executor_answer = executor_answer
 
         self.is_executed = True
-
-        if ret.data is not None:
-            self.data = ret.data
-            self.columns = ret.data.columns
-
-        self.state_track = ret.state_track

mindsdb/api/mysql/mysql_proxy/libs/constants/mysql.py

@@ -94,6 +94,7 @@ class COMMANDS(object):
     COM_STMT_PREPARE = int('0x16', 0)
     COM_STMT_EXECUTE = int('0x17', 0)
     COM_STMT_FETCH = int('0x1c', 0)
+    COM_STMT_RESET = int('0x1a', 0)
     COM_STMT_CLOSE = int('0x19', 0)
     COM_FIELD_LIST = int('0x04', 0)  # deprecated