icsDataValidation 1.0.371__py3-none-any.whl → 1.0.415__py3-none-any.whl

icsDataValidation/services/database_services/exasol_service.py

@@ -1,5 +1,5 @@
 import pyexasol as px
-from typing import Union, List, Dict 
+from typing import Union, List, Dict
 import pandas as pd
 
 from icsDataValidation.core.database_objects import DatabaseObject
@@ -32,7 +32,7 @@ class ExasolService(object):
     #    """
     #    Compose error message if the execution of a statement or query fails.
     #    """
-    #    return 
+    #    return
 
     def get_database_objects(self, database: str, schema: str=None, object_type_restriction: str='include_all') -> dict:
         if self.exasol_connection is None:
@@ -44,7 +44,7 @@ class ExasolService(object):
         if object_type_restriction=='include_all' or object_type_restriction=='include_only_tables':
             if schema:
                 query_db_tables=f"select * from EXA_ALL_OBJECTS where root_name='{object.schema}' and object_type='TABLE';"
-            else:    
+            else:
                 query_db_tables=f"select * from EXA_ALL_OBJECTS where object_type='TABLE';"
 
             all_database_tables = self.execute_queries(query_db_tables)
@@ -53,11 +53,11 @@ class ExasolService(object):
         elif object_type_restriction=='include_all' or object_type_restriction=='include_only_views':
             if schema:
                 query_db_views=f"select * from EXA_ALL_OBJECTS where root_name='{object.schema}' and object_type='VIEW';"
-            else:    
+            else:
                 query_db_views=f"select * from EXA_ALL_OBJECTS where object_type='VIEW';"
 
             all_database_views = self.execute_queries(query_db_views)
-        
+
         database_objects=[]
         for row in all_database_tables:
             table_identifier=f'{database.upper()}.{row["ROOT_NAME"]}.{row["OBJECT_NAME"]}'
@@ -66,7 +66,7 @@ class ExasolService(object):
             view_identifier=f'{database.upper()}.{row["ROOT_NAME"]}.{row["OBJECT_NAME"]}'
             database_objects.append({"object_identifier": view_identifier, "object_type": "view"})
         return database_objects
-        
+
 
     def get_columns_from_object(self, object: DatabaseObject) -> list:
 
@@ -90,7 +90,7 @@ class ExasolService(object):
 
         if self.exasol_connection is None:
             self._connect_to_exasol()
-        
+
         query_get_row_count = f"select count(*) as ROW_COUNT from {object.schema}.{object.name} {where_clause};"
 
         row_count = self.execute_queries(query_get_row_count).fetchall()[0]["ROW_COUNT"]
@@ -107,7 +107,8 @@ class ExasolService(object):
         dict_colummns_datatype=self.execute_queries(query_get_data_types_from_table).fetchall()
         return dict_colummns_datatype
 
-    def get_count_distincts_from_object(self, object: DatabaseObject, column_intersections: list, where_clause: str="") -> dict:
+    def get_count_distincts_from_object(self, object: DatabaseObject, column_intersections: list, where_clause: str="",
+        enclose_column_by_double_quotes: bool = False) -> dict:
 
         if self.exasol_connection is None:
             self._connect_to_exasol()
@@ -115,12 +116,13 @@ class ExasolService(object):
         unions=""
         for column in column_intersections:
             unions +=f"UNION SELECT '{column}' AS COLUMN_NAME, COUNT(DISTINCT {column}) AS COUNT_DISTINCT FROM {object.schema}.{object.name} {where_clause}"
-        
+
         query_get_count_distincts_from_object=f"{unions[5:]} ORDER BY COUNT_DISTINCT;"
         dict_count_distincts=self.execute_queries(query_get_count_distincts_from_object).fetchall()
         return dict_count_distincts
 
-    def create_checksums(self, object : DatabaseObject, column_intersections: list, where_clause: str="") -> List[Dict]:
+    def create_checksums(self, object : DatabaseObject, column_intersections: list, where_clause: str="",
+            enclose_column_by_double_quotes: bool = False) -> List[Dict]:
 
         if self.exasol_connection is None:
             self._connect_to_exasol()
@@ -139,7 +141,7 @@ class ExasolService(object):
             count_nulls += f", sum(case when {column} is null then 1 else 0 end) countnulls_{column}"
 
             if column_datatype.lower() == 'decimal' or column_datatype.lower() == 'double':
