MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.1__py3-none-any.whl

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -10,16 +10,17 @@ from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 from mindsdb.integrations.handlers.mysql_handler.settings import ConnectionConfig
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import C_TYPES, DATA_C_TYPE_MAP
 
 logger = log.getLogger(__name__)
 
 
 def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
-    """ Map MySQL text types names to MySQL types as enum.
+    """Map MySQL text types names to MySQL types as enum.
 
     Args:
         mysql_type_text (str): The name of the MySQL type to map.
@@ -30,23 +31,95 @@ def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
     try:
         return MYSQL_DATA_TYPE(mysql_type_text.upper())
     except Exception:
-        logger.warning(f'MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback.')
+        logger.warning(
+            f"MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback."
+        )
         return MYSQL_DATA_TYPE.TEXT
 
 
+def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQLCursor) -> Response:
+    """Build response from result and cursor.
+
+    Args:
+        result (list[dict]): result of the query.
+        cursor (mysql.connector.cursor.MySQLCursor): cursor object.
+
+    Returns:
+        Response: response object.
+    """
+    description = cursor.description
+    reverse_c_type_map = {v.code: k for k, v in DATA_C_TYPE_MAP.items() if v.code != C_TYPES.MYSQL_TYPE_BLOB}
+    mysql_types: list[MYSQL_DATA_TYPE] = []
+    for col in description:
+        type_int = col[1]
+        if isinstance(type_int, int) is False:
+            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            continue
+
+        if type_int == C_TYPES.MYSQL_TYPE_TINY:
+            # There are 3 types that returns as TINYINT: TINYINT, BOOL, BOOLEAN.
+            mysql_types.append(MYSQL_DATA_TYPE.TINYINT)
+            continue
+
+        if type_int in reverse_c_type_map:
+            mysql_types.append(reverse_c_type_map[type_int])
+            continue
+
+        if type_int != C_TYPES.MYSQL_TYPE_BLOB:
+            raise ValueError(f'Unknown MySQL type id={type_int} in column {col[0]}')
+
+        # region determine text/blob type by flags
+        # Unfortunately, there is no way to determine particular type of text/blob column by flags.
+        # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
+        # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
+        # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
+        if col[7] == 16:  # and col[8] == 45
+            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+        elif col[7] == 144:  # and col[8] == 63
+            mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+        else:
+            logger.debug(f'MySQL handler: unknown type code {col[7]}, use TEXT as fallback.')
+            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+        # endregion
+
+    # region cast int and bool to nullable types
+    serieses = []
+    for i, mysql_type in enumerate(mysql_types):
+        expected_dtype = None
+        column_name = description[i][0]
+        if mysql_type in (
+            MYSQL_DATA_TYPE.SMALLINT, MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.BIGINT, MYSQL_DATA_TYPE.TINYINT
+        ):
+            expected_dtype = 'Int64'
+        elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+            expected_dtype = 'boolean'
+        serieses.append(pd.Series([row[column_name] for row in result], dtype=expected_dtype, name=description[i][0]))
+    df = pd.concat(serieses, axis=1, copy=False)
+    # endregion
+
+    response = Response(
+        RESPONSE_TYPE.TABLE,
+        df,
+        affected_rows=cursor.rowcount,
+        mysql_types=mysql_types
+    )
+    return response
+
+
 class MySQLHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the MySQL statements.
     """
 
-    name = 'mysql'
+    name = "mysql"
 
     def __init__(self, name, **kwargs):
         super().__init__(name)
         self.parser = parse_sql
-        self.dialect = 'mysql'
-        self.connection_data = kwargs.get('connection_data', {})
-        self.database = self.connection_data.get('database')
+        self.dialect = "mysql"
+        self.connection_data = kwargs.get("connection_data", {})
+        self.database = self.connection_data.get("database")
 
         self.connection = None
 
@@ -91,28 +164,28 @@ class MySQLHandler(DatabaseHandler):
         if self.is_connected and self.connection.is_connected():
             return self.connection
         config = self._unpack_config()
-        if 'conn_attrs' in self.connection_data:
-            config['conn_attrs'] = self.connection_data['conn_attrs']
+        if "conn_attrs" in self.connection_data:
+            config["conn_attrs"] = self.connection_data["conn_attrs"]
 
-        if 'connection_timeout' not in config:
-            config['connection_timeout'] = 10
+        if "connection_timeout" not in config:
+            config["connection_timeout"] = 10
 
-        ssl = self.connection_data.get('ssl')
+        ssl = self.connection_data.get("ssl")
         if ssl is True:
-            ssl_ca = self.connection_data.get('ssl_ca')
-            ssl_cert = self.connection_data.get('ssl_cert')
-            ssl_key = self.connection_data.get('ssl_key')
-            config['client_flags'] = [mysql.connector.constants.ClientFlag.SSL]
+            ssl_ca = self.connection_data.get("ssl_ca")
+            ssl_cert = self.connection_data.get("ssl_cert")
+            ssl_key = self.connection_data.get("ssl_key")
+            config["client_flags"] = [mysql.connector.constants.ClientFlag.SSL]
             if ssl_ca is not None:
                 config["ssl_ca"] = ssl_ca
             if ssl_cert is not None:
                 config["ssl_cert"] = ssl_cert
             if ssl_key is not None:
                 config["ssl_key"] = ssl_key
-        if 'collation' not in config:
-            config['collation'] = 'utf8mb4_general_ci'
-        if 'use_pure' not in config:
-            config['use_pure'] = True
+        if "collation" not in config:
+            config["collation"] = "utf8mb4_general_ci"
+        if "use_pure" not in config:
+            config["use_pure"] = True
         try:
             connection = mysql.connector.connect(**config)
             connection.autocommit = True
@@ -146,7 +219,9 @@ class MySQLHandler(DatabaseHandler):
             connection = self.connect()
             result.success = connection.is_connected()
         except mysql.connector.Error as e:
-            logger.error(f'Error connecting to MySQL {self.connection_data["database"]}, {e}!')
+            logger.error(
+                f'Error connecting to MySQL {self.connection_data["database"]}, {e}!'
+            )
             result.error_message = str(e)
 
         if result.success and need_to_close:
@@ -173,22 +248,14 @@ class MySQLHandler(DatabaseHandler):
                 cur.execute(query)
                 if cur.with_rows:
                     result = cur.fetchall()
-                    response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        pd.DataFrame(
-                            result,
-                            columns=[x[0] for x in cur.description]
-                        ),
-                        affected_rows=cur.rowcount
-                    )
+                    response = _make_table_response(result, cur)
                 else:
                     response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
         except mysql.connector.Error as e:
-            logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
+            logger.error(
+                f'Error running query: {query} on {self.connection_data["database"]}!'
             )
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
             if connection is not None and connection.is_connected():
                 connection.rollback()
 
@@ -201,7 +268,7 @@ class MySQLHandler(DatabaseHandler):
         """
         Retrieve the data from the SQL statement.
         """
-        renderer = SqlalchemyRender('mysql')
+        renderer = SqlalchemyRender("mysql")
         query_str = renderer.get_string(query, with_failback=True)
         return self.native_query(query_str)
 

mindsdb/integrations/handlers/mysql_handler/settings.py

@@ -14,29 +14,31 @@ class ConnectionConfig(BaseModel):
     @model_validator(mode="before")
     def check_db_params(cls, values):
         """Ensures either URL is provided or all individual parameters are provided."""
-        url = values.get('url')
-        host = values.get('host')
-        user = values.get('user')
-        password = values.get('password')
-        database = values.get('database')
+        url = values.get("url")
+        host = values.get("host")
+        user = values.get("user")
+        password = values.get("password")
+        database = values.get("database")
         if not url and not (host and user and password and database):
-            raise ValueError("Either a valid URL or required parameters (host, user, password, database) must be provided.")
+            raise ValueError(
+                "Either a valid URL or required parameters (host, user, password, database) must be provided."
+            )
 
         if url:
             parsed = urlparse(url)
-            values['host'] = parsed.hostname or host
-            values['port'] = parsed.port if parsed.port is not None else 3306
-            values['user'] = parsed.username or user
-            values['password'] = parsed.password or password
-            values['database'] = parsed.path[1:] if parsed.path else database
+            values["host"] = parsed.hostname or host
+            values["port"] = parsed.port if parsed.port is not None else 3306
+            values["user"] = parsed.username or user
+            values["password"] = parsed.password or password
+            values["database"] = parsed.path[1:] if parsed.path else database
 
             # mysql connector raise error if url is provided
-            values.pop('url', None)
+            values.pop("url", None)
 
             return values
 
         if not url:
-            for param in ['host', 'user', 'password', 'database']:
+            for param in ["host", "user", "password", "database"]:
                 if not values.get(param):
                     raise ValueError(f"{param} is required when URL is not provided.")
         return values

mindsdb/integrations/handlers/neuralforecast_handler/neuralforecast_handler.py

@@ -41,7 +41,7 @@ class NeuralForecastHandler(BaseMLEngine):
         time_settings = args["timeseries_settings"]
         using_args = args["using"]
         assert time_settings["is_timeseries"], "Specify time series settings in your query"
-        ###### store model args and time series settings in the model folder
+        # store model args and time series settings in the model folder
         model_args = {}
         model_args["target"] = target
         model_args["horizon"] = time_settings["horizon"]

mindsdb/integrations/handlers/newsapi_handler/newsapi_handler.py

@@ -194,7 +194,7 @@ class NewsAPIHandler(APIHandler):
             try:
                 result = self.api.get_everything(**params)
             except Exception as e:
-                raise RuntimeError(f"API call failed: {e}") 
+                raise RuntimeError(f"API call failed: {e}")
             articles = result["articles"]
             for article in articles:
                 article["source_id"] = article["source"]["id"]

mindsdb/integrations/handlers/newsapi_handler/tests/test_newsapi_handler.py

@@ -28,12 +28,12 @@ class NewsApiHandlerTest(unittest.TestCase):
     def test_3_select(self):
         # table = self.handler.get_table("article")
         with self.assertRaises(NewsAPIException):
-            res = self.handler.native_query("SELECT * FROM article")
+            self.handler.native_query("SELECT * FROM article")
 
     def test_4_select(self):
         # table = self.handler.get_table("article")
         with self.assertRaises(NewsAPIException):
-            res = self.handler.native_query(
+            self.handler.native_query(
                 'SELECT * FROM article WHERE query="google" AND sources="google.com"'
             )
 
@@ -46,7 +46,7 @@ class NewsApiHandlerTest(unittest.TestCase):
 
     def test_6_select(self):
         # table = self.handler.get_table("article")
-        res = self.handler.native_query(
+        self.handler.native_query(
             'SELECT * FROM article WHERE query="google" AND publishedAt >= "2023-03-23" AND  publishedAt <= "2023-04-23"'
         )
 
@@ -74,7 +74,7 @@ class NewsApiHandlerTest(unittest.TestCase):
     def test_10_select(self):
         # table = self.handler.get_table("article")
         with self.assertRaises(NotImplementedError):
-            res = self.handler.native_query(
+            self.handler.native_query(
                 'SELECT * FROM article WHERE query="google" ORDER BY query'
             )
 

mindsdb/integrations/handlers/nuo_jdbc_handler/connection_args.py

@@ -44,8 +44,8 @@ connection_args = OrderedDict(
     driver_args={
         'type': ARG_TYPE.STR,
         'description': """
