MindsDB 25.5.4.2__py3-none-any.whl → 25.6.2.0__py3-none-any.whl

mindsdb/integrations/handlers/oracle_handler/oracle_handler.py

@@ -21,8 +21,8 @@ logger = log.getLogger(__name__)
 
 
 def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
-    """ Map Oracle types to MySQL types.
-        List of types: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+    """Map Oracle types to MySQL types.
+        List of types: https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/Data-Types.html
 
     Args:
         internal_type_name (str): The name of the Oracle type to map.
@@ -33,21 +33,33 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
     internal_type_name = internal_type_name.upper()
     types_map = {
         (
-            'VARCHAR2', 'NVARCHAR2', 'CHARACTER VARYING', 'CHAR VARYING', 'NATIONAL CHARACTER', 'NATIONAL CHAR',
-            'VARCHAR', 'NCHAR', 'NATIONAL CHARACTER VARYING', 'NATIONAL CHAR VARYING', 'NCHAR VARYING', 'LONG VARCHAR'
+            "VARCHAR2",
+            "NVARCHAR2",
+            "CHARACTER VARYING",
+            "CHAR VARYING",
+            "NATIONAL CHARACTER",
+            "NATIONAL CHAR",
+            "VARCHAR",
+            "NCHAR",
+            "NATIONAL CHARACTER VARYING",
+            "NATIONAL CHAR VARYING",
+            "NCHAR VARYING",
+            "LONG VARCHAR",
         ): MYSQL_DATA_TYPE.VARCHAR,
-        ('INTEGER', 'INT'): MYSQL_DATA_TYPE.INT,
-        ('SMALLINT',): MYSQL_DATA_TYPE.SMALLINT,
-        ('NUMBER', 'DECIMAL'): MYSQL_DATA_TYPE.DECIMAL,
-        ('FLOAT', 'BINARY_FLOAT', 'REAL'): MYSQL_DATA_TYPE.FLOAT,
-        ('BINARY_DOUBLE',): MYSQL_DATA_TYPE.DOUBLE,
-        ('LONG',): MYSQL_DATA_TYPE.BIGINT,
-        ('DATE',): MYSQL_DATA_TYPE.DATE,
-        ('HOUR', 'MINUTE', 'SECOND', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE'): MYSQL_DATA_TYPE.SMALLINT,
-        ('TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE'): MYSQL_DATA_TYPE.TIMESTAMP,
-        ('RAW', 'LONG RAW', 'BLOB', 'BFILE'): MYSQL_DATA_TYPE.BINARY,
-        ('ROWID', 'UROWID'): MYSQL_DATA_TYPE.TEXT,
-        ('CHAR', 'NCHAR', 'CLOB', 'NCLOB', 'CHARACTER'): MYSQL_DATA_TYPE.CHAR,
+        ("INTEGER", "INT"): MYSQL_DATA_TYPE.INT,
+        ("SMALLINT",): MYSQL_DATA_TYPE.SMALLINT,
+        ("NUMBER", "DECIMAL"): MYSQL_DATA_TYPE.DECIMAL,
+        ("FLOAT", "BINARY_FLOAT", "REAL"): MYSQL_DATA_TYPE.FLOAT,
+        ("BINARY_DOUBLE",): MYSQL_DATA_TYPE.DOUBLE,
+        ("LONG",): MYSQL_DATA_TYPE.BIGINT,
+        ("DATE",): MYSQL_DATA_TYPE.DATE,
+        ("HOUR", "MINUTE", "SECOND", "TIMEZONE_HOUR", "TIMEZONE_MINUTE"): MYSQL_DATA_TYPE.SMALLINT,
+        ("TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"): MYSQL_DATA_TYPE.TIMESTAMP,
+        ("RAW", "LONG RAW", "BLOB", "BFILE"): MYSQL_DATA_TYPE.BINARY,
+        ("ROWID", "UROWID"): MYSQL_DATA_TYPE.TEXT,
+        ("CHAR", "NCHAR", "CLOB", "NCLOB", "CHARACTER"): MYSQL_DATA_TYPE.CHAR,
+        ("VECTOR",): MYSQL_DATA_TYPE.VECTOR,
+        ("JSON",): MYSQL_DATA_TYPE.JSON,
     }
 
     for db_types_list, mysql_data_type in types_map.items():
@@ -74,7 +86,11 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
         db_type = column[1]
         precision = column[4]
         scale = column[5]
-        if db_type is oracledb.DB_TYPE_NUMBER:
+        if db_type is oracledb.DB_TYPE_JSON:
+            mysql_types.append(MYSQL_DATA_TYPE.JSON)
+        elif db_type is oracledb.DB_TYPE_VECTOR:
+            mysql_types.append(MYSQL_DATA_TYPE.VECTOR)
+        elif db_type is oracledb.DB_TYPE_NUMBER:
             if scale != 0:
                 mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
             else:
@@ -92,8 +108,12 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
         elif db_type is oracledb.DB_TYPE_BOOLEAN:
             mysql_types.append(MYSQL_DATA_TYPE.BOOLEAN)
         elif db_type in (
-            oracledb.DB_TYPE_CHAR, oracledb.DB_TYPE_NCHAR, oracledb.DB_TYPE_LONG,
-            oracledb.DB_TYPE_NVARCHAR, oracledb.DB_TYPE_VARCHAR, oracledb.DB_TYPE_LONG_NVARCHAR,
+            oracledb.DB_TYPE_CHAR,
+            oracledb.DB_TYPE_NCHAR,
+            oracledb.DB_TYPE_LONG,
+            oracledb.DB_TYPE_NVARCHAR,
+            oracledb.DB_TYPE_VARCHAR,
+            oracledb.DB_TYPE_LONG_NVARCHAR,
         ):
             mysql_types.append(MYSQL_DATA_TYPE.TEXT)
         elif db_type in (oracledb.DB_TYPE_RAW, oracledb.DB_TYPE_LONG_RAW):
@@ -111,21 +131,20 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
     for i, mysql_type in enumerate(mysql_types):
         expected_dtype = None
         if mysql_type in (
-            MYSQL_DATA_TYPE.SMALLINT, MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.MEDIUMINT,
-            MYSQL_DATA_TYPE.BIGINT, MYSQL_DATA_TYPE.TINYINT
+            MYSQL_DATA_TYPE.SMALLINT,
+            MYSQL_DATA_TYPE.INT,
+            MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.BIGINT,
+            MYSQL_DATA_TYPE.TINYINT,
         ):
-            expected_dtype = 'Int64'
+            expected_dtype = "Int64"
         elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
-            expected_dtype = 'boolean'
+            expected_dtype = "boolean"
         serieses.append(pd.Series([row[i] for row in result], dtype=expected_dtype, name=description[i][0]))
     df = pd.concat(serieses, axis=1, copy=False)
     # endregion
 
-    return Response(
-        RESPONSE_TYPE.TABLE,
-        data_frame=df,
-        mysql_types=mysql_types
-    )
+    return Response(RESPONSE_TYPE.TABLE, data_frame=df, mysql_types=mysql_types)
 
 
 class OracleHandler(DatabaseHandler):
@@ -165,59 +184,63 @@ class OracleHandler(DatabaseHandler):
             return self.connection
 
         # Mandatory connection parameters.
-        if not all(key in self.connection_data for key in ['user', 'password']):
-            raise ValueError('Required parameters (user, password) must be provided.')
+        if not all(key in self.connection_data for key in ["user", "password"]):
+            raise ValueError("Required parameters (user, password) must be provided.")
 
-        if self.connection_data.get('thick_mode', False):
+        if self.connection_data.get("thick_mode", False):
             oracledb.init_oracle_client()
 
         config = {
-            'user': self.connection_data['user'],
-            'password': self.connection_data['password'],
+            "user": self.connection_data["user"],
+            "password": self.connection_data["password"],
         }
 
         # If 'dsn' is given, use it. Otherwise, use the individual connection parameters.
-        if 'dsn' in self.connection_data:
-            config['dsn'] = self.connection_data['dsn']
+        if "dsn" in self.connection_data:
+            config["dsn"] = self.connection_data["dsn"]
 
         else:
-            if 'host' not in self.connection_data and not any(key in self.connection_data for key in ['sid', 'service_name']):
-                raise ValueError('Required parameter host and either sid or service_name must be provided. Alternatively, dsn can be provided.')
+            if "host" not in self.connection_data and not any(
+                key in self.connection_data for key in ["sid", "service_name"]
+            ):
+                raise ValueError(
+                    "Required parameter host and either sid or service_name must be provided. Alternatively, dsn can be provided."
+                )
 
-            config['host'] = self.connection_data.get('host')
+            config["host"] = self.connection_data.get("host")
 
             # Optional connection parameters when 'dsn' is not given.
-            optional_parameters = ['port', 'sid', 'service_name']
+            optional_parameters = ["port", "sid", "service_name"]
             for parameter in optional_parameters:
                 if parameter in self.connection_data:
                     config[parameter] = self.connection_data[parameter]
 
         # Other optional connection parameters.
-        if 'disable_oob' in self.connection_data:
-            config['disable_oob'] = self.connection_data['disable_oob']
+        if "disable_oob" in self.connection_data:
+            config["disable_oob"] = self.connection_data["disable_oob"]
 
-        if 'auth_mode' in self.connection_data:
-            mode_name = 'AUTH_MODE_' + self.connection_data['auth_mode'].upper()
+        if "auth_mode" in self.connection_data:
+            mode_name = "AUTH_MODE_" + self.connection_data["auth_mode"].upper()
             if not hasattr(oracledb, mode_name):
-                raise ValueError(f'Unknown auth mode: {mode_name}')
-            config['mode'] = getattr(oracledb, mode_name)
+                raise ValueError(f"Unknown auth mode: {mode_name}")
+            config["mode"] = getattr(oracledb, mode_name)
 
         try:
             connection = connect(
                 **config,
             )
 
-            if 'session_variables' in self.connection_data:
+            if "session_variables" in self.connection_data:
                 with connection.cursor() as cur:
-                    for key, value in self.connection_data['session_variables'].items():
+                    for key, value in self.connection_data["session_variables"].items():
                         cur.execute(f"ALTER SESSION SET {key} = {repr(value)}")
 
         except DatabaseError as database_error:
-            logger.error(f'Error connecting to Oracle, {database_error}!')
+            logger.error(f"Error connecting to Oracle, {database_error}!")
             raise
 
         except Exception as unknown_error:
-            logger.error(f'Unknown error when connecting to Elasticsearch: {unknown_error}')
+            logger.error(f"Unknown error when connecting to Elasticsearch: {unknown_error}")
             raise
 
         self.is_connected = True
@@ -248,10 +271,10 @@ class OracleHandler(DatabaseHandler):
             con.ping()
             response.success = True
         except (ValueError, DatabaseError) as known_error:
-            logger.error(f'Connection check to Oracle failed, {known_error}!')
+            logger.error(f"Connection check to Oracle failed, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Connection check to Oracle failed due to an unknown error, {unknown_error}!')
+            logger.error(f"Connection check to Oracle failed due to an unknown error, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success and need_to_close: