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

icsDataValidation/connection_setups/azure_connection_setup.py

@@ -14,6 +14,7 @@ def load_azure_credentials(system_configs:dict,system_selection:str)->dict:
         "User"      : system_configs[system_selection]["USER"],
         "Password"  : os.getenv(system_configs[system_selection]["PASSWORD_NAME"]),
         "Driver"    : system_configs[system_selection]["DRIVER"],
+        "Port"      : system_configs[system_selection]["PORT"],
     }
 
-    return azure_params
+    return azure_params

icsDataValidation/connection_setups/sqlserver_connection_setup.py

@@ -0,0 +1,20 @@
+import os
+
+from dotenv import load_dotenv
+from pathlib import Path
+
+#########################################################################################
+#########################################################################################
+
+def load_sqlserver_credentials(system_configs:dict,system_selection:str)->dict:
+
+    sqlserver_params = {
+        "Server"    : system_configs[system_selection]["SERVER"],
+        "Database"  : system_configs[system_selection]["DATABASE"],
+        "User"      : system_configs[system_selection]["USER"],
+        "Password"  : os.getenv(system_configs[system_selection]["PASSWORD_NAME"]),
+        "Driver"    : system_configs[system_selection]["DRIVER"],
+        "Port"      : system_configs[system_selection]["PORT"],
+    }
+
+    return sqlserver_params

icsDataValidation/input_parameters/testing_tool_params.py

@@ -19,7 +19,7 @@ class TestingToolParams:
     pipeline_name: str                          = os.environ.get('BUILD_DEFINITIONNAME','build_definitionname env variable not found')
 
     #########################################################################################
-    
+
     # manual execution load input parameters
     if pipeline_id is None:
         from examples.manual_execution_params import manual_execution_params
@@ -56,8 +56,9 @@ class TestingToolParams:
     max_group_by_count_distinct: int            = int(os.environ.get('MAX_GROUP_BY_COUNT_DISTINCT','max_group_by_count_distinct env variable not found'))
     max_group_by_size: int                      = int(os.environ.get('MAX_GROUP_BY_SIZE','max_group_by_size env variable not found'))
     numeric_scale: int                          = int(os.environ.get('NUMERIC_SCALE','numeric_scale env variable not found'))
+    enclose_column_by_double_quotes: bool       = True if os.environ.get('ENCLOSE_COLUMN_BY_DOUBLE_QUOTES','enclose_column_by_double_quotes env variable not found') == 'True' else False
     branch_name: str                            = os.environ.get('BRANCH_NAME', 'branch_name env variable not found')
-    source_branch:str                           = os.environ.get('BUILD_SOURCEBRANCH', 'build_sourcebranch env variable not found')  
+    source_branch:str                           = os.environ.get('BUILD_SOURCEBRANCH', 'build_sourcebranch env variable not found')
     azure_storage_connection_string: str        = os.environ.get('AZURE_STORAGE_CONNECTION_STRING','azure_storage_connection_string env variable not found')
     aws_bucket_access_key: str                  = os.environ.get('AWS_BUCKET_ACCESS_KEY', 'aws_bucket_access_key env variable not found')
     aws_bucket_secret_key: str                  = os.environ.get('AWS_BUCKET_SECRET_KEY', 'aws_bucket_secret_key env variable not found')
@@ -65,7 +66,7 @@ class TestingToolParams:
     testatm_access_token: str                   = os.environ.get('TESTATM_ACCESS_TOKEN', 'testatm_access_token env variable not found')
     gitlab_ci_server_host: str                  = os.environ.get('GITLAB_CI_SERVER_HOST', 'gitlab_ci_server_host env variable not found')
     gitlab_ci_project_path: str                 = os.environ.get('GITLAB_CI_PROJECT_PATH', 'gitlab_ci_project_path env variable not found')
-    
+
 
     #########################################################################################
 

icsDataValidation/main.py

@@ -5,6 +5,7 @@ import sys
 import os
 import time
 import logging
