code: def results_processing(
      result_gdf,
      base_results_gd,
      worder,
      orderBy,
      testsWithNulls,
      filename,
      query,
      queryId,
      queryType,
      acceptable_difference,
      use_percentage,
      print_result,
      engine,
      input_type,
      load_time,
      engine_time,
      total_time,
      comparing,
      compareResults,
      resultFile,
      file_results_dir,
      str_engine,
  ):
      """
      Results processing of the query execution with blazingsql and drill/spark.
      It include the results formatting, comparison and print of results.
  
      ----------
      result_gdf : blazing results gdf
      base_results_gd : drill/spark results gdf
      worder : (True/False) parameter to indicate if it's neccesary to order the results.
      orderBy : It indicate by what column we want to order the results
      testsWithNulls : that is about the data with we get the results, if it contains nulls or not.
      filename: it's the name that the generated result file will have.
      query: Executed query.
      queryId: Query Id.
      acceptable_difference: This parameter is related to the acceptable difference beetween values
      from blazingsql results and drill/spark results.
      use_percentage: (True/False) to indicate if the results will be compared by percentage or difference.
      print_result: (True/False) To show the query results information on the screen.
      engine: It's the instance of the engine (pydrill/ỳspark).
      input_type: The data type (CSV, PARQUET, DASK_CUDF, JSON, ORC, GDF) that we use to run the query.
      load_time:
      engine_time:
      total_time: Total time to execute the query
      comparing: It indicate if the results will be compared with the results with the based engines (drill/spark)
      resultFile: Complete path where the results file will be saved.
      file_results_dir: Path where the results file will be saved.
      str_engine: the values will be drill/spark
  
      """
  
      if result_gdf is not None:
          if result_gdf.columns is not None:
              # FOR DASK CUDF
              import dask_cudf
  
              if type(result_gdf) is dask_cudf.core.DataFrame:
                  result_gdf = result_gdf.compute()
  
              expected_dtypes = result_gdf.dtypes.to_list()
              pdf1 = (
                  upcast_to_float(result_gdf)
                  .fillna(get_null_constants(result_gdf))
                  .to_pandas()
              )
  
              if not isinstance(engine, str):
                  pdf2 = to_pandas_f64_engine(
                      base_results_gd.resultSet, expected_dtypes
                  )
                  pdf2 = upcast_to_float(pdf2).fillna(
                      get_null_constants(pdf2)
                  )
  
                  formatResults(pdf1, pdf2, worder, orderBy)
              else:
                  if compareResults:
                      format_pdf(pdf1, worder, orderBy)
                      pdf2 = get_results(resultFile)
                  else:
                      pdf2 = pd.DataFrame()
                      formatResults(pdf1, pdf2, worder, orderBy)
  
              if Settings.execution_mode == ExecutionMode.GENERATOR:
                  results_file_generator(
                      file_results_dir,
                      testsWithNulls,
                      filename,
                      str_engine,
                      pdf2,
                  )
                  print("==============================")
              else:
                  (
                      error_message,
                      stringResult,
                      columnNamesComparison,
                      resultComparisson,
                  ) = compare_test_results(
                      pdf1,
                      pdf2,
                      acceptable_difference,
                      use_percentage,
                      engine,
                      comparing,
                  )
                  print_comparison_results(
                      query,
                      queryId,
                      queryType,
                      pdf1,
                      pdf2,
                      print_result,
                      engine,
                      input_type,
                      total_time,
                      error_message,
                      stringResult,
                      columnNamesComparison,
                      resultComparisson,
                  )
  
                  logger = logginghelper(name)
  
                  # TODO percy kharoly bindings we need to get the number from internal api
                  logger_results(
                      logger,
                      queryType,
                      input_type,
                      queryId,
                      query,
                      stringResult,
                      error_message,
                      load_time,
                      engine_time,
                      total_time,
                  )
          else:
              print_validation_results(
                  query, queryId, queryType, result_gdf.error_message
              )
  
imports: import json
  import logging
  import os
  import re
  import time
  import yaml
  import numpy
  import pandas
  import blazingsql
  from blazingsql import DataType
  from BlazingLogging import loggingHandler
  from Configuration import ExecutionMode
  from Configuration import Settings
  from DataBase import createSchema
label_desc: Use image node_id 39 for calling a global function with example usage: results_processing(result_gdf, base_results_gd, worder, orderBy, testsWithNulls, filename, query, queryId, queryType, acceptable_difference, use_percentage, print_result, engine, input_type, load_time, engine_time, total_time, comparing, compareResults, resultFile, file_results_dir, str_engine) without return types