-            
+
                 aggregates += f", sum({column}) as sum_{column}"
 
             elif column_datatype.lower() == 'char' or column_datatype.lower() == 'varchar' or column_datatype.lower() == 'date' or column_datatype.lower() == 'timestamp':
@@ -175,12 +177,12 @@ class ExasolService(object):
                 agg_result = 0
             else:
                 agg_result = aggregation_results[i]
-            
+
             if countnulls_results[i] is None:
                 cnt_result = 0
             else:
                 cnt_result = countnulls_results[i]
-            
+
             test_list.append([[item.split("_", 1)[0] for item in aggregation_columns][i],agg_result,cnt_result])
 
         checksums = dict(zip([item.split("_", 1)[1] for item in aggregation_columns] , test_list))
@@ -188,14 +190,15 @@ class ExasolService(object):
         return checksums
 
 
-    def create_pandas_df_from_group_by(self, object : DatabaseObject, object_type: str, column_intersections: list, group_by_column: str, where_clause: str="") -> List[Dict]:
+    def create_pandas_df_from_group_by(self, object : DatabaseObject, object_type: str, column_intersections: list, group_by_column: str, where_clause: str="",
+        enclose_column_by_double_quotes: bool = False) -> List[Dict]:
 
         if self.teradata_connection is None:
             self._connect_to_teradata()
 
         aggregation_columns= [f"{column.upper()}" for column in column_intersections if column != group_by_column]
 
-        dict_colummns_datatype=self.get_data_types_from_object(object, aggregation_columns)      
+        dict_colummns_datatype=self.get_data_types_from_object(object, aggregation_columns)
 
         aggregates = ""
 
@@ -204,7 +207,7 @@ class ExasolService(object):
             column_datatype = column_datatype.split('(')[0]
 
             if column_datatype.lower() == 'decimal' or column_datatype.lower() == 'double':
-            
+
                 aggregates += f", sum({column}) as sum_{column}"
 
             elif column_datatype.lower() == 'char' or column_datatype.lower() == 'varchar' or column_datatype.lower() == 'date' or column_datatype.lower() == 'timestamp':
@@ -222,16 +225,17 @@ class ExasolService(object):
         group_by_aggregation_pdf = self.execute_queries(query_group_by_aggregation,True)
 
         return group_by_aggregation_pdf
-    
 
-    def create_pandas_df(self, object:DatabaseObject, intersection_columns_trgt_src: list, where_clause:str="", exclude_columns:list=[]) -> pd.DataFrame:
+
+    def create_pandas_df(self, object:DatabaseObject, intersection_columns_trgt_src: list, where_clause:str="", exclude_columns:list=[],
+        enclose_column_by_double_quotes: bool = False) -> pd.DataFrame:
         if self.exasol_connection is None:
             self._connect_to_exasol()
-        
+
         intersection_columns_trgt_src_ = ', '.join(list(set(intersection_columns_trgt_src) - set(exclude_columns)))
 
         df_query = f"select {intersection_columns_trgt_src_} from {object.schema}.{object.name} {where_clause};"
-            
+
         pdf = self.execute_queries(df_query,True)
 
         return pdf
@@ -240,7 +244,7 @@ class ExasolService(object):
     def execute_queries(self, query: Union[str, List[str]],return_as_pdf:bool=False)  -> Union[List[Dict], List[List[Dict]]]:
         if self.exasol_connection is None:
             self._connect_to_exasol()
-        
+
         query_list: List[str] = query if isinstance(query, list) else [query]
 
         results = []
@@ -251,11 +255,10 @@ class ExasolService(object):
                     query_result=self.exasol_connection.export_to_pandas(single_query)
                 else:
                     query_result=self.exasol_connection.execute(single_query)
-                
+
                 results.append(query_result)
 
         except Exception as err:
             raise Exception() from err
 
         return results[0] if not isinstance(query, list) else results
-

icsDataValidation/services/database_services/oracle_service.py

@@ -4,7 +4,7 @@ oracledb.defaults.fetch_decimals = True
 import pandas as pd
 import logging
 
-from typing import Union, List, Dict 
+from typing import Union, List, Dict
 
 from icsDataValidation.utils.logger_util import configure_dev_ops_logger
 from icsDataValidation.core.database_objects import DatabaseObject