-            The extra arguments which can be specified to the driver. 
-            Specify this in the format: "arg1=value1,arg2=value2. 
+            The extra arguments which can be specified to the driver.
+            Specify this in the format: "arg1=value1,arg2=value2.
             More information on the supported paramters can be found at: https://doc.nuodb.com/nuodb/latest/deployment-models/physical-or-vmware-environments-with-nuodb-admin/reference-information/connection-properties/'
         """
     }

mindsdb/integrations/handlers/nuo_jdbc_handler/nuo_jdbc_handler.py

@@ -13,11 +13,10 @@ import jaydebeapi as jdbcconnector
 
 logger = log.getLogger(__name__)
 
-class NuoHandler(DatabaseHandler):
-
 
-    name= 'nuo_jdbc'
+class NuoHandler(DatabaseHandler):
 
+    name = 'nuo_jdbc'
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
         """ Initialize the handler
@@ -27,7 +26,7 @@ class NuoHandler(DatabaseHandler):
             **kwargs: arbitrary keyword arguments.
         """
         super().__init__(name)
-        
+
         self.kwargs = kwargs
         self.parser = parse_sql
         self.database = connection_data['database']
@@ -42,7 +41,7 @@ class NuoHandler(DatabaseHandler):
         self.schema = None
 
         self.jdbc_url = self.construct_jdbc_url()
-    
+
     def connect(self):
         """ Set up any connections required by the handler
         Should return output of check_connection() method after attempting
