code: def create_tables(bc, dir_data_lc, fileSchemaType, **kwargs):
      ext = get_extension(fileSchemaType)
  
      tables = kwargs.get("tables", tpchTables)
      tables = list(set(tables) & set(tableNames))
      table_names = kwargs.get("table_names", tables)
      bool_orders_index = (
          tables.index("bool_orders") if "bool_orders" in tables else -1
      )
      interval_table_index = (
          tables.index("interval_table")
          if "interval_table" in tables
          else -1
      )
  
      testsWithNulls = Settings.data["RunSettings"]["testsWithNulls"]
  
      if tables[0] in smilesTables:
          dir_data_lc = dir_data_lc + "smiles/"
      else:
          if testsWithNulls == "true":
              dir_data_lc = dir_data_lc + "tpch-with-nulls/"
          else:
              dir_data_lc = dir_data_lc + "tpch/"
  
      for i, table in enumerate(tables):
          # using wildcard, note the _ after the table name
          # (it will avoid collisions)
          table_files = ("%s/%s_[0-9]*.%s") % (dir_data_lc, table, ext)
          if (
              fileSchemaType == DataType.CSV
              or fileSchemaType == DataType.JSON
          ):
              bool_orders_flag = False
              interval_table_flag = False
  
              if i == bool_orders_index:
                  bool_orders_flag = True
  
              if i == interval_table_index:
                  interval_table_index = True
  
              dtypes = get_dtypes(
                  table, bool_orders_flag, interval_table_index
              )
              col_names = get_column_names(
                  table, bool_orders_flag, interval_table_index
              )
              bc.create_table(
                  table_names[i],
                  table_files,
                  delimiter="|",
                  dtype=dtypes,
                  names=col_names,
              )
          elif fileSchemaType == DataType.CUDF:
              bool_column = bool_orders_index != -1
              interval_column = interval_table_index != -1
              gdf = read_data(
                  table, dir_data_lc, bool_column, interval_column
              )
              bc.create_table(table_names[i], gdf)
          elif fileSchemaType == DataType.DASK_CUDF:
              nRals = Settings.data["RunSettings"]["nRals"]
              num_partitions = nRals
              bool_column = bool_orders_index != -1
              interval_column = interval_table_index != -1
              gdf = read_data(
                  table, dir_data_lc, bool_column, interval_column
              )
              ds = dask_cudf.from_cudf(gdf, npartitions=num_partitions)
              bc.create_table(table_names[i], ds)
          # elif fileSchemaType == DataType.DASK_CUDF:
          #     bool_column = bool_orders_index != -1
          #     table_files = ("%s/%s_[0-9]*.%s") % (dir_data_lc, table,
          #                                                       'parquet')
          #     dask_df = dask_cudf.read_parquet(table_files)
          #     dask_df = bc.unify_partitions(dask_df)
          #     t = bc.create_table(table, dask_df)
          elif fileSchemaType in [
              DataType.MYSQL,
              DataType.POSTGRESQL,
              DataType.SQLITE,
          ]:
              sql_table_filter_map = kwargs.get(
                  "sql_table_filter_map", {}
              )
              sql_table_batch_size_map = kwargs.get(
                  "sql_table_batch_size_map", {}
              )
              sql = kwargs.get("sql_connection", None)
  
              from_sql = SQLEngineStringDataTypeMap[fileSchemaType]
              sql_hostname = sql.hostname
              sql_port = sql.port
              sql_username = sql.username
              sql_password = sql.password
              sql_schema = sql.schema
              sql_table_filter = ""
              sql_table_batch_size = 1000
  
              if table in sql_table_filter_map:
                  sql_table_filter = sql_table_filter_map[table]
              if table in sql_table_batch_size_map:
                  sql_table_batch_size = sql_table_batch_size_map[table]
  
              bc.create_table(
                  table_names[i],
                  table,
                  from_sql=from_sql,
                  hostname=sql_hostname,
                  port=sql_port,
                  username=sql_username,
                  password=sql_password,
                  database=sql_schema,
                  table_filter=sql_table_filter,
                  table_batch_size=sql_table_batch_size,
              )
          else:
              bc.create_table(table_names[i], table_files)
  
imports: import os
  import re
  import tempfile
  from collections import OrderedDict
  from os import listdir
  from os.path import isdir
  import glob
  from enum import IntEnum, unique
  import cudf
  import dask_cudf
  import numpy
  import pandas
  import pyblazing
  from blazingsql import DataType
  from pyhive import hive
  from Configuration import Settings
  from DemoTest.chronometer import Chronometer
label_desc: Use image node_id 29 for calling a global function with example usage: create_tables(bc, dir_data_lc, fileSchemaType) without return types