@@ -52,8 +52,8 @@ class OracleService(object):
     #        self.oracle_connection.close()
 
     def _connect_to_oracle(self):
-        # self.oracle_connection = oracledb.connect(**self.connection_params, mode=oracledb.SYSDBA) 
-        self.oracle_connection = oracledb.connect(**self.connection_params) 
+        # self.oracle_connection = oracledb.connect(**self.connection_params, mode=oracledb.SYSDBA)
+        self.oracle_connection = oracledb.connect(**self.connection_params)
         return self.oracle_connection
 
     @staticmethod
@@ -72,7 +72,8 @@ class OracleService(object):
         return f"Oracle ERROR: {message}\nFailed statement:\n{statement}"
 
     @staticmethod
-    def _get_in_clause(key_filters:list, numeric_columns:list, numeric_scale:int) -> str:
+    def _get_in_clause(key_filters:list, numeric_columns:list, numeric_scale:int,
+        enclose_column_by_double_quotes: bool = False) -> str:
         """ generates in_clause from list ready to expand the where clause, numeric values are rounded
 
         Args:
@@ -82,8 +83,8 @@ class OracleService(object):
 
         Returns:
             str: in clause as string
-        """        
-        values = list(key_filters.values())  
+        """
+        values = list(key_filters.values())
         in_clause_values = "('"
         for j in range(len(values[0])):
             for value in values:
@@ -91,17 +92,18 @@ class OracleService(object):
             in_clause_values = in_clause_values[:-2] + "),('"
         in_clause_values = in_clause_values[:-3] + ')'
 
-        in_clause_cols = f" AND ((" 
+        in_clause_cols = f" AND (("
         for key in key_filters.keys():
             if key in numeric_columns:
-                in_clause_cols += f"""ROUND({key.replace("'", "")},2)""" + ","
+                in_clause_cols += f"""ROUND({key.replace("'", "")}, {numeric_scale})""" + ","
             else:
                 in_clause_cols += key.replace("'", "") + ","
         in_clause_cols = in_clause_cols[:-1] + ")"
-        in_clause = in_clause_cols + " in ("  + in_clause_values + ")"                                  
+        in_clause = in_clause_cols + " in ("  + in_clause_values + ")"
         return in_clause
-    
-    def _get_column_clause(self, column_list: list, columns_datatype: list,  numeric_scale, key_columns) ->dict : 
+
+    def _get_column_clause(self, column_list: list, columns_datatype: list,  numeric_scale, key_columns,
+        enclose_column_by_double_quotes: bool = False) ->dict :
         """
         Turns list of desired columns into a sql compatible string.
         Columns with a date or time data type are omitted.
@@ -114,8 +116,8 @@ class OracleService(object):
 
         Returns:
             dict: _description_
-        """        
-        column_intersecions_new = []           
+        """
+        column_intersecions_new = []
         used_columns = []
         numeric_columns = []
         for column in column_list:
@@ -150,7 +152,7 @@ class OracleService(object):
         if object_type_restriction=='include_all' or object_type_restriction=='include_only_tables':
             if schema:
                 query_db_tables=f"SELECT * FROM all_tables WHERE OWNER = '{schema.upper()}'"
-            else:    
+            else:
                 query_db_tables=f"SELECT * FROM all_tables "
 
             all_database_tables = self.execute_queries(query_db_tables)
@@ -159,11 +161,11 @@ class OracleService(object):
         if object_type_restriction=='include_all' or object_type_restriction=='include_only_views':
             if schema:
                 query_db_views=f"SELECT * FROM all_views WHERE OWNER = '{schema.upper()}'"
-            else:    
+            else:
                 query_db_views=f"SELECT * FROM all_views "
 
             all_database_views = self.execute_queries(query_db_views)
-        
+
 
         database_objects=[]
         for row in all_database_tables:
@@ -190,7 +192,7 @@ class OracleService(object):
             self._connect_to_oracle()
 
         self.execute_statement("ALTER SESSION SET TIMEZONE = 'Europe/London'")
-        
+
         query_get_last_altered=f"SELECT LAST_ALTERED FROM {object.database}.INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{object.name}' AND TABLE_SCHEMA = '{object.schema}'"
 
         last_altered = self.execute_queries(query_get_last_altered)[0]
@@ -208,7 +210,7 @@ class OracleService(object):
         """
         if self.oracle_connection is None:
             self._connect_to_oracle()
-       
+
         query_get_columns = f"SELECT COLUMN_NAME FROM SYS.ALL_TAB_COLUMNS  WHERE OWNER = '{object.schema}' AND TABLE_NAME = '{object.name}'"
 
         all_columns = self.execute_queries(query_get_columns)
@@ -232,14 +234,14 @@ class OracleService(object):
 
         if self.oracle_connection is None:
             self._connect_to_oracle()
-        
+
         query_get_row_count = f"SELECT COUNT(*) AS ROW_COUNT FROM {object.schema}.{object.name} {where_clause}"
         row_count = -1
         error_list = []
 
         try:
             row_count = self.execute_queries(query_get_row_count)[0]["ROW_COUNT"]
-        
+
         except Exception as err:
             error_list.append(str(err))
             error_list.append(query_get_row_count)
@@ -247,7 +249,7 @@ class OracleService(object):
         return row_count, error_list
 
     def get_data_types_from_object(self, object: DatabaseObject, column_intersections: list) -> dict:
-        """ returns datatypes for all intersection columns in a database object 
+        """ returns datatypes for all intersection columns in a database object
 
         Args:
             object (DatabaseObject): table or view
@@ -274,7 +276,8 @@ class OracleService(object):
         dict_colummns_datatype=self.execute_queries(query_get_data_types_from_object)
         return dict_colummns_datatype
 
-    def get_count_distincts_from_object(self, object: DatabaseObject, column_intersections: list, where_clause: str="", exclude_columns: list=[]) -> dict:
+    def get_count_distincts_from_object(self, object: DatabaseObject, column_intersections: list, where_clause: str="", exclude_columns: list=[],
+        enclose_column_by_double_quotes: bool = False) -> dict:
         """get distinct count for every column in a database object that is in column intersections list
 
         Args:
@@ -301,17 +304,17 @@ class OracleService(object):
         error_list = []
         try:
             dict_count_distincts=self.execute_queries(query_get_count_distincts_from_object)
-        
+
         except Exception as err:
             #raise err
             dict_count_distincts = [{'COUNT_DISTINCT': 0}]
             error_list.append(["ERROR", str(err).split('|||')[0], str(err).split('|||')[1]])
 
-        
+
         return dict_count_distincts, error_list
 
     def get_table_size(self, object: DatabaseObject) -> int:
-        """ returns size of given object 
+        """ returns size of given object
 
         Args:
             object (DatabaseObject): table or view
@@ -334,7 +337,8 @@ class OracleService(object):
 
         return size
 
-    def create_checksums(self, object: DatabaseObject , column_intersections: list, where_clause: str="", exclude_columns:list=[], numeric_scale: int = None) -> List[Dict]:
+    def create_checksums(self, object: DatabaseObject , column_intersections: list, where_clause: str="", exclude_columns:list=[], numeric_scale: int = None,
+            enclose_column_by_double_quotes: bool = False) -> List[Dict]:
         """ creates checksums for given object in compliance with given conditions
 
         Args:
@@ -347,7 +351,7 @@ class OracleService(object):
         Returns:
             List[Dict]: checksums for columns of object
         """
-   
+
         if self.oracle_connection is None:
             self._connect_to_oracle()
 
@@ -362,7 +366,7 @@ class OracleService(object):
             column_datatype=next(x for x in dict_colummns_datatype if x["COLUMN_NAME"] == column)["DATA_TYPE"]
 
             count_nulls += f", SUM(CASE WHEN {column} IS NULL THEN 1 ELSE 0 END) AS COUNTNULLS_{column}"
-            
+
             if column_datatype.lower() in  self.oracle_datatype_mapping["numeric"]:
 
                 if numeric_scale:
@@ -373,7 +377,7 @@ class OracleService(object):
             elif 'char' in column_datatype.lower() or 'raw' in column_datatype.lower():
 
                 aggregates += f", COUNT(DISTINCT LOWER({column})) AS countdistinct_{column}"
-            
+
             elif column_datatype.lower() == 'date' or 'timestamp' in  column_datatype.lower() or 'interval' in  column_datatype.lower():
 
                 aggregates += f", COUNT(DISTINCT {column}) AS countdistinct_{column}"