+import warnings
 
 from datetime import datetime
 
@@ -14,6 +15,9 @@ from datetime import datetime
 current_working_dir = os.getcwd()
 sys.path.append(current_working_dir)
 ##############################
+# Ignore Userwarning
+warnings.simplefilter("ignore", UserWarning)
+##############################
 
 import icsDataValidation.utils.parallelization_util as parallelization_util
 
@@ -46,7 +50,7 @@ def execute():
     initialization_service = InitializationService(TestingToolParams, current_working_dir, start_time_utc)
 
     config_file_path, migration_config_file_path = initialization_service.get_config_file_paths()
-    
+
     #########################################################################################
     logger.info(f"++++++++++++++++ LOAD config.json")
 
@@ -113,14 +117,14 @@ def execute():
             raise ValueError(f"TestsetService could not be initialized. Check wether the migration_config contains the 'MAPPING' key and the 'BLACKLIST' key. {error}")
     else:
         raise ValueError("migration_config not found!")
-    
+
     #########################################################################################
-    logger.info(f"++++++++++++++++ HANDLE database mapping") 
+    logger.info(f"++++++++++++++++ HANDLE database mapping")
 
     target_database_name = testset_service.handle_database_mapping(TestingToolParams.database_name)
 
     #########################################################################################
-    logger.info(f"++++++++++++++++ HANDLE schema mapping and schema replace mapping") 
+    logger.info(f"++++++++++++++++ HANDLE schema mapping and schema replace mapping")
 
     if TestingToolParams.schema_name:
         target_schema_name, found_schema_mapping = testset_service.handle_schema_mapping(TestingToolParams.schema_name, TestingToolParams.database_name)
@@ -173,25 +177,25 @@ def execute():
     logger.info(f"++++++++++++++++ HANDLE whitelist")
 
     if testset_service.testset_whitelist and any(testset_service.testset_whitelist.values()):
-        
+
         database_objects_src=testset_service.handle_whitelist(database_objects_src, "SRC")
         database_objects_trgt=testset_service.handle_whitelist(database_objects_trgt, "TRGT")
-        
+
     #########################################################################################
-    logger.info(f"++++++++++++++++ HANDLE object mapping")# 
+    logger.info(f"++++++++++++++++ HANDLE object mapping")#
     database_objects_src=sorted(database_objects_src, key=lambda d: d["object_identifier"])
     database_objects_trgt=sorted(database_objects_trgt, key=lambda d: d["object_identifier"])
 
     (
         intersection_objects_mapped_trgt_src,
         object_identifiers_src_minus_trgt,
-        object_identifiers_trgt_minus_src, 
-        remaining_mapping_objects, 
+        object_identifiers_trgt_minus_src,
+        remaining_mapping_objects,
         all_objects_matching
     ) = testset_service.map_objects(database_objects_src, database_objects_trgt)
 
     #########################################################################################
-    logger.info(f"++++++++++++++++ GET objects_to_compare")# 
+    logger.info(f"++++++++++++++++ GET objects_to_compare")#
 
     objects_to_compare=testset_service.get_intersection_objects_trgt_src(database_objects_src, database_objects_trgt, intersection_objects_mapped_trgt_src)
 
@@ -247,4 +251,4 @@ def execute():
 
 
 if __name__ == "__main__":
-    execute()
+    execute()

icsDataValidation/services/comparison_service.py

@@ -44,9 +44,9 @@ class ComparisonService(TestingToolParams):
         object_group_by_column=None
         for object_group_by_column in group_by_column_candidates:
 
-            src_group_by_column_count_distinct=next(item["COUNT_DISTINCT"] for item in src_column_count_distincts if item["COLUMN_NAME"].upper() == object_group_by_column)   
+            src_group_by_column_count_distinct=next(item["COUNT_DISTINCT"] for item in src_column_count_distincts if item["COLUMN_NAME"].upper() == object_group_by_column)
             trgt_group_by_column_count_distinct=next(item["COUNT_DISTINCT"] for item in trgt_column_count_distincts if item["COLUMN_NAME"].upper() == object_group_by_column)
