Add greatest and least scalar functions (#1320)

* Added greatest and least scalar functions

* Updated dsl json

* Fixed failing tests

src/core/etl/src/Flow/ETL/DSL/functions.php

@@ -40,8 +40,10 @@
     DenseRank,
     Exists,
     First,
+    Greatest,
     Hash,
     Last,
+    Least,
     ListFunctions,
     Literal,
     Max,
@@ -1165,6 +1167,18 @@ function average(EntryReference|string $ref) : Average
     return new Average(is_string($ref) ? ref($ref) : $ref);
 }
 
+#[DocumentationDSL(module: Module::CORE, type: DSLType::SCALAR_FUNCTION)]
+function greatest(mixed ...$values) : Greatest
+{
+    return new Greatest($values);
+}
+
+#[DocumentationDSL(module: Module::CORE, type: DSLType::SCALAR_FUNCTION)]
+function least(mixed ...$values) : Least
+{
+    return new Least($values);
+}
+
 #[DocumentationDSL(module: Module::CORE, type: DSLType::AGGREGATING_FUNCTION)]
 function collect(EntryReference|string $ref) : Collect
 {

src/core/etl/src/Flow/ETL/Function/Comparison/Comparable.php

@@ -9,6 +9,31 @@
 
 trait Comparable
 {
+    public function assertAllComparable(array $values, string $symbol) : void
+    {
+        $detector = new TypeDetector();
+
+        $types = [];
+
+        foreach ($values as $value) {
+            $type = $detector->detectType($value);
+
+            if (!in_array($type, $types, true)) {
+                $types[] = $type;
+            }
+        }
+
+        if (count($types) > 1) {
+            foreach ($types as $nextType) {
+                foreach ($types as $baseType) {
+                    if (!$baseType->isComparableWith($nextType)) {
+                        throw new InvalidArgumentException(\sprintf("Can't compare '(%s %s %s)' due to data type mismatch.", $baseType->toString(), $symbol, $nextType->toString()));
+                    }
+                }
+            }
+        }
+    }
+
     public function assertComparable(mixed $left, mixed $right, string $symbol) : void
     {
         $detector = new TypeDetector();

src/core/etl/src/Flow/ETL/Function/Greatest.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Function;
+
+use Flow\ETL\Function\Comparison\Comparable;
+use Flow\ETL\Row;
+
+final class Greatest extends ScalarFunctionChain
+{
+    use Comparable;
+
+    public function __construct(
+        private readonly array $values,
+    ) {
+    }
+
+    public function eval(Row $row) : mixed
+    {
+        $extractedValues = [];
+
+        foreach ($this->values as $value) {
+            $extractedValues[] = (new Parameter($value))->eval($row);
+        }
+
+        $this->assertAllComparable($extractedValues, '>');
+
+        return max($extractedValues);
+    }
+}

src/core/etl/src/Flow/ETL/Function/Least.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Function;
+
+use Flow\ETL\Function\Comparison\Comparable;
+use Flow\ETL\Row;
+
+final class Least extends ScalarFunctionChain
+{
+    use Comparable;
+
+    public function __construct(
+        private readonly array $values,
+    ) {
+    }
+
+    public function eval(Row $row) : mixed
+    {
+        $extractedValues = [];
+
+        foreach ($this->values as $value) {
+            $extractedValues[] = (new Parameter($value))->eval($row);
+        }
+
+        $this->assertAllComparable($extractedValues, '<');
+
+        return \min($extractedValues);
+    }
+}

src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreatestTest.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Function;
+
+use function Flow\ETL\DSL\{greatest, int_entry, ref, row};
+use Flow\ETL\Tests\FlowTestCase;
+
+final class GreatestTest extends FlowTestCase
+{
+    public function test_greatest_value() : void
+    {
+        $greatest = greatest(
+            10,
+            20,
+            ref('int'),
+            40
+        );
+
+        self::assertSame(
+            55,
+            $greatest->eval(row(int_entry('int', 55)))
+        );
+    }
+
+    public function test_greatest_with_non_comparable_values() : void
+    {
+        $greatest = greatest(
+            null,
+            20,
+            ref('int'),
+            new \DateTimeImmutable('now')
+        );
+
+        $this->expectExceptionMessage("Can't compare '(datetime > integer)' due to data type mismatch.");
+
+        $greatest->eval(row(int_entry('int', 55)));
+    }
+
+    public function test_greatest_with_null() : void
+    {
+        $greatest = greatest(
+            null,
+            20,
+            ref('int'),
+            1257
+        );
+
+        self::assertSame(
+            1257,
+            $greatest->eval(row(int_entry('int', 55)))
+        );
+    }
+}

src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LeastTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Function;
+
+use function Flow\ETL\DSL\{int_entry, least, ref, row};
+use Flow\ETL\Tests\FlowTestCase;
+
+final class LeastTest extends FlowTestCase
+{
+    public function test_greatest_with_non_comparable_values() : void
+    {
+        $lest = least(
+            null,
+            20,
+            ref('int'),
+            new \DateTimeImmutable('now'),
+        );
+
+        $this->expectExceptionMessage("Can't compare '(datetime < integer)' due to data type mismatch.");
+
+        $lest->eval(row(int_entry('int', 55)));
+    }
+
+    public function test_least_value() : void
+    {
+        $lest = least(
+            10,
+            20,
+            ref('int'),
+            40,
+        );
+
+        self::assertSame(
+            10,
+            $lest->eval(row(int_entry('int', 55)))
+        );
+    }
+
+    public function test_least_with_null() : void
+    {
+        $ltest = least(
+            null,
+            20,
+            ref('int'),
+            1257
+        );
+
+        self::assertNull(
+            $ltest->eval(row(int_entry('int', 4)))
+        );
+    }
+}