@@ -56,10 +55,10 @@ class NuoHandler(DatabaseHandler):
         jdbc_class = "com.nuodb.jdbc.Driver"
         jar_location = self.connection_config.get('jar_location')
 
-        try: 
-            if(jar_location): 
+        try:
+            if (jar_location):
                 self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=self.jdbc_url, jars=jar_location)
-            else: 
+            else:
                 self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=self.jdbc_url)
         except Exception as e:
             logger.error(f"Error while connecting to {self.database}, {e}")
@@ -68,40 +67,38 @@ class NuoHandler(DatabaseHandler):
 
     def construct_jdbc_url(self):
         """ Constructs the JDBC url based on the paramters provided to the handler class.\
-        Returns: 
-            The JDBC connection url string. 
+        Returns:
+            The JDBC connection url string.
         """
 
         jdbc_url = "jdbc:com.nuodb://" + self.host
 
-        #port is an optional paramter, if found then append
+        # port is an optional paramter, if found then append
         port = self.connection_config.get('port')
-        if port: 
+        if port:
             jdbc_url = jdbc_url + ":" + str(port)
-        
-        jdbc_url = jdbc_url + "/" + self.database + "?user=" + self.user + "&password=" + self.password 
 
-        #check if a schema is provided in the connection args, if provided use the schema to establish connection
+        jdbc_url = jdbc_url + "/" + self.database + "?user=" + self.user + "&password=" + self.password
+
+        # check if a schema is provided in the connection args, if provided use the schema to establish connection
         schema = self.connection_config.get('schema')