-            
+
             if (trgt_group_by_column_count_distinct<=1 or src_group_by_column_count_distinct<=1):
                 logger.info(f"[{self.comp_id}] The GROUP_BY_COLUMN {object_group_by_column} does not satisfy the necessary criteria.")
                 logger.info(f"[{self.comp_id}] Number of distinct values <= 1 on src or trgt.")
@@ -70,7 +70,7 @@ class ComparisonService(TestingToolParams):
 
             logger.info(f"[{self.comp_id}] USING Column {object_group_by_column} for group by aggregation")
             return object_group_by_column
-        
+
     def row_count_comparison(self):
         logger.info(f"[{self.comp_id}] START Row-Count-Comparison")
         # row count comparison
@@ -104,10 +104,10 @@ class ComparisonService(TestingToolParams):
         columns_equal = True
         if src_columns_minus_trgt_columns:
             columns_equal = False
-            
+
         if trgt_columns_minus_src_columns:
             columns_equal = False
-            
+
         intersection_columns_trgt_src = list(set(src_columns_upper) & set(trgt_columns_upper))
         intersection_columns_trgt_src.sort()
 
@@ -123,15 +123,15 @@ class ComparisonService(TestingToolParams):
         self.result_params.trgt_columns_minus_src_columns = trgt_columns_minus_src_columns
         self.result_params.columns_equal = columns_equal
         self.result_params.intersection_columns_trgt_src = intersection_columns_trgt_src
-        self.result_params.all_columns_trgt_src = all_columns_trgt_src    
+        self.result_params.all_columns_trgt_src = all_columns_trgt_src
 
     def aggregation_comparison(self):
         logger.info(f"[{self.comp_id}] START Aggregation-Comparison")
         src_column_datatypes = self.db_service_src.get_data_types_from_object(self.src_object, self.result_params.src_columns)
-        src_columns_aggregate = self.db_service_src.create_checksums(self.src_object, self.result_params.src_columns, self.src_filter, self.exclude_columns, self.numeric_scale)
+        src_columns_aggregate = self.db_service_src.create_checksums(self.src_object, self.result_params.src_columns, self.src_filter, self.exclude_columns, self.numeric_scale, self.enclose_column_by_double_quotes)
 
         trgt_column_datatypes = self.db_service_trgt.get_data_types_from_object(self.trgt_object, self.result_params.trgt_columns)
-        trgt_columns_aggregate = self.db_service_trgt.create_checksums(self.trgt_object, self.result_params.trgt_columns, self.trgt_filter, self.exclude_columns, self.numeric_scale)
+        trgt_columns_aggregate = self.db_service_trgt.create_checksums(self.trgt_object, self.result_params.trgt_columns, self.trgt_filter, self.exclude_columns, self.numeric_scale, self.enclose_column_by_double_quotes)
 
         src_aggregations_error = src_columns_aggregate['TESTATM_ERRORS']
         trgt_aggregations_error = trgt_columns_aggregate['TESTATM_ERRORS']
@@ -160,47 +160,47 @@ class ComparisonService(TestingToolParams):
                 , 'ERROR': trgt_aggregations_error[0][2]
             }
         else:
