sumolib.scenario.runsdb

  1# Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
  2# Copyright (C) 2012-2026 German Aerospace Center (DLR) and others.
  3# This program and the accompanying materials are made available under the
  4# terms of the Eclipse Public License 2.0 which is available at
  5# https://www.eclipse.org/legal/epl-2.0/
  6# This Source Code may also be made available under the following Secondary
  7# Licenses when the conditions for such availability set forth in the Eclipse
  8# Public License 2.0 are satisfied: GNU General Public License, version 2
  9# or later which is available at
 10# https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
 11# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
 12
 13# @file    runsdb.py
 14# @author  Daniel Krajzewicz
 15# @date    2014-07-21
 16
 17
 18from __future__ import absolute_import
 19import sqlite3
 20import os
 21
 22
 23class RunsDB:
 24
 25    def __init__(self):
 26        self.conn = None
 27        self.cursor = None
 28        # !!! if an old db is opened to be extended, this should be read from the db
 29        self.run = -1
 30
 31    def buildDB(self, dbName="results.db", deletePrior=True):
 32        if deletePrior and os.path.exists(dbName):
 33            os.remove(dbName)
 34        self.conn = sqlite3.connect(dbName)
 35        self.cursor = self.conn.cursor()
 36        self.cursor.execute(
 37            'CREATE TABLE run (id integer, key text, value text)')
 38        self.cursor.execute(
 39            'CREATE TABLE result (runID integer, denominator integer, key text, value real)')
 40        self.cursor.execute(
 41            'CREATE TABLE timed_result (runID integer, denominator integer, aib real, aie real, key text, value real)')
 42        self.conn.commit()
 43        self.run = 0
 44
 45    def open(self, dbName="results.db"):
 46        self.conn = sqlite3.connect(dbName)
 47        self.cursor = self.conn.cursor()
 48        self.cursor.execute("SELECT MAX(id) FROM run")
 49        v = self.cursor.fetchall()
 50        if len(v) != 0 and v[0][0] is not None:
 51            self.run = v[0][0] + 1
 52        else:
 53            self.run = 0
 54
 55    def addRun(self, scenario, kvDesc):
 56        if self.run < 0:
 57            raise RuntimeError("Database was not initialised")
 58        self.run = self.run + 1
 59        cid = self.run - 1
 60        for k in kvDesc:
 61            self.cursor.execute(
 62                "INSERT INTO run VALUES (?,?,?)", (cid, k, kvDesc[k]))
 63        return cid
 64
 65    def addResult(self, runID, denominator, key, value):
 66        self.cursor.execute(
 67            "INSERT INTO result VALUES (?,?,?,?)", (runID, denominator, key, value))
 68        self.conn.commit()
 69
 70    def addTimedResult(self, runID, denominator, aib, aie, key, value):
 71        self.cursor.execute(
 72            "INSERT INTO timed_result VALUES (?,?,?,?,?,?)", (runID, denominator, aib, aie, key, value))
 73        self.conn.commit()
 74
 75    def addResults(self, results):
 76        self.cursor.executemany("INSERT INTO result VALUES (?,?,?,?)", results)
 77        self.conn.commit()
 78
 79    def addTimedResults(self, results):
 80        self.cursor.executemany(
 81            "INSERT INTO timed_result VALUES (?,?,?,?,?,?)", results)
 82        self.conn.commit()
 83
 84    def toList(self, what):
 85        ret = []
 86        for r in what:
 87            ret.append(r[0])
 88        return ret
 89
 90    def getRunIDs(self):
 91        self.cursor.execute("SELECT DISTINCT id FROM run")
 92        return self.toList(self.cursor.fetchall())
 93
 94    def getMatchingRunIDs(self, key, value):
 95        self.cursor.execute(
 96            "SELECT DISTINCT id FROM run WHERE key=? AND value=?;", (key, value))
 97        return self.toList(self.cursor.fetchall())
 98
 99    def getRunsData(self, runs=None):
100        if runs is None:
101            runs = self.getRunIDs()
102        ret = {}
103        for r in runs:
104            ret[r] = {}
105            for row in self.cursor.execute("SELECT id FROM run WHERE id=?", (r)):
106                ret[r][row[1]] = row[2]
107        return ret
108
109    def getRunID(self, kvMap):
110        stmt = ""
111        params = []
112        for k in kvMap:
113            if len(stmt) != 0:
114                stmt = stmt + " AND "
115            else:
116                stmt = stmt + " WHERE "
117            stmt = stmt + "id IN (SELECT id FROM run WHERE key=? AND value=?)"
118            params.extend([k, kvMap[k]])
119        self.cursor.execute("SELECT DISTINCT id FROM run %s;" % stmt, params)
120        return self.toList(self.cursor.fetchall())
121
122    """
123  Returns a map:
124    runID->denominator->measure->value
125  """
126
127    def fetchResults(self, runs=None, measure=None, denominator=None):
128        if runs is None:
129            runs = self.getRunIDs()
130        ret = {}
131        for r in runs:
132            ret[r] = {}
133            if measure is None:
134                i = self.cursor.execute(
135                    "SELECT * FROM result WHERE runID=?", (r,))
136            else:
137                if denominator is None:
138                    i = self.cursor.execute(
139                        "SELECT * FROM result WHERE runID=? AND key=?", (r, measure))
140                else:
141                    i = self.cursor.execute(
142                        "SELECT * FROM result WHERE runID=? AND key=? AND denominator=?", (r, measure, denominator))
143            for row in i:
144                if row[1] not in ret[r]:
145                    ret[r][row[1]] = {}
146                if row[2] in ret[r][row[1]]:
147                    raise RuntimeError("set twice!!")
148                ret[r][row[1]][row[2]] = row[3]
149        return ret
150
151    def getMeasures(self):
152        self.cursor.execute("SELECT DISTINCT key FROM result")
153        return self.toList(self.cursor.fetchall())
154
155    def getDenominators(self):
156        self.cursor.execute("SELECT DISTINCT denominator FROM result")
157        return self.toList(self.cursor.fetchall())
158
159    def getNamedRunAttribute(self, attr):
160        self.cursor.execute(
161            "SELECT DISTINCT value FROM run WHERE key=?;", (attr,))
162        return self.toList(self.cursor.fetchall())
163
164    def getNamedAttributeFromRun(self, rid, key):
165        self.cursor.execute(
166            "SELECT DISTINCT value FROM run WHERE id=? and key=?;", (rid, key))
167        return self.toList(self.cursor.fetchall())
168
169    def close(self):
170        self.conn.close()