add accumulator, first impl and its test

physical-plan/src/main/kotlin/expressions/AggregateExpression.kt

@@ -0,0 +1,11 @@
+package io.hqew.kquery.physical.expressions
+
+interface AggregateExpression {
+    fun inputExpression(): Expression
+    fun createAccumulator(): Accumulator
+}
+
+interface Accumulator{
+    fun accumulate(value: Any?)
+    fun finalValue() : Any?
+}

physical-plan/src/main/kotlin/expressions/BooleanExpression.kt

@@ -160,8 +160,8 @@ private fun toString(v: Any?): String {
 
 private fun toBool(v: Any?): Boolean {
     when (v) {
-        is Boolean -> v == true
-        is Number -> v == 1
+        is Boolean -> return v == true
+        is Number -> return v == 1
         else -> throw IllegalStateException()
     }
 }

physical-plan/src/main/kotlin/expressions/MaxExpression.kt

@@ -0,0 +1,42 @@
+package io.hqew.kquery.physical.expressions
+
+class MaxExpression(private val expr: Expression) : AggregateExpression {
+    override fun inputExpression(): Expression {
+        return expr
+    }
+
+    override fun createAccumulator(): Accumulator {
+        return MaxAccumulator()
+    }
+
+    override fun toString(): String {
+        return "MAX($expr)"
+    }
+}
+
+class MaxAccumulator : Accumulator {
+    var value: Any? = null
+    override fun accumulate(value: Any?) {
+        if (value != null) {
+            if (this.value == null) {
+                this.value = value
+            } else {
+                val isMax = when(value) {
+                    is Byte -> value > this.value as Byte
+                    is Short -> value > this.value as Short
+                    is Int -> value > this.value as Int
+                    is Long -> value > this.value as Long
+                    is Float -> value > this.value as Float
+                    is Double -> value > this.value as Double
+                    is String -> value > this.value as String
+                    else -> throw UnsupportedOperationException("MAX does not support type of ${value.javaClass.name} ")
+                }
+                if (isMax) this.value = value
+            }
+        }
+    }
+
+    override fun finalValue(): Any? {
+        return this.value
+    }
+}

physical-plan/src/test/kotlin/AccumulatorTest.kt

@@ -0,0 +1,28 @@
+import io.hqew.kquery.physical.expressions.MaxAccumulator
+import org.junit.Test
+import org.junit.jupiter.api.TestInstance
+import kotlin.test.assertEquals
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class AccumulatorTest {
+
+    @Test
+    fun `max accumulator should accumulate value`() {
+        val numbers = listOf(1, 2, 3, 5, 4)
+        val maxAcc = MaxAccumulator()
+
+        numbers.forEach { maxAcc.accumulate(it) }
+
+        assertEquals(5, maxAcc.finalValue())
+    }
+
+    @Test
+    fun `max accumulator should accumulate string value`() {
+        val numbers = listOf("10", "2", "3", "5", "4", "a")
+        val maxAcc = MaxAccumulator()
+
+        numbers.forEach { maxAcc.accumulate(it) }
+
+        assertEquals("a", maxAcc.finalValue())
+    }
+}