-            trgt_error_dict = {'QUERY': None, 'ERROR': None}           
+            trgt_error_dict = {'QUERY': None, 'ERROR': None}
 
         del src_columns_aggregate['TESTATM_ERRORS']
         del trgt_columns_aggregate['TESTATM_ERRORS']
 
         if self.result_params.src_row_count != 0 and self.result_params.trgt_row_count != 0:
             aggregation_differences_trgt_minus_src_not_boolean = {
-                                                                    k:  round(Decimal(trgt_columns_aggregate[k][1]) 
-                                                                        - Decimal(src_columns_aggregate[k][1]), self.numeric_scale) 
-                                                                    for k in src_columns_aggregate.keys() 
-                                                                        if k in trgt_columns_aggregate 
-                                                                        and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1]) 
+                                                                    k:  round(Decimal(trgt_columns_aggregate[k][1])
+                                                                        - Decimal(src_columns_aggregate[k][1]), self.numeric_scale)
+                                                                    for k in src_columns_aggregate.keys()
+                                                                        if k in trgt_columns_aggregate
+                                                                        and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1])
                                                                         and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1]
                                                                         and src_columns_aggregate[k][0].upper() != 'AGGREGATEBOOLEAN'
                                                                         and trgt_columns_aggregate[k][0].upper() != 'AGGREGATEBOOLEAN'
                                                                 }
             aggregation_differences_trgt_minus_src_boolean = {
                                                                 k:  str(
-                                                                        int(trgt_columns_aggregate[k][1].split('_',1)[0]) 
+                                                                        int(trgt_columns_aggregate[k][1].split('_',1)[0])
                                                                         - int(src_columns_aggregate[k][1].split('_',1)[0])
-                                                                    ) 
-                                                                    + '_' 
+                                                                    )
+                                                                    + '_'
                                                                     + str(
-                                                                        int(trgt_columns_aggregate[k][1].split('_',1)[1]) 
+                                                                        int(trgt_columns_aggregate[k][1].split('_',1)[1])
                                                                         - int(src_columns_aggregate[k][1].split('_',1)[1])
-                                                                    ) 
-                                                                for k in src_columns_aggregate.keys() 
-                                                                    if k in trgt_columns_aggregate 
+                                                                    )
+                                                                for k in src_columns_aggregate.keys()
+                                                                    if k in trgt_columns_aggregate
                                                                     and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1])
-                                                                    and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1] 
-                                                                    and src_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN' 
+                                                                    and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1]
+                                                                    and src_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN'
                                                                     and trgt_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN'
                                                             }
             aggregation_differences_trgt_minus_src=aggregation_differences_trgt_minus_src_not_boolean
             aggregation_differences_trgt_minus_src.update(aggregation_differences_trgt_minus_src_boolean)
         elif self.result_params.src_row_count != 0 and self.result_params.trgt_row_count == 0:
             aggregation_differences_trgt_minus_src_not_boolean = {
-                                                        k: -src_columns_aggregate[k][1] 
-                                                        for k in src_columns_aggregate.keys() 
-                                                            if k in trgt_columns_aggregate 
-                                                            and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1]) 
+                                                        k: -src_columns_aggregate[k][1]
+                                                        for k in src_columns_aggregate.keys()
+                                                            if k in trgt_columns_aggregate
+                                                            and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1])
                                                             and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1]
                                                             and src_columns_aggregate[k][0].upper() != 'AGGREGATEBOOLEAN'
                                                             and trgt_columns_aggregate[k][0].upper() != 'AGGREGATEBOOLEAN'
@@ -208,31 +208,31 @@ class ComparisonService(TestingToolParams):
             aggregation_differences_trgt_minus_src_boolean = {
                                                                 k:  str(
                                                                         - int(src_columns_aggregate[k][1].split('_',1)[0])
-                                                                    ) 
-                                                                    + '_' 
+                                                                    )
+                                                                    + '_'
                                                                     + str(
                                                                         - int(src_columns_aggregate[k][1].split('_',1)[1])
-                                                                    ) 
-                                                                for k in src_columns_aggregate.keys() 
-                                                                    if k in trgt_columns_aggregate 
+                                                                    )
+                                                                for k in src_columns_aggregate.keys()
+                                                                    if k in trgt_columns_aggregate
                                                                     and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1])
