From 5864cbcbfe2eb8c36ca05c3a39c7e5916aeecaec Mon Sep 17 00:00:00 2001 From: Dante Niewenhuis Date: Tue, 5 Mar 2024 13:23:57 +0100 Subject: Updated package versions, updated web server tests. (#207) * Updated all package versions including kotlin. Updated all web-server tests to run. * Changed the java version of the tests. OpenDC now only supports java 19. * small update * test update * new update * updated docker version to 19 * updated docker version to 19 --- .../opendc/trace/calcite/TraceReaderEnumerator.kt | 8 ++- .../org/opendc/trace/calcite/TraceSchemaFactory.kt | 6 +- .../kotlin/org/opendc/trace/calcite/TraceTable.kt | 23 ++++++-- .../org/opendc/trace/calcite/TraceTableModify.kt | 67 +++++++++++++--------- .../opendc/trace/calcite/TraceTableModifyRule.kt | 14 +++-- .../kotlin/org/opendc/trace/calcite/CalciteTest.kt | 59 ++++++++++++------- .../opendc/trace/calcite/TraceSchemaFactoryTest.kt | 2 +- 7 files changed, 117 insertions(+), 62 deletions(-) (limited to 'opendc-trace/opendc-trace-calcite/src') diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt index 74bd188b..eed52ab3 100644 --- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt +++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt @@ -36,7 +36,7 @@ import java.util.concurrent.atomic.AtomicBoolean internal class TraceReaderEnumerator( private val reader: TableReader, private val columns: List, - private val cancelFlag: AtomicBoolean + private val cancelFlag: AtomicBoolean, ) : Enumerator { private val columnIndices = columns.map { reader.resolve(it.name) }.toIntArray() private var current: E? = null @@ -80,7 +80,11 @@ internal class TraceReaderEnumerator( return res } - private fun convertColumn(reader: TableReader, column: TableColumn, columnIndex: Int): Any? { + private fun convertColumn( + reader: TableReader, + column: TableColumn, + columnIndex: Int, + ): Any? { return when (column.type) { is TableColumnType.Boolean -> reader.getBoolean(columnIndex) is TableColumnType.Int -> reader.getInt(columnIndex) diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt index 3c6badc8..cbf7ec43 100644 --- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt +++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt @@ -36,7 +36,11 @@ import java.nio.file.Paths * This factory allows users to include a schema that references a trace in a `model.json` file. */ public class TraceSchemaFactory : SchemaFactory { - override fun create(parentSchema: SchemaPlus, name: String, operand: Map): Schema { + override fun create( + parentSchema: SchemaPlus, + name: String, + operand: Map, + ): Schema { val base = operand[ModelHandler.ExtraOperand.BASE_DIRECTORY.camelName] as File? val pathParam = requireNotNull(operand["path"]) { "Trace path not specified" } as String val path = if (base != null) File(base, pathParam).toPath() else Paths.get(pathParam) diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt index 2dd02710..e74d2ee8 100644 --- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt +++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt @@ -71,7 +71,11 @@ internal class TraceTable(private val table: org.opendc.trace.Table) : return rowType } - override fun scan(root: DataContext, filters: MutableList, projects: IntArray?): Enumerable> { + override fun scan( + root: DataContext, + filters: MutableList, + projects: IntArray?, + ): Enumerable> { // Filters are currently not supported by the OpenDC trace API. By keeping the filters in the list, Calcite // assumes that they are declined and will perform the filters itself. @@ -130,14 +134,18 @@ internal class TraceTable(private val table: org.opendc.trace.Table) : return rowCount } - override fun asQueryable(queryProvider: QueryProvider, schema: SchemaPlus, tableName: String): Queryable { + override fun asQueryable( + queryProvider: QueryProvider, + schema: SchemaPlus, + tableName: String, + ): Queryable { return object : AbstractTableQueryable(queryProvider, schema, this@TraceTable, tableName) { override fun enumerator(): Enumerator { val cancelFlag = AtomicBoolean(false) return TraceReaderEnumerator( this@TraceTable.table.newReader(), this@TraceTable.table.columns, - cancelFlag + cancelFlag, ) } @@ -155,7 +163,7 @@ internal class TraceTable(private val table: org.opendc.trace.Table) : operation: TableModify.Operation, updateColumnList: MutableList?, sourceExpressionList: MutableList?, - flattened: Boolean + flattened: Boolean, ): TableModify { cluster.planner.addRule(TraceTableModifyRule.DEFAULT.toRule()) @@ -166,7 +174,7 @@ internal class TraceTable(private val table: org.opendc.trace.Table) : operation, updateColumnList, sourceExpressionList, - flattened + flattened, ) } @@ -184,7 +192,10 @@ internal class TraceTable(private val table: org.opendc.trace.Table) : return typeFactory.createStructType(types, names) } - private fun mapType(typeFactory: JavaTypeFactory, type: TableColumnType): RelDataType { + private fun mapType( + typeFactory: JavaTypeFactory, + type: TableColumnType, + ): RelDataType { return when (type) { is TableColumnType.Boolean -> typeFactory.createSqlType(SqlTypeName.BOOLEAN) is TableColumnType.Int -> typeFactory.createSqlType(SqlTypeName.INTEGER) diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt index cc23854f..eedff00d 100644 --- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt +++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt @@ -59,7 +59,7 @@ internal class TraceTableModify( operation: Operation, updateColumnList: List?, sourceExpressionList: List?, - flattened: Boolean + flattened: Boolean, ) : TableModify(cluster, traitSet, table, schema, input, operation, updateColumnList, sourceExpressionList, flattened), EnumerableRel { init { @@ -67,7 +67,10 @@ internal class TraceTableModify( table.unwrap(ModifiableTable::class.java) ?: throw AssertionError() // TODO: user error in validator } - override fun copy(traitSet: RelTraitSet, inputs: List?): RelNode { + override fun copy( + traitSet: RelTraitSet, + inputs: List?, + ): RelNode { return TraceTableModify( cluster, traitSet, @@ -77,40 +80,48 @@ internal class TraceTableModify( operation, updateColumnList, sourceExpressionList, - isFlattened + isFlattened, ) } - override fun computeSelfCost(planner: RelOptPlanner, mq: RelMetadataQuery?): RelOptCost { + override fun computeSelfCost( + planner: RelOptPlanner, + mq: RelMetadataQuery?, + ): RelOptCost { // Prefer this plan compared to the standard EnumerableTableModify. return super.computeSelfCost(planner, mq)!!.multiplyBy(.1) } - override fun implement(implementor: EnumerableRelImplementor, pref: Prefer): EnumerableRel.Result { + override fun implement( + implementor: EnumerableRelImplementor, + pref: Prefer, + ): EnumerableRel.Result { val builder = BlockBuilder() val result = implementor.visitChild(this, 0, getInput() as EnumerableRel, pref) val childExp = builder.append("child", result.block) - val convertedChildExpr = if (getInput().rowType != rowType) { - val typeFactory = cluster.typeFactory as JavaTypeFactory - val format = EnumerableTableScan.deduceFormat(table) - val physType = PhysTypeImpl.of(typeFactory, table.rowType, format) - val childPhysType = result.physType - val o = Expressions.parameter(childPhysType.javaRowType, "o") - val expressionList = List(childPhysType.rowType.fieldCount) { i -> - childPhysType.fieldReference(o, i, physType.getJavaFieldType(i)) - } + val convertedChildExpr = + if (getInput().rowType != rowType) { + val typeFactory = cluster.typeFactory as JavaTypeFactory + val format = EnumerableTableScan.deduceFormat(table) + val physType = PhysTypeImpl.of(typeFactory, table.rowType, format) + val childPhysType = result.physType + val o = Expressions.parameter(childPhysType.javaRowType, "o") + val expressionList = + List(childPhysType.rowType.fieldCount) { i -> + childPhysType.fieldReference(o, i, physType.getJavaFieldType(i)) + } - builder.append( - "convertedChild", - Expressions.call( - childExp, - BuiltInMethod.SELECT.method, - Expressions.lambda>(physType.record(expressionList), o) + builder.append( + "convertedChild", + Expressions.call( + childExp, + BuiltInMethod.SELECT.method, + Expressions.lambda>(physType.record(expressionList), o), + ), ) - ) - } else { - childExp - } + } else { + childExp + } if (!isInsert) { throw UnsupportedOperationException("Deletion and update not supported") @@ -126,10 +137,10 @@ internal class TraceTableModify( Long::class.java, expression, INSERT_METHOD, - convertedChildExpr - ) - ) - ) + convertedChildExpr, + ), + ), + ), ) val rowFormat = if (pref === Prefer.ARRAY) JavaRowFormat.ARRAY else JavaRowFormat.SCALAR diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt index 7572e381..9c560984 100644 --- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt +++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt @@ -52,14 +52,20 @@ internal class TraceTableModifyRule(config: Config) : ConverterRule(config) { modify.operation, modify.updateColumnList, modify.sourceExpressionList, - modify.isFlattened + modify.isFlattened, ) } companion object { /** Default configuration. */ - val DEFAULT: Config = Config.INSTANCE - .withConversion(LogicalTableModify::class.java, Convention.NONE, EnumerableConvention.INSTANCE, "TraceTableModificationRule") - .withRuleFactory { config: Config -> TraceTableModifyRule(config) } + val DEFAULT: Config = + Config.INSTANCE + .withConversion( + LogicalTableModify::class.java, + Convention.NONE, + EnumerableConvention.INSTANCE, + "TraceTableModificationRule", + ) + .withRuleFactory { config: Config -> TraceTableModifyRule(config) } } } 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 64bb31c9..93b15e5f 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 @@ -71,7 +71,7 @@ class CalciteTest { { assertEquals("1052", rs.getString("id")) }, { assertTrue(rs.next()) }, { assertEquals("1073", rs.getString("id")) }, - { assertFalse(rs.next()) } + { assertFalse(rs.next()) }, ) } } @@ -86,7 +86,7 @@ class CalciteTest { { assertEquals(300000, rs.getLong("duration")) }, { assertEquals(0.0, rs.getDouble("cpu_usage")) }, { assertTrue(rs.next()) }, - { assertEquals("1019", rs.getString("id")) } + { assertEquals("1019", rs.getString("id")) }, ) } } @@ -98,7 +98,7 @@ class CalciteTest { { assertTrue(rs.next()) }, { assertArrayEquals(arrayOf("1019", "1023", "1052"), rs.getArray("members").array as Array<*>) }, { assertEquals(0.0, rs.getDouble("target")) }, - { assertEquals(0.8830158730158756, rs.getDouble("score")) } + { assertEquals(0.8830158730158756, rs.getDouble("score")) }, ) } } @@ -109,7 +109,7 @@ class CalciteTest { assertAll( { assertTrue(rs.next()) }, { assertEquals(249.59993808, rs.getDouble("max_cpu_usage")) }, - { assertEquals(5.387240309118493, rs.getDouble("avg_cpu_usage")) } + { assertEquals(5.387240309118493, rs.getDouble("avg_cpu_usage")) }, ) } } @@ -120,12 +120,13 @@ class CalciteTest { val newTrace = Trace.create(tmp, "opendc-vm") runStatement(newTrace) { stmt -> - val count = stmt.executeUpdate( - """ - INSERT INTO trace.resources (id, start_time, stop_time, cpu_count, cpu_capacity, mem_capacity) - VALUES (1234, '2013-08-12 13:35:46.0', '2013-09-11 13:39:58.0', 1, 2926.0, 1024.0) - """.trimIndent() - ) + val count = + stmt.executeUpdate( + """ + INSERT INTO trace.resources (id, start_time, stop_time, cpu_count, cpu_capacity, mem_capacity) + VALUES (1234, '2013-08-12 13:35:46.0', '2013-09-11 13:39:58.0', 1, 2926.0, 1024.0) + """.trimIndent(), + ) assertEquals(1, count) } @@ -136,7 +137,7 @@ class CalciteTest { { assertEquals(1, rs.getInt("cpu_count")) }, { assertEquals(Timestamp.valueOf("2013-08-12 13:35:46.0"), rs.getTimestamp("start_time")) }, { assertEquals(2926.0, rs.getDouble("cpu_capacity")) }, - { assertEquals(1024.0, rs.getDouble("mem_capacity")) } + { assertEquals(1024.0, rs.getDouble("mem_capacity")) }, ) } } @@ -145,9 +146,10 @@ class CalciteTest { fun testUUID() { val trace = mockk() every { trace.tables } returns listOf(TABLE_RESOURCES) - every { trace.getTable(TABLE_RESOURCES)!!.columns } returns listOf( - TableColumn("id", TableColumnType.UUID) - ) + 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 @@ -195,15 +197,25 @@ class CalciteTest { TODO("not implemented") } - override fun getList(index: Int, elementType: Class): List? { + override fun getList( + index: Int, + elementType: Class, + ): List? { TODO("not implemented") } - override fun getSet(index: Int, elementType: Class): Set? { + override fun getSet( + index: Int, + elementType: Class, + ): Set? { TODO("not implemented") } - override fun getMap(index: Int, keyType: Class, valueType: Class): Map? { + override fun getMap( + index: Int, + keyType: Class, + valueType: Class, + ): Map? { TODO("not implemented") } @@ -214,7 +226,7 @@ class CalciteTest { 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")) } + { assertArrayEquals(byteArrayOf(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2), rs.getBytes("id")) }, ) } } @@ -222,7 +234,11 @@ class CalciteTest { /** * Helper function to run statement for the specified trace. */ - private fun runQuery(trace: Trace, query: String, block: (ResultSet) -> Unit) { + private fun runQuery( + trace: Trace, + query: String, + block: (ResultSet) -> Unit, + ) { runStatement(trace) { stmt -> val rs = stmt.executeQuery(query) rs.use { block(rs) } @@ -232,7 +248,10 @@ class CalciteTest { /** * Helper function to run statement for the specified trace. */ - private fun runStatement(trace: Trace, block: (Statement) -> Unit) { + private fun runStatement( + trace: Trace, + block: (Statement) -> Unit, + ) { val info = Properties() info.setProperty("lex", "JAVA") val connection = DriverManager.getConnection("jdbc:calcite:", info).unwrap(CalciteConnection::class.java) diff --git a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt index 735cedce..eb4bc769 100644 --- a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt +++ b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt @@ -48,7 +48,7 @@ class TraceSchemaFactoryTest { { assertEquals("1019", rs.getString("id")) }, { assertEquals(1, rs.getInt("cpu_count")) }, { assertEquals(Timestamp.valueOf("2013-08-12 13:40:46.0"), rs.getTimestamp("start_time")) }, - { assertEquals(181352.0, rs.getDouble("mem_capacity")) } + { assertEquals(181352.0, rs.getDouble("mem_capacity")) }, ) } finally { rs.close() -- cgit v1.2.3