-        if schema: 
+        if schema:
             self.schema = schema
             jdbc_url = jdbc_url + "&schema=" + schema
 
-        #sets direct paramter only if the paramters is specified to be true
-        if(str(self.is_direct).lower() == 'true'): 
+        # sets direct paramter only if the paramters is specified to be true
+        if (str(self.is_direct).lower() == 'true'):
             jdbc_url = jdbc_url + "&direct=true"
 
-        
         driver_args = self.connection_config.get('driver_args')
 
-        #if driver args are present then construct them in the form: &query=one#qquerytwo=true
-        #finally append these to the url
-        if(driver_args): 
+        # if driver args are present then construct them in the form: &query=one#qquerytwo=true
+        # finally append these to the url
+        if (driver_args):
             driver_arg_string = '&'.join(driver_args.split(","))
-            jdbc_url = jdbc_url + "&" + driver_arg_string 
+            jdbc_url = jdbc_url + "&" + driver_arg_string
 
-        return jdbc_url 
-        
+        return jdbc_url
 
     def disconnect(self):
         """ Close any existing connections
@@ -111,12 +108,11 @@ class NuoHandler(DatabaseHandler):
             return
         try:
             self.connection.close()
-            self.is_connected=False
+            self.is_connected = False
         except Exception as e:
             logger.error(f"Error while disconnecting to {self.database}, {e}")
 
-        return 
-
+        return
 
     def check_connection(self) -> StatusResponse:
         """ Check connection to the handler
@@ -140,7 +136,6 @@ class NuoHandler(DatabaseHandler):
 
         return responseCode
 
-
     def native_query(self, query: str) -> StatusResponse:
         """Receive raw query and act upon it somehow.
         Args:
@@ -155,7 +150,7 @@ class NuoHandler(DatabaseHandler):
             try:
                 cur.execute(query)
                 if cur.description:
-                    result = cur.fetchall() 
+                    result = cur.fetchall()
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         data_frame=pd.DataFrame(
@@ -179,7 +174,6 @@ class NuoHandler(DatabaseHandler):
 
         return response
 
-    
     def query(self, query: ASTNode) -> StatusResponse:
         """Render and execute a SQL query.
 
@@ -196,24 +190,22 @@ class NuoHandler(DatabaseHandler):
 
         return self.native_query(query_str)
 
-
     def get_tables(self) -> StatusResponse:
         """Get a list of all the tables in the database.
 
         Returns:
             Response: Names of the tables in the database.
         """
-        if self.schema: 
+        if self.schema:
             query = f''' SELECT TABLENAME FROM SYSTEM.TABLES WHERE SCHEMA = '{self.schema}' '''
-        else: 
+        else:
             query = ''' SELECT TABLENAME FROM SYSTEM.TABLES WHERE SCHEMA != 'SYSTEM' '''
-    
+
         result = self.native_query(query)
         df = result.data_frame
         result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
         return result
 