-                                                                    and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1] 
-                                                                    and src_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN' 
+                                                                    and src_columns_aggregate[k][1] != trgt_columns_aggregate[k][1]
+                                                                    and src_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN'
                                                                     and trgt_columns_aggregate[k][0].upper() == 'AGGREGATEBOOLEAN'
                                                             }
             aggregation_differences_trgt_minus_src=aggregation_differences_trgt_minus_src_not_boolean
             aggregation_differences_trgt_minus_src.update(aggregation_differences_trgt_minus_src_boolean)
         elif self.result_params.src_row_count == 0 and self.result_params.trgt_row_count != 0:
             aggregation_differences_trgt_minus_src = {
-                                                        k: trgt_columns_aggregate[k][1] 
-                                                        for k in src_columns_aggregate.keys() 
-                                                            if k in trgt_columns_aggregate 
+                                                        k: trgt_columns_aggregate[k][1]
+                                                        for k in src_columns_aggregate.keys()
+                                                            if k in trgt_columns_aggregate
                                                             and str(src_columns_aggregate[k][1]) != str(trgt_columns_aggregate[k][1])
                                                     }
 
         else:
             aggregation_differences_trgt_minus_src = {}
-                                                     
+
         aggregations_equal = True
         if src_aggregations_error or trgt_aggregations_error:
             aggregations_equal = None
@@ -240,9 +240,9 @@ class ComparisonService(TestingToolParams):
             for aggregation_diff in aggregation_differences_trgt_minus_src.values():
                 if aggregation_diff and not aggregation_diff == 0.0:
                     aggregations_equal = False
-                    break 
+                    break
 
-        # save results              
+        # save results
         self.result_params.src_column_datatypes = src_column_datatypes
         self.result_params.src_columns_aggregate = src_columns_aggregate
         self.result_params.trgt_column_datatypes = trgt_column_datatypes
@@ -252,7 +252,7 @@ class ComparisonService(TestingToolParams):
         self.result_params.aggregation_differences_trgt_minus_src  = aggregation_differences_trgt_minus_src
         self.result_params.src_error_dict = src_error_dict
         self.result_params.trgt_error_dict = trgt_error_dict
-        self.result_params.aggregations_equal = aggregations_equal 
+        self.result_params.aggregations_equal = aggregations_equal
 
 
     def group_by_comparison(self):
@@ -260,7 +260,7 @@ class ComparisonService(TestingToolParams):
         object_group_by_columns=[]
         group_by_columns_src=[]
         group_by_columns_trgt=[]
-        src_group_by_error = {} 
+        src_group_by_error = {}
         trgt_group_by_error = {}
         src_group_by_query_aggregation_string = ''
         src_group_by_query_columns_string = ''
@@ -288,7 +288,7 @@ class ComparisonService(TestingToolParams):
                 raise ValueError(f"The GROUP_BY_COLUMNS_PER_TABLE key is missing in the migration_config.json. Please add the key to the config under GROUP_BY_AGGREGATION or disable the use_group_by_columns parameter or the execute_group_by_comparison parameter.")
 
         # group-by only if tables not empty
-        if self.result_params.src_row_count == 0 : 
+        if self.result_params.src_row_count == 0 :
             logger.info(f"[{self.comp_id}] Source table  {self.src_object.database}.{self.src_object.schema}.{self.src_object.name} is empty, Group-By-Comparison will be skipped")
         elif self.result_params.trgt_row_count == 0:
             logger.info(f"[{self.comp_id}] Target table {self.trgt_object.database}.{self.trgt_object.schema}.{self.trgt_object.name}  is empty, Group-By-Comparison will be skipped")
@@ -314,21 +314,21 @@ class ComparisonService(TestingToolParams):
         # group-by option 3 - group_by_columns NOT defined as a list
         elif (not self.use_group_by_columns or not object_group_by_columns):
             logger.info(f"[{self.comp_id}] START Group-By-Comparison - with option 3 (group_by_columns NOT defined -> retrieve group_by_columns by defined criteria)")
-            src_column_count_distincts, error_list = self.db_service_src.get_count_distincts_from_object(self.src_object, self.result_params.src_columns)
-            trgt_column_count_distincts, error_list = self.db_service_trgt.get_count_distincts_from_object(self.trgt_object, self.result_params.trgt_columns)
+            src_column_count_distincts, error_list = self.db_service_src.get_count_distincts_from_object(self.src_object, self.result_params.src_columns, self.enclose_column_by_double_quotes)
+            trgt_column_count_distincts, error_list = self.db_service_trgt.get_count_distincts_from_object(self.trgt_object, self.result_params.trgt_columns, self.enclose_column_by_double_quotes)
             if src_column_count_distincts and trgt_column_count_distincts:
                 object_group_by_column=self._get_group_by_column_by_validation(self.result_params.intersection_columns_trgt_src, src_column_count_distincts, trgt_column_count_distincts)
                 if object_group_by_column:
                     object_group_by_columns=[object_group_by_column]
                     object_group_by_aggregation_columns=["all"]
                     object_group_by_aggregation_type='various'
-           
+
         if not object_group_by_columns:
             logger.info(f"[{self.comp_id}] No Group-By-Columns found")
         else:
             logger.info(f"[{self.comp_id}] USING Column(s) {str(object_group_by_columns)} for Group-By-Comparison")
-            src_pdf_from_group_by, src_group_by_query_aggregation_string, src_group_by_query_columns_string, group_by_columns_src, src_group_by_error = self.db_service_src.create_pandas_df_from_group_by(self.src_object, self.result_params.intersection_columns_trgt_src, object_group_by_columns, object_group_by_aggregation_columns, object_group_by_aggregation_type, False, self.src_filter, self.exclude_columns, self.numeric_scale)
-            trgt_pdf_from_group_by, trgt_group_by_query_aggregation_string, trgt_group_by_query_columns_string, group_by_columns_trgt, trgt_group_by_error = self.db_service_trgt.create_pandas_df_from_group_by(self.trgt_object, self.result_params.intersection_columns_trgt_src, object_group_by_columns, object_group_by_aggregation_columns, object_group_by_aggregation_type, False, self.trgt_filter, self.exclude_columns, self.numeric_scale)
+            src_pdf_from_group_by, src_group_by_query_aggregation_string, src_group_by_query_columns_string, group_by_columns_src, src_group_by_error = self.db_service_src.create_pandas_df_from_group_by(self.src_object, self.result_params.intersection_columns_trgt_src, object_group_by_columns, object_group_by_aggregation_columns, object_group_by_aggregation_type, False, self.src_filter, self.exclude_columns, self.numeric_scale, self.enclose_column_by_double_quotes)
+            trgt_pdf_from_group_by, trgt_group_by_query_aggregation_string, trgt_group_by_query_columns_string, group_by_columns_trgt, trgt_group_by_error = self.db_service_trgt.create_pandas_df_from_group_by(self.trgt_object, self.result_params.intersection_columns_trgt_src, object_group_by_columns, object_group_by_aggregation_columns, object_group_by_aggregation_type, False, self.trgt_filter, self.exclude_columns, self.numeric_scale, self.enclose_column_by_double_quotes)
 
              # check if Group-By-Aggregation was actually performed
             if src_group_by_error == {} and trgt_group_by_error == {}:
@@ -338,8 +338,8 @@ class ComparisonService(TestingToolParams):
                     logger.debug(f"[{self.comp_id}] diff_trgt_pdf_from_group_by_sorted:\n {diff_trgt_pdf_from_group_by_sorted}")
 
                 for object_group_by_column in object_group_by_columns:
-                    # creating Group-By-Values with mismatches 
-                    if object_group_by_column in diff_src_pdf_from_group_by_sorted and object_group_by_column in diff_trgt_pdf_from_group_by_sorted:                 
+                    # creating Group-By-Values with mismatches
+                    if object_group_by_column in diff_src_pdf_from_group_by_sorted and object_group_by_column in diff_trgt_pdf_from_group_by_sorted:
                         group_by_values_with_mismatches [object_group_by_column] = list(set(diff_src_pdf_from_group_by_sorted[object_group_by_column].tolist()).union(set(diff_trgt_pdf_from_group_by_sorted[object_group_by_column].tolist())))
                     elif object_group_by_column in diff_src_pdf_from_group_by_sorted:
                         group_by_values_with_mismatches [object_group_by_column] = diff_src_pdf_from_group_by_sorted[object_group_by_column].tolist()
