MindsDB 25.9.3rc1__py3-none-any.whl → 25.10.0rc1__py3-none-any.whl

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import pandas as pd
 import mysql.connector
 
@@ -6,7 +8,7 @@ from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.utilities import log
-from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.integrations.libs.base import MetaDatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
@@ -104,7 +106,7 @@ def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQ
     return response
 
 
-class MySQLHandler(DatabaseHandler):
+class MySQLHandler(MetaDatabaseHandler):
     """
     This handler handles connection and execution of the MySQL statements.
     """
@@ -237,7 +239,6 @@ class MySQLHandler(DatabaseHandler):
         Returns:
             Response: A response object containing the result of the query or an error message.
         """
-
         need_to_close = not self.is_connected
         connection = None
         try:
@@ -314,3 +315,234 @@ class MySQLHandler(DatabaseHandler):
         result = self.native_query(q)
         result.to_columns_table_response(map_type_fn=_map_type)
         return result
+
+    def meta_get_tables(self, table_names: Optional[list[str]] = None) -> Response:
+        """
+        Retrieves metadata information about the tables in the MySQL database
+        to be stored in the data catalog.
+
+        Args:
+            table_names (list): A list of table names for which to retrieve metadata information.
+
+        Returns:
+            Response: A response object containing the metadata information.
+        """
+        query = """
+            SELECT 
+                t.TABLE_NAME as table_name,
+                t.TABLE_SCHEMA as table_schema,
+                t.TABLE_TYPE as table_type,
+                t.TABLE_COMMENT as table_description,
+                t.TABLE_ROWS as row_count
+            FROM information_schema.TABLES t
+            WHERE t.TABLE_SCHEMA = DATABASE()
+                AND t.TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND t.TABLE_NAME IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY t.TABLE_NAME"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_columns(self, table_names: Optional[list[str]] = None) -> Response:
+        """
+        Retrieves column metadata for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (list): A list of table names for which to retrieve column metadata.
+
+        Returns:
+            Response: A response object containing the column metadata.
+        """
+        query = """
+            SELECT 
+                c.TABLE_NAME as table_name,
+                c.COLUMN_NAME as column_name,
+                c.DATA_TYPE as data_type,
+                c.COLUMN_COMMENT as column_description,
+                c.COLUMN_DEFAULT as column_default,
+                CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END as is_nullable
+            FROM information_schema.COLUMNS c
+            WHERE c.TABLE_SCHEMA = DATABASE()
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND c.TABLE_NAME IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_column_statistics(self, table_names: Optional[list[str]] = None) -> Response:
+        """
+        Retrieves column statistics for the specified tables (or all tables if no list is provided).
+        Uses MySQL 8.0+ metadata sources (INFORMATION_SCHEMA.COLUMN_STATISTICS and INFORMATION_SCHEMA.STATISTICS) not requiring table scans.
+
+        Args:
+            table_names (list): A list of table names for which to retrieve column statistics.
+
+        Returns:
+            Response: A response object containing the column statistics.
+        """
+        table_filter = ""
+        if table_names:
+            quoted = ",".join(f"'{t}'" for t in table_names)
+            table_filter = f" AND c.TABLE_NAME IN ({quoted})"
+
+        query = f"""
+            WITH cols AS (
+                SELECT c.TABLE_SCHEMA, c.TABLE_NAME, c.COLUMN_NAME, c.ORDINAL_POSITION
+                FROM information_schema.COLUMNS c
+                WHERE c.TABLE_SCHEMA = DATABASE()
+                {table_filter}
+            ),
+            hist AS (
+                SELECT
+                    cs.SCHEMA_NAME AS TABLE_SCHEMA,
+                    cs.TABLE_NAME,
+                    cs.COLUMN_NAME,
+                    cs.HISTOGRAM,
+                    JSON_LENGTH(cs.HISTOGRAM, '$.buckets') AS buckets_len
+                FROM information_schema.COLUMN_STATISTICS cs
+                WHERE cs.SCHEMA_NAME = DATABASE()
+            ),
+            ndv AS (
+                SELECT
+                    s.TABLE_SCHEMA,
+                    s.TABLE_NAME,
+                    s.COLUMN_NAME,
+                    MAX(s.CARDINALITY) AS DISTINCT_VALUES_COUNT
+                FROM information_schema.STATISTICS s
+                WHERE s.TABLE_SCHEMA = DATABASE()
+                GROUP BY s.TABLE_SCHEMA, s.TABLE_NAME, s.COLUMN_NAME
+            )
+            SELECT
+                c.TABLE_NAME  AS TABLE_NAME,
+                c.COLUMN_NAME AS COLUMN_NAME,
+
+                /* optional fields kept NULL for simplicity */
+                CAST(NULL AS JSON) AS MOST_COMMON_VALUES,
+                CAST(NULL AS JSON) AS MOST_COMMON_FREQUENCIES,
+
+                /* histogram "null-values" fraction -> percent */
+                CASE
+                WHEN h.HISTOGRAM IS NULL THEN NULL
+                ELSE ROUND(
+                        CAST(JSON_UNQUOTE(JSON_EXTRACT(h.HISTOGRAM, '$."null-values"')) AS DECIMAL(10,6)) * 100,
+                        2
+                    )
+                END AS NULL_PERCENTAGE,
+                /* MIN: first bucket's point (singleton) or lower endpoint (equi-height) */
+                CASE
+                WHEN h.HISTOGRAM IS NULL THEN NULL
+                ELSE COALESCE(
+                        JSON_UNQUOTE(JSON_EXTRACT(h.HISTOGRAM, '$.buckets[0].value')),
+                        JSON_UNQUOTE(JSON_EXTRACT(h.HISTOGRAM, '$.buckets[0].endpoint[0]'))
+                    )
+                END AS MINIMUM_VALUE,
+
+                /* MAX: last bucket's point (singleton) or upper endpoint (equi-height) */
+                CASE
+                WHEN h.HISTOGRAM IS NULL THEN NULL
+                ELSE COALESCE(
+                        JSON_UNQUOTE(
+                        JSON_EXTRACT(h.HISTOGRAM,
+                            CONCAT('$.buckets[', GREATEST(h.buckets_len - 1, 0), '].value')
+                        )
+                        ),
+                        JSON_UNQUOTE(
+                        JSON_EXTRACT(h.HISTOGRAM,
+                            CONCAT('$.buckets[', GREATEST(h.buckets_len - 1, 0), '].endpoint[1]')
+                        )
+                        ),
+                        JSON_UNQUOTE(
+                        JSON_EXTRACT(h.HISTOGRAM,
+                            CONCAT('$.buckets[', GREATEST(h.buckets_len - 1, 0), '].endpoint[0]')
+                        )
+                        )
+                    )
+                END AS MAXIMUM_VALUE,
+                n.DISTINCT_VALUES_COUNT
+            FROM cols c
+            LEFT JOIN hist h
+                ON h.TABLE_SCHEMA = c.TABLE_SCHEMA
+                AND h.TABLE_NAME  = c.TABLE_NAME
+                AND h.COLUMN_NAME = c.COLUMN_NAME
+            LEFT JOIN ndv n
+                ON n.TABLE_SCHEMA = c.TABLE_SCHEMA
+                AND n.TABLE_NAME   = c.TABLE_NAME
+                AND n.COLUMN_NAME  = c.COLUMN_NAME
+            ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION;
+        """
+        return self.native_query(query)
+
+    def meta_get_primary_keys(self, table_names: Optional[list[str]] = None) -> Response:
+        """
+        Retrieves primary key information for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (list): A list of table names for which to retrieve primary key information.
+
+        Returns:
+            Response: A response object containing the primary key information.
+        """
+        query = """
+            SELECT 
+                tc.TABLE_NAME as table_name,
+                kcu.COLUMN_NAME as column_name,
+                kcu.ORDINAL_POSITION as ordinal_position,
+                tc.CONSTRAINT_NAME as constraint_name
+            FROM information_schema.TABLE_CONSTRAINTS tc
+            INNER JOIN information_schema.KEY_COLUMN_USAGE kcu
+                ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+                AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+                AND tc.TABLE_NAME = kcu.TABLE_NAME
+            WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+                AND tc.TABLE_SCHEMA = DATABASE()
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND tc.TABLE_NAME IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY tc.TABLE_NAME, kcu.ORDINAL_POSITION"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_foreign_keys(self, table_names: Optional[list[str]] = None) -> Response:
+        """
+        Retrieves foreign key information for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (list): A list of table names for which to retrieve foreign key information.
+
+        Returns:
+            Response: A response object containing the foreign key information.
+        """
+        query = """
+            SELECT 
+                kcu.REFERENCED_TABLE_NAME as parent_table_name,
+                kcu.REFERENCED_COLUMN_NAME as parent_column_name,
+                kcu.TABLE_NAME as child_table_name,
+                kcu.COLUMN_NAME as child_column_name,
+                kcu.CONSTRAINT_NAME as constraint_name
+            FROM information_schema.KEY_COLUMN_USAGE kcu
+            WHERE kcu.TABLE_SCHEMA = DATABASE()
+                AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND kcu.TABLE_NAME IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY kcu.TABLE_NAME, kcu.CONSTRAINT_NAME"
+
+        result = self.native_query(query)
+        return result

mindsdb/integrations/handlers/oracle_handler/__init__.py

@@ -2,8 +2,10 @@ from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
 from .connection_args import connection_args, connection_args_example
+
 try:
     from .oracle_handler import OracleHandler as Handler
+
     import_error = None
 except Exception as e:
     Handler = None

mindsdb/integrations/handlers/oracle_handler/connection_args.py

@@ -64,7 +64,13 @@ connection_args = OrderedDict(
         "description": "Set to `true` to use thick mode for the connection. Thin mode is used by default.",
         "required": False,
         "label": "Connection mode",
-    }
+    },
+    oracle_client_lib_dir={
+        "type": ARG_TYPE.STR,
+        "description": "The directory path where Oracle client libraries are located. Required if using thick mode.",
+        "required": False,
+        "label": "Oracle Client Library Directory",
+    },
 )
 
 connection_args_example = OrderedDict(