Revision control
++ #!/usr/bin/env python3
++ # Copyright (C) 2026 The Qt Company Ltd.
++ # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ import os
++ import sys
++ import pandas as pd
++ import json
++ import psycopg2
++ from io import StringIO
++
++ SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
++ INSERTION_SQL_PATH = os.path.join(SCRIPT_DIR, "insertion.sql")
++ RUN_DETAILS_INSERTION_SQL_PATH = os.path.join(SCRIPT_DIR, "insert_run_details.sql")
++ REVISIONS_MM_GROUPS_INSERTION_SQL_PATH = os.path.join(SCRIPT_DIR, "insert_revisions_mm_groups.sql")
++
++ def bulk_insert_results(conn, df):
++ '''
++ Inserts into staging table a bulk of results and then merges it into the main table.
++
++ :param conn: Connection to database using psycopg2.
++ :param df: Pandas dataframa containing the results of benchmark run.
++ '''
++ # Buffer is an in-memory text buffer which we fill with the df values, needed for copy_from.
++ buffer = StringIO()
++ df.to_csv(buffer, index=False, header=False)
++ buffer.seek(0) # Move cursor of the buffer back to the beginning.
++
++ with conn.cursor() as cur:
++ cur.execute("TRUNCATE TABLE staging_qml_results")
++ cur.copy_from(buffer, "staging_qml_results", sep=",", columns=df.columns) # Copies buffer into table
++ with open(INSERTION_SQL_PATH, "r") as f:
++ query = f.read()
++ cur.execute(query)
++
++ def insert_run_info(conn, branch, host, graphics_api, sha1_list):
++ '''
++ The insertion process:
++ 1. Store submodules and associate each with its sha1 in submodule_revisions.
++ 2. Look up the set of submodule_revision_ids in revisions_mm_groups.
++ 3. If no matching group exists, create a new group_id and insert the set.
++ 4. Insert branch, host, graphics API, and group_id into run_details_qml.
++
++ :param conn: psycopg2 database connection.
++ :param sha1_list: Comma-separated "module-sha1" pairs (e.g. ['qtbase-abc123,qtdeclarative-def456']).
++ '''
++ # Inserts a submodule if not found and returns its submodule_id
++ query_submodule = """ WITH inserted AS (
++ INSERT INTO submodules_qml (submodule)
++ SELECT %(submodule)s
++ WHERE NOT EXISTS (
++ SELECT 1 FROM submodules_qml WHERE submodule = %(submodule)s
++ )
++ RETURNING submodule_qml_id, submodule
++ )
++ SELECT submodule_qml_id, submodule
++ FROM
++ inserted
++ UNION ALL
++ SELECT
++ submodule_qml_id,
++ submodule
++ FROM
++ submodules_qml
++ WHERE
++ submodule = %(submodule)s;
++ """
++ # Inserts sha1 for a submodule if not found and returns its submodule_revision_id
++ query_revisions = """ WITH inserted AS (
++ INSERT INTO submodule_revisions (submodule_qml_id, sha1)
++ SELECT %(submodule_qml_id)s, %(sha1)s
++ WHERE NOT EXISTS (
++ SELECT 1 FROM submodule_revisions
++ WHERE
++ submodule_qml_id = %(submodule_qml_id)s
++ AND
++ sha1 = %(sha1)s
++ )
++ RETURNING submodule_revision_id
++ )
++ SELECT
++ submodule_revision_id
++ FROM
++ inserted
++ UNION ALL
++ SELECT
++ submodule_revision_id
++ FROM
++ submodule_revisions
++ WHERE
++ submodule_qml_id = %(submodule_qml_id)s
++ AND
++ sha1 = %(sha1)s
++ """
++
++ rev_ids = []
++ with conn.cursor() as cur:
++ # Split elements of sha1_list into module and sha
++ for item in sha1_list[0].split(","):
++ module, sha = item.split("-", 1)
++ module = module.strip(" '")
++ sha = sha.strip(" '")
++
++ cur.execute(query_submodule, {"submodule": module})
++ module_id = cur.fetchone()[0]
++
++ cur.execute(query_revisions, {"submodule_qml_id" : module_id, "sha1" : sha})
++ rev_ids.append(cur.fetchone()[0])
++
++ with open(REVISIONS_MM_GROUPS_INSERTION_SQL_PATH, "r") as f:
++ query = f.read()
++ cur.execute(query, {"rev_ids": rev_ids})
++ group_id = cur.fetchone()[0]
++
++ data = {
++ "host": host,
++ "graphics_api": graphics_api,
++ "branch": branch,
++ "group_id": group_id
++ }
++
++ with open(RUN_DETAILS_INSERTION_SQL_PATH, "r") as f:
++ query = f.read()
++
++ cur.execute(query, data)
++ run_details_id = cur.fetchone()[0]
++
++ return run_details_id
++
++ def submit_output(filename, branch, host_name, sha1_list):
++ print("Loading %s" % filename)
++
++ with open(filename, "r") as f:
++ tree = json.load(f)
++
++ if 'vulkan' in tree.keys():
++ graphics_api = 'vulkan'
++ else:
++ graphics_api = 'opengl'
++
++ rows = []
++ # Retrieve benchmark values from filename
++ for key in tree:
++ if key.endswith(".qml"):
++ mean = 0
++ standardDeviation = 0
++ coefficientOfVariation = 0
++
++ # key is benchmarks/auto/<suite>/benchmark.qml
++ # dirname will trim off the last part and then we
++ # retrieve the suite. Does not differentiate
++ # between creation/quick.image and creation/quick.item
++ # and saves both under creation.
++ benchmarkSuite = os.path.dirname(key)
++ prefix = "benchmarks/auto/"
++ cutPos = benchmarkSuite.find(prefix)
++ if cutPos != -1:
++ benchmarkSuite = benchmarkSuite[cutPos + len(prefix):]
++ benchmarkSuite = benchmarkSuite.lstrip("/").split("/", 1)[0]
++
++ try:
++ mean = tree[key]["average"]
++ standardDeviation = tree[key]["standard-deviation-all-samples"]
++ coefficientOfVariation = tree[key]["coefficient-of-variation"]
++ iterations = tree[key]["samples-in-average"]
++ except:
++ # Catch exceptions in order to keep other results and
++ # be able to upload them.
++ print("Test %s was malformed (empty run?)" % key, file=sys.stderr)
++ # Skip this iteration as there is no result
++ continue
++
++ basename = key.split("/")[-1]
++
++ rows.append({
++ "benchmark": basename,
++ "suite": benchmarkSuite,
++ "mean": mean,
++ "std_dev": standardDeviation,
++ "cov": coefficientOfVariation,
++ "iterations": iterations
++ })
++ # If no valid benchmarks were found, we should not proceed with database insertion.
++ if not rows:
++ print("No valid benchmark results found in the file. Aborting upload.", file=sys.stderr)
++ return
++
++ df = pd.DataFrame(rows)
++
++ conn_info = f'''host=benchmark-postgres.ci.qt.io
++ dbname=benchmarks
++ user={os.environ["TIMESCALEDBUSER"]}
++ password={os.environ["TIMESCALEDBPASSWORD"]}
++ port=5432
++ '''
++ n = len(df)
++ inserted = 0
++ batch_size = n if n < 25000 else 25000
++
++ with psycopg2.connect(conn_info) as conn:
++ run_details = insert_run_info(conn, branch, host_name, graphics_api, sha1_list)
++ df["run_details_qml_id"] = run_details
++
++ # Insert benchmark results in batches
++ for start in range(0, n, batch_size):
++ batch = df.iloc[start:start+batch_size]
++
++ bulk_insert_results(conn, batch)
++
++ inserted += batch.shape[0]
++
++ with conn.cursor() as cur:
++ cur.execute("TRUNCATE TABLE staging_qml_results")
++
++ print(f"Successfully inserted {inserted} rows")
++
++ if __name__ == "__main__":
++ import argparse
++ parser = argparse.ArgumentParser()
++ parser.add_argument("filename", help = "The .json file to post")
++ parser.add_argument("branch", help = "The Qt branch tested")
++ parser.add_argument("host_name", help = "Our unique hardware ID (e.g. linux_imx6_eskil)")
++ parser.add_argument("sha1", nargs="+", help = "Comma-separated module SHA-1 pairs in format "
++ "'module-sha1,module-sha1' (e.g. 'qtbase-abc123,qtdeclarative-def456')")
++ args = parser.parse_args(sys.argv[1:])
++
++ submit_output(args.filename, args.branch, args.host_name, args.sha1)