@@ -395,12 +399,12 @@ class OracleService(object):
             countnulls_results=checksums_results[1][0]
 
             for i in range(0,len(aggregation_results)):
-                
+
                 if list(aggregation_results.values())[i] is None:
                     agg_result = 0
                 else:
                     agg_result = list(aggregation_results.values())[i]
-                
+
                 if list(countnulls_results.values())[i] is None:
                     cnt_result = 0
                 else:
@@ -414,7 +418,7 @@ class OracleService(object):
 
         checksums = dict(zip([item.split("_", 1)[1] for item in aggregation_results.keys()] , test_list))
         checksums['TESTATM_ERRORS'] = error_list
-        
+
         return checksums
 
     def create_pandas_df_from_group_by(
@@ -427,7 +431,8 @@ class OracleService(object):
         only_numeric: bool,
         where_clause: str,
         exclude_columns: list,
-        numeric_scale: int = None
+        numeric_scale: int = None,
+        enclose_column_by_double_quotes: bool = False
     ) -> List[Dict]:
         """execution of multiple aggregations at once
 
@@ -443,7 +448,7 @@ class OracleService(object):
             numeric_scale (int, optional): number of decimal places for aggregations. Defaults to None.
 
         Returns:
-            List[Dict]: list of pandas dataframes with results from aggregations, used sql queries 
+            List[Dict]: list of pandas dataframes with results from aggregations, used sql queries
         """
 
         if self.oracle_connection is None:
@@ -457,7 +462,7 @@ class OracleService(object):
         group_by_query_columns_string = " "
         grouping_columns_final = []
         error_dict = {}
-        
+
         try:
             for column in group_by_columns:
                 if column in column_intersections and column not in exclude_columns:
@@ -503,7 +508,7 @@ class OracleService(object):
             # CASE 3: sum, count_distinct, aggregate_boolean, min_max
             elif group_by_aggregation_type == "various_and_min_max":
                 group_by_query_aggregation_string = f"{aggregates_min[1:]}{aggregates}"
-        
+
             query_group_by_aggregation = f"SELECT {group_by_query_columns_string}, COUNT(*) AS COUNT_OF_GROUP_BY_VALUE, {group_by_query_aggregation_string} FROM {object.schema}.{object.name} {where_clause} GROUP BY {group_by_query_columns_string} ORDER BY {group_by_query_columns_string}"
 
             group_by_aggregation_pdf = self.execute_queries(query_group_by_aggregation,True)
@@ -530,7 +535,8 @@ class OracleService(object):
 
         return group_by_aggregation_pdf, group_by_query_aggregation_string, group_by_query_columns_string, grouping_columns_final, error_dict
 