@@ -388,8 +388,8 @@ class ComparisonService(TestingToolParams):
                     pandas_df_from_group_by_is_equal = src_pdf_from_group_by_sorted.equals(trgt_pdf_from_group_by_sorted)
                 except:
                     pandas_df_from_group_by_is_equal = False
-            
-            ## RE-EVALUATE 
+
+            ## RE-EVALUATE
             if src_group_by_error == {} and trgt_group_by_error == {} and src_pdf_from_group_by_sorted is not None and trgt_pdf_from_group_by_sorted is not None:
 
                 eq_frame = src_pdf_from_group_by_sorted.eq(trgt_pdf_from_group_by_sorted)
@@ -401,7 +401,7 @@ class ComparisonService(TestingToolParams):
                         pandas_df_from_group_by_is_equal = False
 
                 src_number_of_rows = len(src_pdf_from_group_by_sorted.index)
-                trgt_number_of_rows = len(trgt_pdf_from_group_by_sorted.index)                            
+                trgt_number_of_rows = len(trgt_pdf_from_group_by_sorted.index)
                 logger.info(f"[{self.comp_id}] ROWS src_pdf_from_group_by_sorted: {str(src_number_of_rows)}")
                 logger.info(f"[{self.comp_id}] ROWS trgt_pdf_from_group_by_sorted: {str(trgt_number_of_rows)}")
                 diff_rows = abs(trgt_number_of_rows - src_number_of_rows)
@@ -417,14 +417,14 @@ class ComparisonService(TestingToolParams):
 
                     trgt_delta_pdf_pre = trgt_pdf_from_group_by_sorted.merge(src_pdf_from_group_by_sorted, indicator=True, how='outer').query('_merge not in ("both", "right_only")')
 
-                    ## RE-EVALUATE 
+                    ## RE-EVALUATE
                     eq_frame = src_pdf_from_group_by_sorted.eq(trgt_pdf_from_group_by_sorted)
                     if not pandas_df_from_group_by_is_equal:
                         if src_delta_pdf_pre.empty and trgt_delta_pdf_pre.empty:
                             pandas_df_from_group_by_is_equal = True
                         else:
                             pandas_df_from_group_by_is_equal = False
-        
+
         #### save self.result_params data
         self.result_params.src_group_by_query = src_group_by_query
         self.result_params.trgt_group_by_query = trgt_group_by_query
@@ -444,7 +444,7 @@ class ComparisonService(TestingToolParams):
                     src_tbl_size=-1
             else:
                 src_tbl_size = self.db_service_src.get_table_size(self.src_object)
-                
+
             if self.trgt_object.type=='view':
                 trgt_tbl_size=-1
             else:
@@ -456,13 +456,13 @@ class ComparisonService(TestingToolParams):
         if (
             src_tbl_size is None
             or trgt_tbl_size is None
-            or src_tbl_size == 0 
-            or trgt_tbl_size == 0 
-            or src_tbl_size > self.max_object_size 
-            or trgt_tbl_size > self.max_object_size 
-            or self.result_params.src_row_count > self.max_row_number 
+            or src_tbl_size == 0
+            or trgt_tbl_size == 0
+            or src_tbl_size > self.max_object_size
+            or trgt_tbl_size > self.max_object_size
+            or self.result_params.src_row_count > self.max_row_number
             or self.result_params.trgt_row_count > self.max_row_number
-        ): 
+        ):
             pandas_df_compared = False
             pandas_df_is_equal = None
             pandas_df_mismatch = f"Pandas Dataframes not compared!"
@@ -474,8 +474,8 @@ class ComparisonService(TestingToolParams):
                 logger.info(f"[{self.comp_id}] Pandas Dataframes not compared -> restricted by input parameters MAX_OBJECT_SIZE and MAX_ROW_NUMBER")
         else:
             logger.info(f"[{self.comp_id}] START Pandas-Dataframe-Comparison")
