fix(#474): support usage of arithmetic expressions in mathematical functions

.github/workflows/sloth.yml

@@ -34,7 +34,7 @@ jobs:
         uses: lendable/sloth@1d0ce54a04a834366b4af63362ffd0a58fc447ad # 0.2.2
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          interval: 10
+          interval: 15
           ignored: |
             CodeRabbit
             Scrutinizer

src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php

@@ -13,7 +13,7 @@ abstract class BaseArithmeticFunction extends BaseVariadicFunction
 {
     protected function getNodeMappingPattern(): array
     {
-        return ['ArithmeticPrimary'];
+        return ['SimpleArithmeticExpression'];
     }
 
     protected function getMinArgumentCount(): int

src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Gamma.php

@@ -17,6 +17,6 @@ class Gamma extends BaseFunction
     protected function customizeFunction(): void
     {
         $this->setFunctionPrototype('gamma(%s)');
-        $this->addNodeMapping('ArithmeticPrimary');
+        $this->addNodeMapping('SimpleArithmeticExpression');
     }
 }

src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Lgamma.php

@@ -17,6 +17,6 @@ class Lgamma extends BaseFunction
     protected function customizeFunction(): void
     {
         $this->setFunctionPrototype('lgamma(%s)');
-        $this->addNodeMapping('ArithmeticPrimary');
+        $this->addNodeMapping('SimpleArithmeticExpression');
     }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php

@@ -49,10 +49,20 @@ public function can_calculate_cube_root_of_negative_number(): void
     #[Test]
     public function can_calculate_cube_root_of_column_value(): void
     {
-        $dql = 'SELECT CBRT(n.decimal1) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n 
+        $dql = 'SELECT CBRT(n.decimal1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
                 WHERE n.id = 1';
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(2.1897595699439445, $result[0]['result'], 0.0001);
     }
+
+    #[Test]
+    public function can_calculate_cube_root_of_arithmetic_expression(): void
+    {
+        $dql = 'SELECT CBRT(n.integer1 + n.integer2 - 3) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
+                WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(3.0, $result[0]['result'], 0.0001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CeilTest.php

@@ -39,4 +39,12 @@ public function ceil_with_column_value(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEquals(11, $result[0]['result']);
     }
+
+    #[Test]
+    public function ceil_with_arithmetic_expression(): void
+    {
+        $dql = 'SELECT CEIL(t.decimal1 * t.decimal2 / t.integer1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(22, $result[0]['result']);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php

@@ -31,4 +31,12 @@ public function degrees_with_entity_property(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(601.6056848873644, $result[0]['result'], 0.000001);
     }
+
+    #[Test]
+    public function degrees_with_arithmetic_expression(): void
+    {
+        $dql = 'SELECT DEGREES(n.decimal1 / n.integer1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(60.16056848873644, $result[0]['result'], 0.000001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php

@@ -31,4 +31,12 @@ public function can_calculate_exponential_of_entity_decimal_value(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(36315.502674246638, $result[0]['result'], 0.000001);
     }
+
+    #[Test]
+    public function can_calculate_exponential_of_arithmetic_expression(): void
+    {
+        $dql = 'SELECT EXP(n.integer1 / 10) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(2.718281828459, $result[0]['result'], 0.0001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/GammaTest.php

@@ -54,4 +54,15 @@ public function can_compute_gamma_of_integer_field(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(362880.0, $result[0]['result'], 0.0001);
     }
+
+    #[Test]
+    public function can_compute_gamma_of_arithmetic_expression(): void
+    {
+        $dql = 'SELECT GAMMA(t.integer1 / 2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t
+                WHERE t.id = 1';
+
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(24.0, $result[0]['result'], 0.0001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php

@@ -31,4 +31,12 @@ public function can_calculate_natural_logarithm_of_entity_decimal_value(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(2.3513752571634777, $result[0]['result'], 0.000001);
     }
+
+    #[Test]
+    public function can_calculate_natural_logarithm_of_arithmetic_expression(): void
+    {
+        $dql = 'SELECT LN(n.integer1 + n.integer2) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(3.4011973816621555, $result[0]['result'], 0.000001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php

@@ -31,4 +31,12 @@ public function can_calculate_base_ten_logarithm_of_entity_decimal_value(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(1.0211892990699381, $result[0]['result'], 0.000001);
     }
+
+    #[Test]
+    public function can_calculate_logarithm_with_arithmetic_expressions(): void
+    {
+        $dql = 'SELECT LOG(n.integer1 / 2, n.integer2 * 5) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(2.861353116146, $result[0]['result'], 0.000001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php

@@ -59,10 +59,20 @@ public function can_calculate_with_negative_exponent(): void
     #[Test]
     public function can_calculate_with_column_values(): void
     {
-        $dql = 'SELECT POWER(n.decimal1, n.decimal2) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n 
+        $dql = 'SELECT POWER(n.decimal1, n.decimal2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
                 WHERE n.id = 1';
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(859766721136081107225.6, $result[0]['result'], 0.0001);
     }
+
+    #[Test]
+    public function can_calculate_with_arithmetic_expressions(): void
+    {
+        $dql = 'SELECT POWER(n.integer1 + n.integer2, n.integer1 / 5) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
+                WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(900, $result[0]['result'], 0.0001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php

@@ -31,4 +31,12 @@ public function can_convert_decimal_entity_property_to_radians(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(0.1832595714594046, $result[0]['result'], 0.000001);
     }
+
+    #[Test]
+    public function can_convert_arithmetic_expression_to_radians(): void
+    {
+        $dql = 'SELECT RADIANS(n.integer1 * 18) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEqualsWithDelta(3.141592653589793, $result[0]['result'], 0.0001);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php

@@ -65,10 +65,40 @@ public function can_round_with_negative_precision(): void
     #[Test]
     public function can_round_column_value(): void
     {
-        $dql = 'SELECT ROUND(t.decimal1) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+        $dql = 'SELECT ROUND(t.decimal1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t
                 WHERE t.id = 1';
         $result = $this->executeDqlQuery($dql);
         $this->assertEquals(11, $result[0]['result']);
     }
+
+    #[Test]
+    public function can_round_arithmetic_expression(): void
+    {
+        $dql = 'SELECT ROUND(100 * t.integer1 / t.integer2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(50, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_round_arithmetic_expression_with_precision(): void
+    {
+        $dql = 'SELECT ROUND(t.decimal1 + t.decimal2 - t.integer1, 1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(21.0, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_round_parenthesized_arithmetic_expression(): void
+    {
+        $dql = 'SELECT ROUND((t.integer1 + t.integer2) * t.decimal1, 1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(315.0, $result[0]['result']);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php

@@ -29,10 +29,20 @@ public function sign_with_zero(): void
     #[Test]
     public function sign_with_column_value(): void
     {
-        $dql = 'SELECT SIGN(n.decimal1) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n 
+        $dql = 'SELECT SIGN(n.decimal1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
                 WHERE n.id = 1';
         $result = $this->executeDqlQuery($dql);
         $this->assertEquals(1, $result[0]['result']);
     }
+
+    #[Test]
+    public function sign_with_arithmetic_expression(): void
+    {
+        $dql = 'SELECT SIGN(n.integer1 - n.integer2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n
+                WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(-1, $result[0]['result']);
+    }
 }

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/TruncTest.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Integration\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
+
+use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trunc;
+use PHPUnit\Framework\Attributes\Test;
+
+class TruncTest extends NumericTestCase
+{
+    protected function getStringFunctions(): array
+    {
+        return [
+            'TRUNC' => Trunc::class,
+        ];
+    }
+
+    #[Test]
+    public function can_trunc_positive_number(): void
+    {
+        $dql = 'SELECT TRUNC(42.8) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(42, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_negative_number(): void
+    {
+        $dql = 'SELECT TRUNC(-42.8) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(-42, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_with_precision(): void
+    {
+        $dql = 'SELECT TRUNC(42.4382, 2) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(42.43, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_with_negative_precision(): void
+    {
+        $dql = 'SELECT TRUNC(1234.56, -2) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(1200, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_column_value(): void
+    {
+        $dql = 'SELECT TRUNC(t.decimal1) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(10, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_arithmetic_expression(): void
+    {
+        $dql = 'SELECT TRUNC(t.integer1 * t.decimal1) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(105, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_arithmetic_expression_with_precision(): void
+    {
+        $dql = 'SELECT TRUNC(100 * t.integer1 / t.integer2, 2) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(50.00, $result[0]['result']);
+    }
+
+    #[Test]
+    public function can_trunc_parenthesized_arithmetic_expression(): void
+    {
+        $dql = 'SELECT TRUNC((t.integer1 + t.integer2) * t.decimal1, 1) as result 
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t 
+                WHERE t.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertEquals(315.0, $result[0]['result']);
+    }
+}

tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php

@@ -31,4 +31,12 @@ public function width_bucket_with_entity_property(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertSame(3, $result[0]['result']);
     }
+
+    #[Test]
+    public function width_bucket_with_arithmetic_expressions(): void
+    {
+        $dql = 'SELECT WIDTH_BUCKET(n.integer1 / 2, n.integer1 - 10, n.integer2 + 10, n.integer1 / 2) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
+        $result = $this->executeDqlQuery($dql);
+        $this->assertSame(1, $result[0]['result']);
+    }
 }