-    def create_pandas_df(self, object: DatabaseObject, intersection_columns_trgt_src: list, where_clause:str="", exclude_columns:list=[]) -> pd.DataFrame:
+    def create_pandas_df(self, object: DatabaseObject, intersection_columns_trgt_src: list, where_clause:str="", exclude_columns:list=[],
+        enclose_column_by_double_quotes: bool = False) -> pd.DataFrame:
         """ creates pandas dataframes with all data from given object in given columns
 
         Args:
@@ -547,13 +553,13 @@ class OracleService(object):
         intersection_columns_trgt_src_ = ', '.join(list(set(intersection_columns_trgt_src) - set(exclude_columns)))
 
         df_query = f"SELECT {intersection_columns_trgt_src_} FROM {object.schema}.{object.name} {where_clause}"
-        
+
         src_pdf = self.execute_queries(df_query,True)
 
         return src_pdf
 
-    def create_pandas_df_from_sample(self, object: DatabaseObject, column_intersections: list, key_columns: list, where_clause:str="", exclude_columns:list=[], key_filters: dict={}, dedicated_columns: list=[], sample_count :int=10, numeric_scale: int = None) -> List[Dict]:
- 
+    def create_pandas_df_from_sample(self, object: DatabaseObject, column_intersections: list, key_columns: list, where_clause:str="", exclude_columns:list=[], key_filters: dict={}, dedicated_columns: list=[], sample_count :int=10, numeric_scale: int = None, enclose_column_by_double_quotes: bool = False) -> List[Dict]:
+
         if self.oracle_connection is None:
             self._connect_to_oracle()
 
@@ -579,26 +585,28 @@ class OracleService(object):
 
             dict_colummns_datatype=self.get_data_types_from_object(object, column_intersections)
 
-       
+
         if key_intersection != [] and is_dedicated:
             keys = str(key_intersection)[1:-1].replace("'", "")
-            column_clause, numeric_columns, used_columns = self._get_column_clause(dedicated_intersection, dict_colummns_datatype, numeric_scale, key_columns)
+            column_clause, numeric_columns, used_columns = self._get_column_clause(dedicated_intersection, dict_colummns_datatype, numeric_scale, key_columns,
+                enclose_column_by_double_quotes)
             if (key_filters != {}) & (filter_intersection != []):
                 values = list(key_filters.values())
                 if values[0] != []:
-                    in_clause = self._get_in_clause(key_filters, numeric_columns, numeric_scale) 
+                    in_clause = self._get_in_clause(key_filters, numeric_columns, numeric_scale, enclose_column_by_double_quotes)
                 else:
                     in_clause = ""
             else:
-                in_clause = "" 
+                in_clause = ""
             sample_query = f"SELECT {column_clause} FROM (SELECT * FROM {object.schema}.{object.name} ORDER BY DBMS_RANDOM.VALUE) {where_clause} AND rownum <= {sample_count} {in_clause} ORDER BY {keys}"
         elif key_intersection != [] and not is_dedicated:
             keys = str(key_intersection)[1:-1].replace("'", "")
-            column_clause, numeric_columns, used_columns = self._get_column_clause(column_intersections, dict_colummns_datatype, numeric_scale, key_columns)
+            column_clause, numeric_columns, used_columns = self._get_column_clause(column_intersections, dict_colummns_datatype, numeric_scale, key_columns,
+                enclose_column_by_double_quotes)
             if (key_filters != {}) & (filter_intersection != []):
                 values = list(key_filters.values())
                 if values[0] != []:
-                    in_clause = self._get_in_clause(key_filters, numeric_columns, numeric_scale)
+                    in_clause = self._get_in_clause(key_filters, numeric_columns, numeric_scale, enclose_column_by_double_quotes)
                 else:
                     in_clause = ""
             else:
@@ -607,7 +615,8 @@ class OracleService(object):
         else:
             column_intersections = list(set(column_intersections)  - set(exclude_columns))
             column_intersections.sort()
-            column_clause, numeric_columns, used_columns = self._get_column_clause(column_intersections, dict_colummns_datatype, numeric_scale, key_columns)
+            column_clause, numeric_columns, used_columns = self._get_column_clause(column_intersections, dict_colummns_datatype, numeric_scale, key_columns,
+                enclose_column_by_double_quotes)
             sample_query = f"SELECT {column_clause} FROM (SELECT * FROM {object.schema}.{object.name} ORDER BY DBMS_RANDOM.VALUE) {where_clause} AND rownum <= {sample_count}"
 
         error_dict = {}
@@ -658,7 +667,7 @@ class OracleService(object):
 
         if self.oracle_connection is None:
             self._connect_to_oracle()
-        
+
         if query:
             query_list: List[str] = query if isinstance(query, list) else [query]
         else:
@@ -668,10 +677,10 @@ class OracleService(object):
 
         results = []
 
-        for single_query in query_list:    
-            try:      
+        for single_query in query_list:
+            try:
                 if return_as_pdf:
-                    
+
                         query_list=cursor.execute(single_query).fetchall()
                         columns = [col[0] for col in cursor.description]
                         query_result = pd.DataFrame(query_list, columns = columns)
@@ -683,7 +692,7 @@ class OracleService(object):
 
             except Exception as err:
                 raise Exception(single_query + "|||" + str(err))
-                
+
             results.append(query_result)
 
         return results[0] if not isinstance(query, list) else results
@@ -697,7 +706,7 @@ class OracleService(object):
         """
         if self.oracle_connection is None:
             self._connect_to_oracle()
-            
+
         statement_list: List[str] = (
             statement if isinstance(statement, list) else [statement]
         )
@@ -706,8 +715,8 @@ class OracleService(object):
             for single_statement in statement_list:
                 stripped_statement = (
                     single_statement.strip()
-                )  
+                )
                 _ = self.oracle_connection.execute_string(stripped_statement)
 
         except Exception as err:
-            raise Exception(self._get_error_message(err, single_statement)) from err
+            raise Exception(self._get_error_message(err, single_statement)) from err