MindsDB 25.3.4.1__py3-none-any.whl → 25.4.1.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.3.4.1'
+__version__ = '25.4.1.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

@@ -24,7 +24,8 @@ from mindsdb.__about__ import __version__ as mindsdb_version
 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_http, start_mysql, start_mongo, start_postgres, start_ml_task_queue, start_scheduler, start_tasks,
+    start_mcp
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 from mindsdb.utilities.functions import get_versions_where_predictors_become_obsolete
@@ -57,6 +58,7 @@ class TrunkProcessEnum(Enum):
     JOBS = 'jobs'
     TASKS = 'tasks'
     ML_TASK_QUEUE = 'ml_task_queue'
+    MCP = 'mcp'
 
     @classmethod
     def _missing_(cls, value):
@@ -221,9 +223,9 @@ if __name__ == '__main__':
     ctx.set_default()
 
     # ---- CHECK SYSTEM ----
-    if not (sys.version_info[0] >= 3 and sys.version_info[1] >= 9):
+    if not (sys.version_info[0] >= 3 and sys.version_info[1] >= 10):
         print("""
-     MindsDB requires Python >= 3.9 to run
+     MindsDB requires Python >= 3.10 to run
 
      Once you have supported Python version installed you can start mindsdb as follows:
 
@@ -385,6 +387,7 @@ if __name__ == '__main__':
 
     http_api_config = config['api']['http']
     mysql_api_config = config['api']['mysql']
+    mcp_api_config = config['api']['mcp']
     trunc_processes_struct = {
         TrunkProcessEnum.HTTP: TrunkProcessData(
             name=TrunkProcessEnum.HTTP.value,
@@ -434,11 +437,25 @@ if __name__ == '__main__':
             name=TrunkProcessEnum.ML_TASK_QUEUE.value,
             entrypoint=start_ml_task_queue,
             args=(config.cmd_args.verbose,)
+        ),
+        TrunkProcessEnum.MCP: TrunkProcessData(
+            name=TrunkProcessEnum.MCP.value,
+            entrypoint=start_mcp,
+            port=mcp_api_config.get('port', 47337),
+            args=(config.cmd_args.verbose,),
+            restart_on_failure=mcp_api_config.get('restart_on_failure', False),
+            max_restart_count=mcp_api_config.get('max_restart_count', TrunkProcessData.max_restart_count),
+            max_restart_interval_seconds=mcp_api_config.get(
+                'max_restart_interval_seconds', TrunkProcessData.max_restart_interval_seconds
+            )
         )
     }
 
     for api_enum in api_arr:
-        trunc_processes_struct[api_enum].need_to_run = True
+        if api_enum in trunc_processes_struct:
+            trunc_processes_struct[api_enum].need_to_run = True
+        else:
+            logger.error(f"ERROR: {api_enum} API is not a valid api in config")
 
     if config['jobs']['disable'] is False:
         trunc_processes_struct[TrunkProcessEnum.JOBS].need_to_run = True

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

@@ -64,6 +64,7 @@ class IntegrationDataNode(DataNode):
             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
@@ -78,8 +79,10 @@ class IntegrationDataNode(DataNode):
             names = df[df.columns[col_name]]
 
             # type
-            if 'type' in columns:
-                types = df[df.columns[columns.index('type')]]
+            if 'mysql_data_type' in columns:
+                types = df['mysql_data_type']
+            elif 'type' in columns:
+                types = df['type']
             else:
                 types = [None] * len(names)
 

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

@@ -1,14 +1,17 @@
+from typing import Optional, Literal
+from dataclasses import dataclass, astuple, fields
 
 import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 
+from mindsdb.utilities import log
+from mindsdb.utilities.config import config
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.api.executor.datahub.classes.tables_row import (
     TABLES_ROW_TYPE,
     TablesRow,
 )
-from mindsdb.utilities import log
-from mindsdb.utilities.config import config
 
 logger = log.getLogger(__name__)
 
@@ -162,132 +165,108 @@ class TablesTable(Table):
         return df
 
 
-class ColumnsTable(Table):
+@dataclass
+class ColumnsTableRow:
+    """Represents a row in the COLUMNS table.
+    Fields description: https://dev.mysql.com/doc/refman/8.4/en/information-schema-columns-table.html
+    NOTE: attrs order matter, don't change it.
+    """
+    TABLE_CATALOG: Literal['def'] = 'def'
+    TABLE_SCHEMA: Optional[str] = None
+    TABLE_NAME: Optional[str] = None
+    COLUMN_NAME: Optional[str] = None
+    ORDINAL_POSITION: int = 0
+    COLUMN_DEFAULT: Optional[str] = None
+    IS_NULLABLE: Literal['YES', 'NO'] = 'YES'
+    DATA_TYPE: str = MYSQL_DATA_TYPE.VARCHAR.value
+    CHARACTER_MAXIMUM_LENGTH: Optional[int] = None
+    CHARACTER_OCTET_LENGTH: Optional[int] = None
+    NUMERIC_PRECISION: Optional[int] = None
+    NUMERIC_SCALE: Optional[int] = None
+    DATETIME_PRECISION: Optional[int] = None
+    CHARACTER_SET_NAME: Optional[str] = None
+    COLLATION_NAME: Optional[str] = None
+    COLUMN_TYPE: Optional[str] = None
+    COLUMN_KEY: Optional[str] = None
+    EXTRA: Optional[str] = None
+    PRIVILEGES: str = 'select'
+    COLUMN_COMMENT: Optional[str] = None
+    GENERATION_EXPRESSION: Optional[str] = None
+
+    def __post_init__(self):
+        # region check mandatory fields
+        mandatory_fields = ['TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME']
+        if any(getattr(self, field_name) is None for field_name in mandatory_fields):
+            raise ValueError('One of mandatory fields is missed when creating ColumnsTableRow')
+        # endregion
+
+        # region set default values depend on type
+        defaults = {
+            'COLUMN_TYPE': self.DATA_TYPE
+        }
+        if MYSQL_DATA_TYPE(self.DATA_TYPE) in (
+            MYSQL_DATA_TYPE.TIMESTAMP,
+            MYSQL_DATA_TYPE.DATETIME,
+            MYSQL_DATA_TYPE.DATE
+        ):
+            defaults = {
+                'DATETIME_PRECISION': 0,
+                'COLUMN_TYPE': self.DATA_TYPE
+            }
+        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
+            MYSQL_DATA_TYPE.FLOAT,
+            MYSQL_DATA_TYPE.DOUBLE,
+            MYSQL_DATA_TYPE.DECIMAL
+        ):
+            defaults = {
+                'NUMERIC_PRECISION': 12,
+                'NUMERIC_SCALE': 0,
+                'COLUMN_TYPE': self.DATA_TYPE
+            }
+        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
+            MYSQL_DATA_TYPE.TINYINT,
+            MYSQL_DATA_TYPE.SMALLINT,
+            MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.INT,
+            MYSQL_DATA_TYPE.BIGINT
+        ):
+            defaults = {
+                'NUMERIC_PRECISION': 20,
+                'NUMERIC_SCALE': 0,
+                'COLUMN_TYPE': self.DATA_TYPE
+            }
+        elif MYSQL_DATA_TYPE(self.DATA_TYPE) is MYSQL_DATA_TYPE.VARCHAR:
+            defaults = {
+                'CHARACTER_MAXIMUM_LENGTH': 1024,
+                'CHARACTER_OCTET_LENGTH': 3072,
+                'CHARACTER_SET_NAME': 'utf8',
+                'COLLATION_NAME': 'utf8_bin',
+                'COLUMN_TYPE': 'varchar(1024)'
+            }
+        else:
+            # show as MYSQL_DATA_TYPE.TEXT:
+            defaults = {
+                'CHARACTER_MAXIMUM_LENGTH': 65535,      # from https://bugs.mysql.com/bug.php?id=90685
+                'CHARACTER_OCTET_LENGTH': 65535,        #
+                'CHARACTER_SET_NAME': 'utf8',
+                'COLLATION_NAME': 'utf8_bin',
+                'COLUMN_TYPE': 'text'
+            }
+
+        for key, value in defaults.items():
+            setattr(self, key, value)
 
+        self.DATA_TYPE = self.DATA_TYPE.lower()
+        self.COLUMN_TYPE = self.COLUMN_TYPE.lower()
+        # endregion
+
+
+class ColumnsTable(Table):
     name = 'COLUMNS'
-    columns = [
-        "TABLE_CATALOG",
-        "TABLE_SCHEMA",
-        "TABLE_NAME",
-        "COLUMN_NAME",
-        "ORDINAL_POSITION",
-        "COLUMN_DEFAULT",
-        "IS_NULLABLE",
-        "DATA_TYPE",
-        "CHARACTER_MAXIMUM_LENGTH",
-        "CHARACTER_OCTET_LENGTH",
-        "NUMERIC_PRECISION",
-        "NUMERIC_SCALE",
-        "DATETIME_PRECISION",
-        "CHARACTER_SET_NAME",
-        "COLLATION_NAME",
-        "COLUMN_TYPE",
-        "COLUMN_KEY",
-        "EXTRA",
-        "PRIVILEGES",
-        "COLUMN_COMMENT",
-        "GENERATION_EXPRESSION",
-    ]
+    columns = [field.name for field in fields(ColumnsTableRow)]
 
     @classmethod
     def get_data(cls, inf_schema=None, query: ASTNode = None, **kwargs):
-
-        # NOTE there is a lot of types in mysql, but listed below should be enough for our purposes
-        row_templates = {
-            "text": [
-                "def",
-                "SCHEMA_NAME",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                "COL_INDEX",
-                None,
-                "YES",
-                "varchar",
-                1024,
-                3072,
-                None,
-                None,
-                None,
-                "utf8",
-                "utf8_bin",
-                "varchar(1024)",
-                None,
-                None,
-                "select",
-                None,
-                None,
-            ],
-            "timestamp": [
-                "def",
-                "SCHEMA_NAME",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                "COL_INDEX",
-                "CURRENT_TIMESTAMP",
-                "YES",
-                "timestamp",
-                None,
-                None,
-                None,
-                None,
-                0,
-                None,
-                None,
-                "timestamp",
-                None,
-                None,
-                "select",
-                None,
-                None,
-            ],
-            "bigint": [
-                "def",
-                "SCHEMA_NAME",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                "COL_INDEX",
-                None,
-                "YES",
-                "bigint",
-                None,
-                None,
-                20,
-                0,
-                None,
-                None,
-                None,
-                "bigint unsigned",
-                None,
-                None,
-                "select",
-                None,
-                None,
-            ],
-            "float": [
-                "def",
-                "SCHEMA_NAME",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                "COL_INDEX",
-                None,
-                "YES",
-                "float",
-                None,
-                None,
-                12,
-                0,
-                None,
-                None,
-                None,
-                "float",
-                None,
-                None,
-                "select",
-                None,
-                None,
-            ],
-        }
-
         result = []
 
         databases, tables_names = _get_scope(query)
@@ -320,20 +299,34 @@ class ColumnsTable(Table):
                 for i, column in enumerate(table_columns):
                     column_name = column['name']
                     column_type = column.get('type', 'text')
-                    if column_type in ('double precision', 'real', 'numeric'):
-                        column_type = 'float'
-                    elif column_type in ('integer', 'smallint', 'int'):
-                        column_type = 'bigint'
-                    elif column_type in ('timestamp without time zone', 'timestamp with time zone', 'date'):
-                        column_type = 'timestamp'
-                    elif column_type not in row_templates:
-                        column_type = 'text'
-                    result_row = row_templates[column_type].copy()
-                    result_row[1] = db_name
-                    result_row[2] = table_name
-                    result_row[3] = column_name
-                    result_row[4] = i
-                    result.append(result_row)
+
+                    # region infer type
+                    if isinstance(column_type, MYSQL_DATA_TYPE) is False:
+                        if column_type in ('double precision', 'real', 'numeric', 'float'):
+                            column_type = MYSQL_DATA_TYPE.FLOAT
+                        elif column_type in ('integer', 'smallint', 'int', 'bigint'):
+                            column_type = MYSQL_DATA_TYPE.BIGINT
+                        elif column_type in (
+                            'timestamp without time zone',
+                            'timestamp with time zone',
+                            'date', 'timestamp'
+                        ):
+                            column_type = MYSQL_DATA_TYPE.DATETIME
+                        else:
+                            column_type = MYSQL_DATA_TYPE.VARCHAR
+                    # endregion
+
+                    column_row = astuple(
+                        ColumnsTableRow(
+                            TABLE_SCHEMA=db_name,
+                            TABLE_NAME=table_name,
+                            COLUMN_NAME=column_name,
+                            DATA_TYPE=column_type.value,
+                            ORDINAL_POSITION=i
+                        )
+                    )
+
+                    result.append(column_row)
 
         df = pd.DataFrame(result, columns=cls.columns)
         return df

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/libs/constants/mysql.py

@@ -8,6 +8,7 @@
  * permission of MindsDB Inc
  *******************************************************
 """
+import enum
 
 # CAPABILITIES
 # As defined in : https://dev.mysql.com/doc/dev/mysql-server/8.0.0/group__group__cs__capabilities__flags.html
@@ -101,6 +102,8 @@ COMMANDS = COMMANDS()
 
 
 # FIELD TYPES
+# https://dev.mysql.com/doc/dev/mysql-server/latest/field__types_8h_source.html
+# https://mariadb.com/kb/en/result-set-packets/
 class TYPES(object):
     __slots__ = ()
     MYSQL_TYPE_DECIMAL = 0
@@ -123,6 +126,11 @@ class TYPES(object):
     MYSQL_TYPE_TIMESTAMP2 = 17
     MYSQL_TYPE_DATETIME2 = 18
     MYSQL_TYPE_TIME2 = 19
+    MYSQL_TYPE_TYPED_ARRAY = 20
+    MYSQL_TYPE_VECTOR = 242,
+    MYSQL_TYPE_INVALID = 243,
+    MYSQL_TYPE_BOOL = 244,
+    MYSQL_TYPE_JSON = 245,
     MYSQL_TYPE_NEWDECIMAL = 246
     MYSQL_TYPE_ENUM = 247
     MYSQL_TYPE_SET = 248
@@ -135,9 +143,75 @@ class TYPES(object):
     MYSQL_TYPE_GEOMETRY = 255
 
 
+C_TYPES = TYPES()
 TYPES = TYPES()
 
 
+class MYSQL_DATA_TYPE(enum.Enum):
+    TINYINT = 'TINYINT'
+    SMALLINT = 'SMALLINT'
+    MEDIUMINT = 'MEDIUMINT'
+    INT = 'INT'
+    BIGINT = 'BIGINT'
+    FLOAT = 'FLOAT'
+    DOUBLE = 'DOUBLE'
+    DECIMAL = 'DECIMAL'
+    YEAR = 'YEAR'
+    TIME = 'TIME'
+    DATE = 'DATE'
+    DATETIME = 'DATETIME'
+    TIMESTAMP = 'TIMESTAMP'
+    CHAR = 'CHAR'
+    BINARY = 'BINARY'
+    VARCHAR = 'VARCHAR'
+    VARBINARY = 'VARBINARY'
+    TINYBLOB = 'TINYBLOB'
+    TINYTEXT = 'TINYTEXT'
+    BLOB = 'BLOB'
+    TEXT = 'TEXT'
+    MEDIUMBLOB = 'MEDIUMBLOB'
+    MEDIUMTEXT = 'MEDIUMTEXT'
+    LONGBLOB = 'LONGBLOB'
+    LONGTEXT = 'LONGTEXT'
+    BIT = 'BIT'
+    BOOL = 'BOOL'
+    BOOLEAN = 'BOOLEAN'
+
+
+# Map between data types and C types
+# https://dev.mysql.com/doc/c-api/8.0/en/c-api-prepared-statement-type-codes.html
+DATA_C_TYPE_MAP = {
+    MYSQL_DATA_TYPE.TINYINT: C_TYPES.MYSQL_TYPE_TINY,
+    MYSQL_DATA_TYPE.SMALLINT: C_TYPES.MYSQL_TYPE_SHORT,
+    MYSQL_DATA_TYPE.MEDIUMINT: C_TYPES.MYSQL_TYPE_INT24,
+    MYSQL_DATA_TYPE.INT: C_TYPES.MYSQL_TYPE_LONG,
+    MYSQL_DATA_TYPE.BIGINT: C_TYPES.MYSQL_TYPE_LONGLONG,
+    MYSQL_DATA_TYPE.FLOAT: C_TYPES.MYSQL_TYPE_FLOAT,
+    MYSQL_DATA_TYPE.DOUBLE: C_TYPES.MYSQL_TYPE_DOUBLE,
+    MYSQL_DATA_TYPE.DECIMAL: C_TYPES.MYSQL_TYPE_NEWDECIMAL,
+    MYSQL_DATA_TYPE.YEAR: C_TYPES.MYSQL_TYPE_SHORT,
+    MYSQL_DATA_TYPE.TIME: C_TYPES.MYSQL_TYPE_TIME,
+    MYSQL_DATA_TYPE.DATE: C_TYPES.MYSQL_TYPE_DATE,
+    MYSQL_DATA_TYPE.DATETIME: C_TYPES.MYSQL_TYPE_DATETIME,
+    MYSQL_DATA_TYPE.TIMESTAMP: C_TYPES.MYSQL_TYPE_TIMESTAMP,
+    MYSQL_DATA_TYPE.CHAR: C_TYPES.MYSQL_TYPE_STRING,
+    MYSQL_DATA_TYPE.BINARY: C_TYPES.MYSQL_TYPE_STRING,
+    MYSQL_DATA_TYPE.VARCHAR: C_TYPES.MYSQL_TYPE_VAR_STRING,
+    MYSQL_DATA_TYPE.VARBINARY: C_TYPES.MYSQL_TYPE_VAR_STRING,
+    MYSQL_DATA_TYPE.TINYBLOB: C_TYPES.MYSQL_TYPE_TINY_BLOB,
+    MYSQL_DATA_TYPE.TINYTEXT: C_TYPES.MYSQL_TYPE_TINY_BLOB,
+    MYSQL_DATA_TYPE.BLOB: C_TYPES.MYSQL_TYPE_BLOB,
+    MYSQL_DATA_TYPE.TEXT: C_TYPES.MYSQL_TYPE_BLOB,
+    MYSQL_DATA_TYPE.MEDIUMBLOB: C_TYPES.MYSQL_TYPE_MEDIUM_BLOB,
+    MYSQL_DATA_TYPE.MEDIUMTEXT: C_TYPES.MYSQL_TYPE_MEDIUM_BLOB,
+    MYSQL_DATA_TYPE.LONGBLOB: C_TYPES.MYSQL_TYPE_LONG_BLOB,
+    MYSQL_DATA_TYPE.LONGTEXT: C_TYPES.MYSQL_TYPE_LONG_BLOB,
+    MYSQL_DATA_TYPE.BIT: C_TYPES.MYSQL_TYPE_BIT,
+    MYSQL_DATA_TYPE.BOOL: C_TYPES.MYSQL_TYPE_TINY,
+    MYSQL_DATA_TYPE.BOOLEAN: C_TYPES.MYSQL_TYPE_TINY
+}
+
+
 class FIELD_FLAG(object):
     __slots__ = ()
     NOT_NULL = 1                # field cannot be null

mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py

@@ -149,8 +149,20 @@ class ConfluenceAPIClient:
         results.extend(response["results"])
 
         while response["_links"].get("next"):
-            params["cursor"] = response["_links"].get("next")
-            response = self._make_request("GET", url, params)
+            next_url = response["_links"].get("next")
+            next_params = {}
+            if params:
+                next_params.update(params)
+            if "cursor=" in next_url:
+                # cursor= is 7 characters long
+                cursor_start = next_url.find("cursor=") + 7
+                cursor_value = next_url[cursor_start:]
+                if "&" in cursor_value:
+                    cursor_value = cursor_value.split("&")[0]
+                next_params["cursor"] = cursor_value
+                response = self._make_request("GET", url, next_params)
+            else:
+                response = self._make_request("GET", next_url)
             results.extend(response["results"])
 
         return results