-    
     def get_columns(self, table_name: str) -> StatusResponse:
         """Get details about a table.
 

mindsdb/integrations/handlers/nuo_jdbc_handler/tests/test_nuo_handler.py

@@ -2,6 +2,7 @@ import unittest
 from mindsdb.integrations.handlers.nuo_jdbc_handler.nuo_jdbc_handler import NuoHandler
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 
+
 class NuoHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -20,7 +21,7 @@ class NuoHandlerTest(unittest.TestCase):
 
     def test_0_connect(self):
         self.handler.connect()
-    
+
     def test_1_check_connection(self):
         self.handler.check_connection()
 
@@ -35,7 +36,7 @@ class NuoHandlerTest(unittest.TestCase):
     def test_4_select(self):
         res = self.handler.query('SELECT * FROM HOCKEY')
         assert res.type is RESPONSE_TYPE.TABLE
-    
+
     def test_5_get_tables(self):
         res = self.handler.get_tables()
         assert res.type is RESPONSE_TYPE.TABLE
@@ -43,8 +44,7 @@ class NuoHandlerTest(unittest.TestCase):
     def test_6_get_columns(self):
         res = self.handler.get_columns("HOCKEY")
         assert res.type is RESPONSE_TYPE.TABLE
-    
 
-        
+
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

mindsdb/integrations/handlers/oceanbase_handler/oceanbase_handler.py

@@ -15,7 +15,6 @@ class OceanBaseHandler(MysqlHandler):
         super().__init__(name, **kwargs)
 
 
-
 connection_args = OrderedDict(
     user={
         'type': ARG_TYPE.STR,

mindsdb/integrations/handlers/oceanbase_handler/tests/test_oceanbase_handler.py

@@ -2,6 +2,7 @@ import unittest
 from mindsdb.integrations.handlers.oceanbase_handler.oceanbase_handler import OceanBaseHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
+
 class OceanBaseHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -21,36 +22,33 @@ class OceanBaseHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table IF NOT EXISTS Lover(name varchar(101));"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert(self):
         query = "INSERT INTO LOVER VALUES('Shiv Shakti');"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_4_native_query_select(self):
         query = "SELECT * FROM LOVER;"
         result = self.handler.query(query)
-        assert result.type is RESPONSE_TYPE.TABLE 
+        assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is  RESPONSE_TYPE.TABLE
+        assert tables.type is RESPONSE_TYPE.TABLE
 
     def test_6_get_columns(self):
         columns = self.handler.get_columns('LOVER')
-        
+
         query = "DROP Table IF  EXISTS Lover;"
-        result = self.handler.query(query)
+        self.handler.query(query)
         assert columns.type is not RESPONSE_TYPE.ERROR
 
 
 if __name__ == '__main__':
     unittest.main()
-
-
-    

mindsdb/integrations/handlers/ollama_handler/ollama_handler.py

@@ -63,7 +63,7 @@ class OllamaHandler(BaseMLEngine):
             responses = _model_check()
             if 200 not in responses.values():
                 raise Exception(f"Ollama model `{args['model_name']}` is not working correctly. Please try pulling this model manually, check it works correctly and try again.")  # noqa
-        
+
         supported_modes = {k: True if v == 200 else False for k, v in responses.items()}
 
         # check if a mode has been provided and if it is valid
@@ -71,7 +71,7 @@ class OllamaHandler(BaseMLEngine):
         if 'mode' in args:
             if args['mode'] not in runnable_modes:
                 raise Exception(f"Mode `{args['mode']}` is not supported by the model `{args['model_name']}`.")
-        
+
         # if a mode has not been provided, check if the model supports only one mode
         # if it does, set it as the default mode
         # if it supports multiple modes, set the default mode to 'generate'
@@ -168,4 +168,4 @@ class OllamaHandler(BaseMLEngine):
                     'modelfile',
                     'parameters',
                     'ollama_base_template',
-                ])
+            ])

mindsdb/integrations/handlers/opengauss_handler/tests/test_opengauss_handler.py

@@ -1,5 +1,4 @@
 import unittest
-import pandas as pd
 from mindsdb.integrations.handlers.opengauss_handler.opengauss_handler import OpenGaussHandler
 
 
@@ -42,4 +41,4 @@ class OpenGaussHandlerTest(unittest.TestCase):
 
     def test_7_select_query(self):
         query = "SELECT * FROM dt_test WHERE 'id'='a'"
-        result = self.handler.native_query(query)
+        self.handler.native_query(query)

mindsdb/integrations/handlers/openstreetmap_handler/__init__.py

@@ -4,7 +4,7 @@ from .__about__ import __version__ as version, __description__ as description
 
 try:
     from .openstreetmap_handler import OpenStreetMapHandler as Handler
-    
+
     import_error = None
 except Exception as e:
     Handler = None
@@ -16,12 +16,12 @@ type = HANDLER_TYPE.DATA
 icon_path = "icon.svg"
 
 __all__ = [
-    "Handler", 
-    "version", 
-    "name", 
-    "type", 
-    "title", 
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
     "description",
-    "import_error", 
+    "import_error",
     "icon_path",
 ]

mindsdb/integrations/handlers/oracle_handler/connection_args.py

@@ -59,6 +59,12 @@ connection_args = OrderedDict(
         "required": False,
         "label": "Auth Mode",
     },
+    thick_mode={
+        "type": ARG_TYPE.BOOL,
+        "description": "Set to `true` to use thick mode for the connection. Thin mode is used by default.",
+        "required": False,
+        "label": "Connection mode",
+    }
 )
 
 connection_args_example = OrderedDict(