code: def run_query(
      bc,
      engine,
      query,
      queryId,
      queryType,
      worder,
      orderBy,
      acceptable_difference,
      use_percentage,
      input_type,
      **kwargs,
  ):
      """
      This function execute the query with blazingsql and drill/spark and call the functions to compare, print results
      and logs.
  
      ----------
      bc : blazing context
      engine: It's the instance of the engine (pydrill/ỳspark).
      query: Executed query.
      queryId: Query Id.
      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.
      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.
      input_type: The data type (CSV, PARQUET, DASK_CUDF, JSON, ORC, GDF) that we use to run the query.
      """
  
      print(query)
  
      worder = 1 if worder == True else worder
  
      query_spark = kwargs.get("query_spark", query)
  
      algebra = kwargs.get("algebra", "")
  
      comparing = kwargs.get("comparing", True)
  
      nRals = Settings.data["RunSettings"]["nRals"]
  
      print_result = kwargs.get("print_result")
      if print_result is None:
          print_result = False
  
      message_validation = kwargs.get("message_validation", "")
      if message_validation is None:
          message_validation = False
  
      nested_query = kwargs.get("nested_query", False)
  
      blz_result = None
      if nested_query:
          blz_result = kwargs.get("blz_result", [])
  
      data_type = cs.get_extension(input_type)
  
      if Settings.execution_mode != "generator":
          print(
              "\n=============== New query: "
              + str(queryId)
              + " - "
              + data_type
              + " ("
              + queryType
              + ")"
              + "================="
          )
  
      str_code_test = str(get_codTest(queryType)).upper()
      filename = str_code_test + "-" + str(queryId) + ".parquet"
  
      result_dir = Settings.data["TestSettings"]["fileResultsDirectory"]
      file_results_dir = str(result_dir)
  
      testsWithNulls = Settings.data["RunSettings"]["testsWithNulls"]
  
      (
          result_gdf,
          load_time,
          engine_time,
          total_time,
          error_message,
      ) = run_query_blazing(
          bc,
          nested_query,
          query,
          algebra,
          message_validation,
          blz_result,
      )
  
      base_results_gd = None
  
      compareResults = True
  
      resultFile = ""
  
      str_engine = ""
  
      if not message_validation == "":
          print_validation_results(
              query,
              queryId,
              input_type,
              queryType,
              error_message,
              message_validation,
          )
      elif not isinstance(engine, str):
          if isinstance(engine, PyDrill):
              # Drill
              query_drill = get_drill_query(query)
              base_results_gd = run_query_drill(engine, query_drill)
              str_engine = "drill"
  
          elif isinstance(engine, SparkSession):
              # Spark
              base_results_gd = run_query_spark(engine, query_spark)
              str_engine = "spark"
  
      else:  # GPUCI
          if "compare_result_values" in Settings.data["RunSettings"]:
              compareResults = Settings.data["RunSettings"][
                  "compare_result_values"
              ]
  
          if compareResults:
              if testsWithNulls != "true":
                  resultFile = (
                      file_results_dir
                      + "/"
                      + str(engine)
                      + "/"
                      + filename
                  )
              else:
                  resultFile = (
                      file_results_dir
                      + "/"
                      + str(engine)
                      + "-nulls"
                      + "/"
                      + filename
                  )
  
              # base_results_gd = get_results(resultFile)
  
      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,
      )
  
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 38 for calling a global function with example usage: run_query(bc, engine, query, queryId, queryType, worder, orderBy, acceptable_difference, use_percentage, input_type) without return types