code: def executionTestAuto(dask_client, spark, dir_data_file, bc, nRals):
      # Create Tables -----------------------------------------------------
      for fileSchemaType in data_types:
          if skip_test(dask_client, nRals, fileSchemaType, queryType):
              continue
  
          location = tmpPath + cs.get_extension(fileSchemaType) + "/"
  
          # Create tables for hive
          cs.create_hive_partitions_tables(
              bc=bc,
              dir_partitions=location,
              fileSchemaType=fileSchemaType,
              createTableType=cs.HiveCreateTableType.AUTO,
              partitions={},
              partitions_schema=[],
              tables=tables,
          )
  
          # Run Query ------------------------------------------------------
          # Parameter to indicate if its necessary to order
          # the resulsets before compare them
          worder = 1
          use_percentage = False
          acceptable_difference = 0.01
  
          print("==============================")
          print(queryType)
          print("==============================")
  
          # https://github.com/BlazingDB/blazingsql/issues/1541
          queryId = "TEST_01"
          query = "select o_totalprice from orders where o_orderstatus = 'F' and o_orderdate <= '1992-01-31' and o_orderpriority IS NOT NULL and o_orderstatus IS NOT NULL and o_orderdate IS NOT NULL order by o_orderkey"
          # runTest.run_query(
          #     bc,
          #     spark,
          #     query,
          #     queryId,
          #     queryType,
          #     worder,
          #     "",
          #     acceptable_difference,
          #     use_percentage,
          #     fileSchemaType,
          #     query_spark=query,
          # )
  
          queryId = "TEST_02"
          query = """select c_nationkey, c_acctbal + 3 as c_acctbal_new
                      from customer where c_acctbal > 1000 and c_mktsegment = 'AUTOMOBILE' 
                      and c_nationkey IS NOT NULL and c_mktsegment IS NOT NULL"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          queryId = "TEST_03"
          query = """ select l.l_orderkey, l.l_linenumber from lineitem as l
                      inner join orders as o on l.l_orderkey = o.o_orderkey
                      and l.l_commitdate < o.o_orderdate
                      and l.l_receiptdate > o.o_orderdate
                      where o.o_orderdate <= '1992-01-31'
                      and o.o_orderpriority IS NOT NULL 
                      and o.o_orderstatus IS NOT NULL 
                      and o.o_orderdate IS NOT NULL"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          queryId = "TEST_04"
          query = """ select l_linenumber, l_shipmode, l_returnflag 
                      from lineitem 
                      where l_shipmode in ('AIR','FOB','MAIL','RAIL') and l_returnflag in ('A', 'N')
                      and l_shipmode IS NOT NULL
                      and l_linestatus IS NOT NULL
                      and l_returnflag IS NOT NULL
                      order by l_orderkey"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          # "nation", "part", "supplier"]
  
          queryId = "TEST_05"
          query = """select n_regionkey as rkey, n_nationkey from nation
                      where n_regionkey < 3 and n_nationkey > 5"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          if int(nRals) == 1:
              queryId = "TEST_06"
              query = """select p.p_partkey, p.p_mfgr
                          from part p
                          where p.p_type like '%STEEL'
                          and p.p_container IS NOT NULL"""
              runTest.run_query(
                  bc,
                  spark,
                  query,
                  queryId,
                  queryType,
                  worder,
                  "",
                  acceptable_difference,
                  use_percentage,
                  fileSchemaType,
                  query_spark=query,
              )
  
              queryId = "TEST_07"
              query = """select p_partkey, p_mfgr, p_container
                          from part
                          where p_size = 35 and p_container like 'WRAP%'
                          and p_container IS NOT NULL"""
              runTest.run_query(
                  bc,
                  spark,
                  query,
                  queryId,
                  queryType,
                  worder,
                  "",
                  acceptable_difference,
                  use_percentage,
                  fileSchemaType,
                  query_spark=query,
              )
  
              queryId = "TEST_08"
              query = """select count(s_suppkey), count(s_nationkey)
                          from supplier
                          where s_nationkey IS NOT NULL"""
              runTest.run_query(
                  bc,
                  spark,
                  query,
                  queryId,
                  queryType,
                  worder,
                  "",
                  acceptable_difference,
                  use_percentage,
                  fileSchemaType,
                  query_spark=query,
              )
  
          queryId = "TEST_09"
          query = """select n1.n_nationkey as supp_nation,
                      n2.n_nationkey as cust_nation,
                      l.l_extendedprice * l.l_discount
                      from supplier as s
                      inner join lineitem as l on s.s_suppkey = l.l_suppkey
                      inner join orders as o on o.o_orderkey = l.l_orderkey
                      inner join customer as c on c.c_custkey = o.o_custkey
                      inner join nation as n1 on s.s_nationkey = n1.n_nationkey
                      inner join nation as n2 on c.c_nationkey = n2.n_nationkey
                      where n1.n_nationkey = 1
                      and n2.n_nationkey = 2
                      and o.o_orderkey < 20
                      and o.o_orderdate <= '1992-01-31'
                      and o.o_orderpriority IS NOT NULL 
                      and o.o_orderstatus IS NOT NULL 
                      and o.o_orderdate IS NOT NULL
                      and c.c_nationkey IS NOT NULL
                      and c.c_mktsegment IS NOT NULL"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          queryId = "TEST_10"
          query = """ select s_name, s_address, s_nationkey
                      from supplier
                      where s_nationkey < 10
                      order by s_suppkey"""
          runTest.run_query(
              bc,
              spark,
              query,
              queryId,
              queryType,
              worder,
              "",
              acceptable_difference,
              use_percentage,
              fileSchemaType,
              query_spark=query,
          )
  
          if Settings.execution_mode == ExecutionMode.GENERATOR:
              print("==============================")
              break
  
file_path: blazingsql/tests/BlazingSQLTest/EndToEndTests/oldScripts/hiveFileTest.py
imports: from blazingsql import DataType
  from Configuration import ExecutionMode
  from Configuration import Settings
  from DataBase import createSchema
  from pynvml import nvmlInit
  from Runner import runTest
  from Utils import Execution, gpuMemory, init_context, skip_test, utilityHive
  import shutil
  import pandas
  import tempfile
label_desc: Use image node_id 1 for calling a global function with example usage: executionTestAuto(dask_client, spark, dir_data_file, bc, nRals) without return types