merge: Introduce schema for trace API (#88)

This pull request updates the OpenDC trace API to support proper specification 
of a schema of the tables exposed by the traces. This functionality makes it easier 
for the API consumer to understand the types exposed by the API.

## Implementation Notes :hammer_and_pick:

* Introduce type system for trace API
* Add benchmarks for odcvm trace format 
* Add benchmarks for Azure trace format
* Add conformance suite for OpenDC trace API 

## External Dependencies :four_leaf_clover:

* N/A

## Breaking API Changes :warning:

* Removal of typed `TableColumn`. Instead, `TableColumn` instances are now 
   used to describe the columns belonging to some table.
* `TableReader` and `TableWriter` do not support accessing arbitrary objects 
   anymore. Instead, only the types supported by the type system are exposed.

1 files changed, 91 insertions, 5 deletions

diff --git a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
index d2877d7c..d8729034 100644
--- a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
+++ b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
@@ -22,16 +22,24 @@
 
 package org.opendc.trace.calcite
 
+import io.mockk.every
+import io.mockk.mockk
 import org.apache.calcite.jdbc.CalciteConnection
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
+import org.opendc.trace.TableColumn
+import org.opendc.trace.TableColumnType
+import org.opendc.trace.TableReader
 import org.opendc.trace.Trace
+import org.opendc.trace.conv.TABLE_RESOURCES
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.sql.DriverManager
 import java.sql.ResultSet
 import java.sql.Statement
 import java.sql.Timestamp
+import java.time.Duration
+import java.time.Instant
 import java.util.*
 
 /**
@@ -41,11 +49,11 @@ class CalciteTest {
     /**
      * The trace to experiment with.
      */
-    private val trace = Trace.open(Paths.get("src/test/resources/trace"), format = "opendc-vm")
+    private val odcTrace = Trace.open(Paths.get("src/test/resources/trace"), format = "opendc-vm")
 
     @Test
     fun testResources() {
-        runQuery(trace, "SELECT * FROM trace.resources") { rs ->
+        runQuery(odcTrace, "SELECT * FROM trace.resources") { rs ->
             assertAll(
                 { assertTrue(rs.next()) },
                 { assertEquals("1019", rs.getString("id")) },
@@ -65,7 +73,7 @@ class CalciteTest {
 
     @Test
     fun testResourceStates() {
-        runQuery(trace, "SELECT * FROM trace.resource_states") { rs ->
+        runQuery(odcTrace, "SELECT * FROM trace.resource_states") { rs ->
             assertAll(
                 { assertTrue(rs.next()) },
                 { assertEquals("1019", rs.getString("id")) },
@@ -80,7 +88,7 @@ class CalciteTest {
 
     @Test
     fun testInterferenceGroups() {
-        runQuery(trace, "SELECT * FROM trace.interference_groups") { rs ->
+        runQuery(odcTrace, "SELECT * FROM trace.interference_groups") { rs ->
             assertAll(
                 { assertTrue(rs.next()) },
                 { assertArrayEquals(arrayOf("1019", "1023", "1052"), rs.getArray("members").array as Array<*>) },
@@ -92,7 +100,7 @@ class CalciteTest {
 
     @Test
     fun testComplexQuery() {
-        runQuery(trace, "SELECT max(cpu_usage) as max_cpu_usage, avg(cpu_usage) as avg_cpu_usage FROM trace.resource_states") { rs ->
+        runQuery(odcTrace, "SELECT max(cpu_usage) as max_cpu_usage, avg(cpu_usage) as avg_cpu_usage FROM trace.resource_states") { rs ->
             assertAll(
                 { assertTrue(rs.next()) },
                 { assertEquals(249.59993808, rs.getDouble("max_cpu_usage")) },
@@ -128,6 +136,84 @@ class CalciteTest {
         }
     }
 
+    @Test
+    fun testUUID() {
+        val trace = mockk<Trace>()
+        every { trace.tables } returns listOf(TABLE_RESOURCES)
+        every { trace.getTable(TABLE_RESOURCES)!!.columns } returns listOf(
+            TableColumn("id", TableColumnType.UUID)
+        )
+        every { trace.getTable(TABLE_RESOURCES)!!.newReader() } answers {
+            object : TableReader {
+                override fun nextRow(): Boolean = true
+
+                override fun resolve(name: String): Int {
+                    return when (name) {
+                        "id" -> 0
+                        else -> -1
+                    }
+                }
+
+                override fun isNull(index: Int): Boolean = false
+
+                override fun getBoolean(index: Int): Boolean {
+                    TODO("not implemented")
+                }
+
+                override fun getInt(index: Int): Int {
+                    TODO("not implemented")
+                }
+
+                override fun getLong(index: Int): Long {
+                    TODO("not implemented")
+                }
+
+                override fun getFloat(index: Int): Float {
+                    TODO("not implemented")
+                }
+
+                override fun getDouble(index: Int): Double {
+                    TODO("not implemented")
+                }
+
+                override fun getString(index: Int): String? {
+                    TODO("not implemented")
+                }
+
+                override fun getUUID(index: Int): UUID = UUID(1, 2)
+
+                override fun getInstant(index: Int): Instant? {
+                    TODO("not implemented")
+                }
+
+                override fun getDuration(index: Int): Duration? {
+                    TODO("not implemented")
+                }
+
+                override fun <T> getList(index: Int, elementType: Class<T>): List<T>? {
+                    TODO("not implemented")
+                }
+
+                override fun <T> getSet(index: Int, elementType: Class<T>): Set<T>? {
+                    TODO("not implemented")
+                }
+
+                override fun <K, V> getMap(index: Int, keyType: Class<K>, valueType: Class<V>): Map<K, V>? {
+                    TODO("not implemented")
+                }
+
+                override fun close() {}
+            }
+        }
+
+        runQuery(trace, "SELECT id FROM trace.resources") { rs ->
+            assertAll(
+                { assertTrue(rs.next()) },
+                { assertArrayEquals(byteArrayOf(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2), rs.getBytes("id")) },
+            )
+        }
+    }
+
     /**
      * Helper function to run statement for the specified trace.
      */