-            src_pdf = self.db_service_src.create_pandas_df(self.src_object, self.result_params.intersection_columns_trgt_src, self.src_filter, self.exclude_columns)
-            trgt_pdf = self.db_service_trgt.create_pandas_df(self.trgt_object, self.result_params.intersection_columns_trgt_src, self.trgt_filter, self.exclude_columns)
+            src_pdf = self.db_service_src.create_pandas_df(self.src_object, self.result_params.intersection_columns_trgt_src, self.src_filter, self.exclude_columns, self.enclose_column_by_double_quotes)
+            trgt_pdf = self.db_service_trgt.create_pandas_df(self.trgt_object, self.result_params.intersection_columns_trgt_src, self.trgt_filter, self.exclude_columns, self.enclose_column_by_double_quotes)
 
             # sorting the dataframes using the intersecting columns minus excluded columns
             src_pdf_sorted  =  src_pdf.sort_values(by=list(set(self.result_params.intersection_columns_trgt_src) - set(self.exclude_columns))).reset_index(drop=True)
@@ -519,20 +519,24 @@ class ComparisonService(TestingToolParams):
                 samples_compared = True
                 key_columns = sample_comparison_config[f"{self.src_object.database}.{self.src_object.schema}.{self.src_object.name}"]
                 trgt_sample_pdf, trgt_key_filters, trgt_used_columns, trgt_sample_query = self.db_service_trgt.create_pandas_df_from_sample(
-                                                                                                                                object = self.trgt_object,  
-                                                                                                                                column_intersections=self.result_params.intersection_columns_trgt_src,  
-                                                                                                                                key_columns=key_columns, 
-                                                                                                                                where_clause=self.trgt_filter, 
-                                                                                                                                exclude_columns=self.exclude_columns
+                                                                                                                                object = self.trgt_object,
+                                                                                                                                column_intersections=self.result_params.intersection_columns_trgt_src,
+                                                                                                                                key_columns=key_columns,
+                                                                                                                                where_clause=self.trgt_filter,
+                                                                                                                                exclude_columns=self.exclude_columns,
+                                                                                                                                numeric_scale=self.numeric_scale,
+                                                                                                                                enclose_column_by_double_quotes=self.enclose_column_by_double_quotes
                                                                                                                                 )
                 src_sample_pdf, src_key_filters, src_used_columns, src_sample_query = self.db_service_src.create_pandas_df_from_sample(
-                                                                                                                            object = self.src_object, 
-                                                                                                                            column_intersections=self.result_params.intersection_columns_trgt_src,  
-                                                                                                                            key_columns=key_columns, 
+                                                                                                                            object = self.src_object,
+                                                                                                                            column_intersections=self.result_params.intersection_columns_trgt_src,
+                                                                                                                            key_columns=key_columns,
                                                                                                                             where_clause=self.src_filter,
-                                                                                                                            exclude_columns=self.exclude_columns, 
-                                                                                                                            key_filters=trgt_key_filters, 
-                                                                                                                            dedicated_columns=trgt_used_columns
+                                                                                                                            exclude_columns=self.exclude_columns,
+                                                                                                                            key_filters=trgt_key_filters,
+                                                                                                                            dedicated_columns=trgt_used_columns,
+                                                                                                                            numeric_scale=self.numeric_scale,
+                                                                                                                            enclose_column_by_double_quotes=self.enclose_column_by_double_quotes
                                                                                                                             )
                 ## Handle Datetime Datatypes -> transform into readable string
                 for key in trgt_key_filters:
@@ -579,4 +583,4 @@ class ComparisonService(TestingToolParams):
         self.result_params.trgt_sample_error_dict= trgt_sample_error_dict
         self.result_params.samples_compared = samples_compared
         self.result_params.samples_equal = samples_equal
-        self.result_params.trgt_key_filters = trgt_key_filters
+        self.result_params.trgt_key_filters = trgt_key_filters