run_benchmark_import Namespace Reference

Functions
def	get_connection
def	json_format_handler

Variables
tuple	parser = ArgumentParser()
tuple	optional = parser._action_groups.pop()
tuple	required = parser.add_argument_group("required arguments")
string	action = "store_true"
string	help = "Suppress script outuput "
string	dest = "passwd"
string	default = "HyperInteractive"
	type = int,
tuple	args = parser.parse_args()
	source_db_user = args.user
	source_db_passwd = args.passwd
	source_db_server = args.server
	source_db_port = args.port
	source_db_name = args.name
	label = args.label
	import_file = args.import_file
	table_schema_file = args.table_schema_file
	import_table_name = args.import_table_name
	import_query_template_file = args.import_query_template_file
	no_drop_table_before = args.no_drop_table_before
	no_drop_table_after = args.no_drop_table_after
	import_test_name = args.import_test_name
	machine_name = args.machine_name
	machine_uname = args.machine_uname
tuple	destinations = args.destination.split(",")
	valid_destination_set = True
	dest_db_user = args.dest_user
	dest_db_passwd = args.dest_passwd
	dest_db_server = args.dest_server
	dest_db_port = args.dest_port
	dest_db_name = args.dest_name
	dest_table = args.dest_table
	dest_table_schema_file = args.dest_table_schema_file
	output_file_json = args.output_file_json
	output_file_jenkins = args.output_file_jenkins
tuple	con
tuple	run_guid = str(uuid.uuid4())
tuple	run_timestamp = datetime.datetime.now()
tuple	run_connection = str(con)
string	run_driver = ""
tuple	run_version = con._client.get_version()
tuple	run_version_short = run_version.split("-")
tuple	conn_machine_name = re.search(r"@(.*?):", run_connection)
tuple	local_uname = os.uname()
	run_machine_name = machine_name
	run_machine_uname = machine_uname
tuple	create_table_sql = table_schema.read()
tuple	res = con.execute(create_table_sql)
tuple	import_query = import_query_template.read()
tuple	start_time = timeit.default_timer()
tuple	end_time = timeit.default_timer()
tuple	query_elapsed_time = round(((end_time - start_time) * 1000), 1)
	execution_time = res._result.execution_time_ms
tuple	connect_time = round((query_elapsed_time - execution_time), 2)
tuple	res_output = str(res.fetchall()[0])
tuple	rows_loaded = re.search(r"Loaded: (.*?) recs, R", res_output)
tuple	rows_rejected = re.search(r"Rejected: (.*?) recs i", res_output)
dictionary	result
tuple	result_json = json.dumps(result, default=json_format_handler, indent=2)
tuple	results_df = pandas.DataFrame(result, index=[0])
tuple	dest_con
tuple	tables = dest_con.get_tables()
tuple	file_json_open = open(output_file_json, "w")
tuple	jenkins_bench_json
tuple	file_jenkins_open = open(output_file_jenkins, "w")

Function Documentation

def run_benchmark_import.get_connection

(

kwargs

)

  Connects to the db using pymapd
  https://pymapd.readthedocs.io/en/latest/usage.html#connecting

  Kwargs:
    db_user(str): DB username
    db_passwd(str): DB password
    db_server(str): DB host
    db_port(int): DB port
    db_name(str): DB name

  Returns:
    con(class): Connection class
    False(bool): The connection failed. Exception should be logged.

Definition at line 15 of file run_benchmark_import.py.

def get_connection(**kwargs):
    """
      Connects to the db using pymapd
      https://pymapd.readthedocs.io/en/latest/usage.html#connecting

      Kwargs:
        db_user(str): DB username
        db_passwd(str): DB password
        db_server(str): DB host
        db_port(int): DB port
        db_name(str): DB name

      Returns:
        con(class): Connection class
        False(bool): The connection failed. Exception should be logged.
    """
    try:
        logging.debug("Connecting to mapd db...")
        con = pymapd.connect(
            user=kwargs["db_user"],
            password=kwargs["db_passwd"],
            host=kwargs["db_server"],
            port=kwargs["db_port"],
            dbname=kwargs["db_name"],
        )
        logging.info("Succesfully connected to mapd db")
        return con
    except (pymapd.exceptions.OperationalError, pymapd.exceptions.Error):
        logging.exception("Error connecting to database.")
        return False