feat: add support for mathematical functions CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN and WIDTH_BUCKET
#383
Conversation
|
Warning Rate limit exceeded@martin-georgiev has exceeded the limit for the number of commits or files that can be reviewed per hour. Please wait 7 minutes and 35 seconds before requesting another review. ⌛ How to resolve this issue?After the wait time has elapsed, a review can be triggered using the We recommend that you space out your commits to avoid hitting the rate limit. 🚦 How do rate limits work?CodeRabbit enforces hourly rate limits for each developer per organization. Our paid plans have higher rate limits than the trial, open-source and free plans. In all cases, we re-allow further reviews after a brief timeout. Please see our FAQ for further information. 📒 Files selected for processing (1)
## Walkthrough
This update introduces new PostgreSQL mathematical and range functions into the Doctrine ORM extension. It adds implementations and documentation for functions such as CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN, and WIDTH_BUCKET, along with comprehensive integration and unit tests. Documentation and configuration examples are updated accordingly.
## Changes
| Files/Paths | Change Summary |
|-------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| README.md, docs/AVAILABLE-FUNCTIONS-AND-OPERATORS.md, docs/INTEGRATING-WITH-DOCTRINE.md,<br>docs/INTEGRATING-WITH-LARAVEL.md, docs/INTEGRATING-WITH-SYMFONY.md | Expanded documentation to list new mathematical/arithmetic and range functions, updated integration examples, and removed the `ABS` function from configuration samples. |
| src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php,<br>Degrees.php, Exp.php, Ln.php, Log.php, Pi.php, Power.php, Radians.php, Random.php, Sign.php, WidthBucket.php | Added new PHP classes implementing PostgreSQL functions: CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN, WIDTH_BUCKET. Each class defines the function name and argument handling as needed. |
| src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ArrayShuffle.php | Updated PostgreSQL documentation URL in the class docblock. |
| src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Round.php, src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Trunc.php | Added `getMinArgumentCount()` method to specify minimum argument counts for ROUND and TRUNC functions. |
| tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php,<br>DegreesTest.php, ExpTest.php, LnTest.php, LogTest.php, PiTest.php, PowerTest.php, RadiansTest.php, RandomTest.php, SignTest.php, WidthBucketTest.php | Added integration tests for each new mathematical function, verifying correct DQL-to-SQL translation and results for literals and entity properties. |
| tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php | Refactored assertions for type and value checks; added a new test for rounding a column value. |
| tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php,<br>PowerTest.php, SignTest.php, DegreesTest.php, ExpTest.php, LnTest.php, LogTest.php, PiTest.php, RadiansTest.php, RandomTest.php, WidthBucketTest.php | Added unit tests to verify DQL-to-SQL translation for all new mathematical functions including CBRT, POWER, SIGN, DEGREES, EXP, LN, LOG, PI, RADIANS, RANDOM, and WIDTH_BUCKET. |
| tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/TruncTest.php | Updated test cases for TRUNC function to consolidate precision argument tests and adjust expected SQL and DQL statements. |
## Sequence Diagram(s)
```mermaid
sequenceDiagram
participant User
participant DoctrineDQL
participant CustomFunction
participant PostgreSQL
User->>DoctrineDQL: Use DQL with new function (e.g., CBRT, POWER)
DoctrineDQL->>CustomFunction: Parse and translate function call
CustomFunction->>PostgreSQL: Generate SQL with corresponding PG function
PostgreSQL-->>CustomFunction: Return result
CustomFunction-->>DoctrineDQL: Pass result
DoctrineDQL-->>User: Return query resultPossibly related PRs
Suggested labels
Poem
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 21
🧹 Nitpick comments (4)
docs/AVAILABLE-FUNCTIONS-AND-OPERATORS.md (1)
120-130: Documentation correctly lists the new mathematical functions.The changes effectively document all the newly added mathematical functions. This aligns well with the PR objective of adding mathematical functions to the library.
For consistency with the rest of the table, consider removing the trailing pipe characters from the table rows:
-| cbrt | CBRT | `MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cbrt` | +| cbrt | CBRT | `MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cbrt`(Apply similar changes to the other new entries)
🧰 Tools
🪛 markdownlint-cli2 (0.17.2)
120-120: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
121-121: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
122-122: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
123-123: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
124-124: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
125-125: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
126-126: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
127-127: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
128-128: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
129-129: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
130-130: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe(MD055, table-pipe-style)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (3)
18-25: Test coverage looks comprehensive, consider adding edge cases.The test cases cover perfect cubes, non-perfect cubes, negative numbers, and column values, which is good. Consider adding a test for edge cases like the cube root of 0.
+ public function test_cbrt_with_zero(): void + { + $dql = 'SELECT CBRT(0.0) as result + FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n + WHERE n.id = 1'; + $result = $this->executeDqlQuery($dql); + $this->assertEqualsWithDelta(0.0, $result[0]['result'], 0.0001); + }Also applies to: 27-34, 36-43, 45-52
38-38: Consider simplifying the double parentheses.The expression
((-27.0))contains double parentheses. While this works, a single set of parentheses around the negative number should be sufficient:(-27.0).- $dql = 'SELECT CBRT((-27.0)) as result + $dql = 'SELECT CBRT(-27.0) as result
45-52: Add a comment about the expected test data value.For better test clarity, consider adding a comment explaining what value is expected in
n.decimal1for the entity with ID=1. This would make the test more self-documenting and easier to maintain.public function test_cbrt_with_column_value(): void { + // Assuming n.decimal1 = 10.5 for entity with ID=1 $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); }
📜 Review details
Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (32)
README.md(1 hunks)docs/AVAILABLE-FUNCTIONS-AND-OPERATORS.md(1 hunks)docs/INTEGRATING-WITH-DOCTRINE.md(1 hunks)docs/INTEGRATING-WITH-LARAVEL.md(1 hunks)docs/INTEGRATING-WITH-SYMFONY.md(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ArrayShuffle.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php(1 hunks)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php(4 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php(1 hunks)
🧰 Additional context used
🧠 Learnings (7)
📓 Common learnings
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#263
File: src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Numrange.php:19-21
Timestamp: 2025-03-11T12:32:10.726Z
Learning: In the postgresql-for-doctrine repository, PostgreSQL range functions have distinct implementations for different data types. The `Numrange` function works with numeric/decimal values and is tested using the `ContainsDecimals` fixture with properties typed as `float`. In contrast, the `Int4range` function works with 32-bit integers and is tested using the `ContainsIntegers` fixture with properties typed as `int`. While the PHP implementations share a similar structure (extending `BaseFunction`), they are semantically different as they handle different PostgreSQL data types.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (1)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php (1)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
🧬 Code Graph Analysis (12)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (11)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
getFunctionName(19-22)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (11)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
getFunctionName(19-22)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php (1)
tests/Integration/MartinGeorgiev/TestCase.php (1)
executeDqlQuery(236-250)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (3)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (3)
getFunctionName(17-20)getMaxArgumentCount(22-25)getMinArgumentCount(27-30)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (11)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
getFunctionName(19-22)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
Power(15-31)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (2)
PowerTest(9-62)getStringFunctions(11-16)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (11)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
getFunctionName(19-22)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (3)
getFunctionName(17-20)getMaxArgumentCount(22-25)getMinArgumentCount(27-30)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (3)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
Pi(15-31)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NumericTestCase.php (1)
NumericTestCase(9-49)tests/Integration/MartinGeorgiev/TestCase.php (1)
executeDqlQuery(236-250)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (11)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseArithmeticFunction.php (1)
BaseArithmeticFunction(12-28)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
getFunctionName(17-20)src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
getFunctionName(19-22)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php (14)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
Log(15-31)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NumericTestCase.php (1)
NumericTestCase(9-49)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php (1)
getStringFunctions(11-14)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php (1)
getStringFunctions(11-16)tests/Integration/MartinGeorgiev/TestCase.php (1)
executeDqlQuery(236-250)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php (4)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
Sign(15-21)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php (2)
SignTest(9-35)getStringFunctions(11-16)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (3)
getStringFunctions(12-17)getExpectedSqlStatements(19-26)getDqlStatements(28-35)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (3)
getStringFunctions(12-17)getExpectedSqlStatements(19-26)getDqlStatements(28-35)
🪛 GitHub Actions: Integrations
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php
[error] 63-63: Doctrine ORM QueryException: Entity 'Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsArrays' has no field or association named 'decimal1' causing test_round_with_column_value to fail.
[error] 31-31: Test failure: Expected -3.0 but got string '-3' in test_round_with_negative_number.
[error] 22-22: Test failure: Expected 3.0 but got string '3' in test_round_with_positive_number.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php
[error] 24-24: Test failure: Expected '0.0' but got '0' string mismatch in test_sign_with_zero.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_width_bucket to fail with TableNotFoundException.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php
[error] 50-50: Doctrine ORM QueryException: Syntax error in query near 'POWER(2, -2)' due to unexpected '-' causing test_power_with_negative_exponent to fail.
[error] 41-41: Doctrine ORM QueryException: Syntax error in query near 'POWER(-2, 3)' due to unexpected '-' causing test_power_with_negative_base to fail.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_exp to fail with TableNotFoundException.
[error] 29-29: Test failure: Expected '1' but got '36315.502674246638' in test_exp_with_entity_property.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_degrees to fail with TableNotFoundException.
[error] 29-29: Test failure: Expected '1' but got '601.6056848873644' in test_degrees_with_entity_property.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_radians to fail with TableNotFoundException.
[error] 29-29: Test failure: Value '0.1832595714594046' identical to expected in test_radians_with_entity_property but test failed.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_ln to fail with TableNotFoundException.
[error] 29-29: Test failure: Expected '1' but got '2.3513752571634777' in test_ln_with_entity_property.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_pi to fail with TableNotFoundException.
[error] 29-29: Test failure: Expected '5.2907810314839' but got '13.641592653589793' in test_pi_plus_entity_property.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_log to fail with TableNotFoundException.
[error] 29-29: Test failure: Expected '1' but got '1.0211892990699381' in test_log_with_entity_property.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php
[error] 21-21: Doctrine DBAL Exception: Table 'containsjsons' does not exist causing test_random to fail with TableNotFoundException.
[error] 30-30: Test failure: Value '10.9658236190421' not equal or greater than expected 11.0 in test_random_plus_entity_property.
🪛 markdownlint-cli2 (0.17.2)
docs/AVAILABLE-FUNCTIONS-AND-OPERATORS.md
120-120: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
121-121: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
122-122: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
123-123: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
124-124: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
125-125: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
126-126: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
127-127: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
128-128: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
129-129: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
130-130: Table pipe style
Expected: leading_only; Actual: leading_and_trailing; Unexpected trailing pipe
(MD055, table-pipe-style)
🔇 Additional comments (21)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ArrayShuffle.php (1)
10-10: URL reference updated to specific PostgreSQL versionThe documentation link has been updated from a generic version to specifically point to PostgreSQL version 17. This is a good practice for ensuring accurate and consistent documentation references.
README.md (1)
80-83: Great addition of mathematical and range functions documentationThe documentation has been clearly organized with the new mathematical/arithmetic functions and range functions sections. This provides users with a comprehensive overview of the available functionality.
docs/INTEGRATING-WITH-LARAVEL.md (1)
206-220: Comprehensive addition of mathematical functionsThe integration documentation has been updated with a complete set of PostgreSQL mathematical functions. This is well-organized and consistent with the changes in the README file.
This implementation aligns well with the learning from previous PRs about how PostgreSQL functions are distinctly implemented for different data types in this repository.
docs/INTEGRATING-WITH-SYMFONY.md (1)
200-214: Arithmetic Functions List Updated CorrectlyThe new mathematical functions (CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN, WIDTH_BUCKET) have been added in alphabetical order, and
ABSwas removed as intended. This matches the updates in other integration guides and maintains consistency across documentation.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
1-21: ConsistentExpFunction ImplementationThe
Expclass correctly extendsBaseArithmeticFunction, declaresstrict_types, and returns'EXP'ingetFunctionName(). The docblock is well-formed with proper references and author attribution, matching existing function implementations.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Ln.php (1)
1-21: ConsistentLnFunction ImplementationThe
Lnclass follows the same pattern as other arithmetic functions: it extendsBaseArithmeticFunction, enforcesstrict_types, and returns'LN'ingetFunctionName(). Docblock annotations and links are correct.docs/INTEGRATING-WITH-DOCTRINE.md (1)
151-165: Arithmetic Functions Registration UpdatedNew arithmetic functions (
CBRT,DEGREES,EXP,LN,LOG,PI,POWER,RADIANS,RANDOM,SIGN,WIDTH_BUCKET) have been registered in alphabetical order, replacingABS. This aligns with the Symfony and Laravel guides and ensures consistency.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Sign.php (1)
1-21:SignFunction Follows Established PatternThe
Signclass is correctly implemented: it extendsBaseArithmeticFunction, hasdeclare(strict_types=1), and returns'SIGN'. The docblock is consistent with the other arithmetic function classes.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
1-21: Well-structuredDegreesAST function.
The class correctly extendsBaseArithmeticFunction, inherits the single-argument constraint, and returns the proper SQL nameDEGREES. Docblock, strict typing, and namespace align with existing implementations.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
1-21: CorrectRadiansAST function implementation.
This class mirrors theDegreespattern, enforces exactly one argument, and exposes theRADIANSSQL function. Documentation, strict types, and method override are consistent with the codebase conventions.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
1-31: Accurate zero-argumentPI()function.
OverridesgetMinArgumentCount()andgetMaxArgumentCount()to 0 as expected forPI(). The function name, docblock, and strict typing follow the established pattern for no-argument functions.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Power.php (1)
1-32: Proper two-argumentPOWER()function.
Overrides both min and max argument counts to 2, correctly mapping to PostgreSQL’sPOWER()signature. Implementation and documentation are aligned with the existingLogand other multi-arg functions.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Cbrt.php (1)
1-21: StandardCBRT()function extension.
Follows the same structure as other single-argument math functions. Inherits the argument count fromBaseArithmeticFunctionand properly returnsCBRTas the SQL function name.src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Random.php (1)
1-31: Implementation looks correct!The class correctly implements the PostgreSQL RANDOM() function by extending BaseArithmeticFunction and overriding the necessary methods. The function takes no arguments, which is properly reflected in both min and max argument count returning 0.
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
1-33: Correct implementation with proper argument validation.This implementation of PostgreSQL's WIDTH_BUCKET() function correctly enforces the requirement of exactly 4 arguments by setting both min and max argument counts to 4. The PHPDoc comment includes good documentation with the function description and an example of usage in DQL.
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
1-31: Correct implementation of PostgreSQL's LOG function.The implementation properly extends BaseArithmeticFunction and enforces that LOG requires exactly 2 arguments (base and value), which aligns with PostgreSQL's implementation.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php (1)
1-36: LGTM!The unit test for the Sign function is well-structured and follows the established pattern for other mathematical function tests in the project. It properly extends TestCase, registers the Sign function, and provides appropriate test SQL and DQL statements.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (1)
1-36: LGTM! Unit tests for Power function are well-structured.The PowerTest class is well-structured with appropriate test cases covering different scenarios of the POWER function usage. The expected SQL statements match the corresponding DQL statements correctly.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (1)
1-36: LGTM! Unit tests for CBRT function are well-structured.The CbrtTest class is well-structured with appropriate test cases for the CBRT function. The expected SQL statements correctly match the corresponding DQL statements.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php (1)
54-61: Check for potential overflow with large power resultsThe expected result of approximately 8.6 × 10^20 is extremely large and may cause precision/overflow issues in some PostgreSQL configurations.
While the test looks correct, verify that the actual database supports such large values consistently. Consider adding a more moderate test case as well.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php (1)
1-53: Overall good test implementation for the PostgreSQL CBRT function.The test class correctly covers various scenarios for the cube root function implementation. The structure follows good practices with the function registration and appropriate assertions with delta values for floating-point comparisons.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php
Outdated
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php
Outdated
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php
Outdated
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php
Show resolved
Hide resolved
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php
Show resolved
Hide resolved
martin-georgiev
changed the title
CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN, and WIDTH_BUCKET.
There was a problem hiding this comment.
Actionable comments posted: 0
🧹 Nitpick comments (3)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (1)
9-31: Consider adding tests for edge cases.The current tests cover basic functionality well, but consider adding tests for edge cases such as NULL values, negative values, or very large values to ensure the function handles all potential inputs correctly.
class DegreesTest extends NumericTestCase { protected function getStringFunctions(): array { return [ 'DEGREES' => Degrees::class, ]; } public function test_degrees(): void { $dql = 'SELECT DEGREES(3.141592653589793) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1'; $result = $this->executeDqlQuery($dql); $this->assertEqualsWithDelta(180.0, $result[0]['result'], 0.0001); } public function test_degrees_with_entity_property(): void { $dql = 'SELECT DEGREES(n.decimal1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1'; $result = $this->executeDqlQuery($dql); $this->assertEqualsWithDelta(601.6056848873644, $result[0]['result'], 0.000001); } + + public function test_degrees_with_null_value(): void + { + // Assuming your database structure supports NULL values + $sql = sprintf('UPDATE %s.containsnumerics SET decimal2 = NULL WHERE id = 1', self::DATABASE_SCHEMA); + $this->connection->executeStatement($sql); + + $dql = 'SELECT DEGREES(n.decimal2) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1'; + $result = $this->executeDqlQuery($dql); + $this->assertNull($result[0]['result']); + } + + public function test_degrees_with_negative_value(): void + { + $dql = 'SELECT DEGREES(-3.141592653589793) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1'; + $result = $this->executeDqlQuery($dql); + $this->assertEqualsWithDelta(-180.0, $result[0]['result'], 0.0001); + } }tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
22-23: Consider consistent delta precisionThe delta value (0.0001) used here is different from the more precise delta (0.000001) used in the second test. Consider using consistent precision across similar tests unless there's a specific reason for the difference.
18-23: Consider adding tests for edge casesThe current test covers the basic case of EXP(1). Consider adding tests for important edge cases:
public function test_exp(): void { $dql = 'SELECT EXP(1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1'; $result = $this->executeDqlQuery($dql); $this->assertEqualsWithDelta(2.718281828459, $result[0]['result'], 0.0001); } + public function test_exp_zero(): void + { + $dql = 'SELECT EXP(0) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1'; + $result = $this->executeDqlQuery($dql); + $this->assertEqualsWithDelta(1.0, $result[0]['result'], 0.0001); + } + + public function test_exp_negative(): void + { + $dql = 'SELECT EXP(-1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1'; + $result = $this->executeDqlQuery($dql); + $this->assertEqualsWithDelta(0.367879441171, $result[0]['result'], 0.0001); + }
📜 Review details
Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (11)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php(2 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php(1 hunks)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php(1 hunks)
🚧 Files skipped from review as they are similar to previous changes (9)
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RoundTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PowerTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php
- tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php
🧰 Additional context used
🧠 Learnings (2)
📓 Common learnings
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#263
File: src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Numrange.php:19-21
Timestamp: 2025-03-11T12:32:10.726Z
Learning: In the postgresql-for-doctrine repository, PostgreSQL range functions have distinct implementations for different data types. The `Numrange` function works with numeric/decimal values and is tested using the `ContainsDecimals` fixture with properties typed as `float`. In contrast, the `Int4range` function works with 32-bit integers and is tested using the `ContainsIntegers` fixture with properties typed as `int`. While the PHP implementations share a similar structure (extending `BaseFunction`), they are semantically different as they handle different PostgreSQL data types.
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
🧬 Code Graph Analysis (1)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (3)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
Degrees(15-21)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NumericTestCase.php (1)
NumericTestCase(9-49)tests/Integration/MartinGeorgiev/TestCase.php (1)
executeDqlQuery(236-250)
⏰ Context from checks skipped due to timeout of 90000ms (20)
- GitHub Check: sloth
- GitHub Check: PostgreSQL 16 + PHP 8.4
- GitHub Check: PostgreSQL 17 + PHP 8.2
- GitHub Check: PostgreSQL 16 + PHP 8.2
- GitHub Check: PostgreSQL 17 + PHP 8.3
- GitHub Check: PostgreSQL 16 + PHP 8.1
- GitHub Check: PostgreSQL 17 + PHP 8.1
- GitHub Check: PHP 8.4 + Doctrine ORM latest + Doctrine Lexer latest
- GitHub Check: PHP 8.4 + Doctrine ORM 3.0 + Doctrine Lexer latest
- GitHub Check: PHP 8.4 + Doctrine ORM 2.18 + Doctrine Lexer latest
- GitHub Check: PHP 8.4 + Doctrine ORM 2.18 + Doctrine Lexer 2.1
- GitHub Check: PHP 8.4 + Doctrine ORM 2.14 + Doctrine Lexer 2.1
- GitHub Check: PHP 8.3 + Doctrine ORM 2.18 + Doctrine Lexer latest
- GitHub Check: PHP 8.4 + Doctrine ORM latest + Doctrine Lexer 2.1
- GitHub Check: PHP 8.3 + Doctrine ORM 2.14 + Doctrine Lexer 2.1
- GitHub Check: PHP 8.2 + Doctrine ORM 2.14 + Doctrine Lexer latest
- GitHub Check: PHP 8.3 + Doctrine ORM 2.14 + Doctrine Lexer latest
- GitHub Check: PHP 8.3 + Doctrine ORM latest + Doctrine Lexer 2.1
- GitHub Check: PHP 8.2 + Doctrine ORM latest + Doctrine Lexer 3.0
- GitHub Check: PHP 8.2 + Doctrine ORM 2.18 + Doctrine Lexer 3.0
🔇 Additional comments (4)
tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (3)
9-16: Well-structured test class with proper function registration.The test class is well-organized and properly extends the
NumericTestCasebase class. ThegetStringFunctions()method correctly registers theDegreesfunction for use in DQL queries.
18-23: Good test case for constant value conversion.This test correctly verifies that the PostgreSQL
DEGREESfunction converts radians to degrees. Using π (3.141592653589793) as input to verify it outputs 180 degrees is a perfect test case. TheassertEqualsWithDeltawith a delta of 0.0001 is appropriate for floating-point comparisons.
25-30: Accurate test for entity property conversion.This test correctly verifies the
DEGREESfunction using thedecimal1entity property. The expected value of approximately 601.6 degrees is accurate for converting 10.5 radians to degrees (10.5 * 180/π).tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (1)
1-31: Implementation looks good overallThe test class properly validates the PostgreSQL EXP function implementation with both constant values and entity properties. The test correctly verifies that EXP(1) returns Euler's number and that EXP(n.decimal1) returns the expected result with appropriate precision.
I see that you've addressed the previous issues identified in the CI pipeline by:
- Using the correct fixture (
ContainsNumericsinstead ofContainsJsons)- Using the correct expected value with
assertEqualsWithDeltain the second test
There was a problem hiding this comment.
Actionable comments posted: 3
🧹 Nitpick comments (2)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php (1)
1-34: LGTM! Well-structured unit test following project conventions.The test properly implements the standard pattern for testing DQL function translation in this project. The use of
ContainsDecimalsfixture is appropriate sinceRANDOM()returns decimal values between 0 and 1, and the mapping between DQL statements and expected SQL is correct.Consider enhancing test coverage with additional scenarios:
protected function getDqlStatements(): array { return [ \sprintf('SELECT RANDOM() FROM %s e', ContainsDecimals::class), \sprintf('SELECT RANDOM() + e.decimal1 FROM %s e', ContainsDecimals::class), + \sprintf('SELECT RANDOM() * 100 FROM %s e', ContainsDecimals::class), + \sprintf('SELECT FLOOR(RANDOM() * 10) FROM %s e', ContainsDecimals::class), ]; }And corresponding expected SQL statements:
protected function getExpectedSqlStatements(): array { return [ 'SELECT RANDOM() AS sclr_0 FROM ContainsDecimals c0_', 'SELECT RANDOM() + c0_.decimal1 AS sclr_0 FROM ContainsDecimals c0_', + 'SELECT RANDOM() * 100 AS sclr_0 FROM ContainsDecimals c0_', + 'SELECT FLOOR(RANDOM() * 10) AS sclr_0 FROM ContainsDecimals c0_', ]; }This would test more realistic usage patterns where
RANDOM()is often scaled or used in mathematical expressions.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php (1)
19-33: Consider adding more comprehensive test cases.While the basic functionality is well covered, consider adding test cases for edge conditions to improve robustness:
- Zero value:
LN(0)(should handle domain error)- Negative values:
LN(-1)(should handle domain error)- Very small positive values:
LN(0.001)- NULL handling:
LN(NULL)Example additional test cases:
protected function getExpectedSqlStatements(): array { return [ 'SELECT LN(12) AS sclr_0 FROM ContainsDecimals c0_', 'SELECT LN(c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_', + 'SELECT LN(0.001) AS sclr_0 FROM ContainsDecimals c0_', + 'SELECT LN(c0_.decimal2) AS sclr_0 FROM ContainsDecimals c0_', ]; } protected function getDqlStatements(): array { return [ \sprintf('SELECT LN(12) FROM %s e', ContainsDecimals::class), \sprintf('SELECT LN(e.decimal1) FROM %s e', ContainsDecimals::class), + \sprintf('SELECT LN(0.001) FROM %s e', ContainsDecimals::class), + \sprintf('SELECT LN(e.decimal2) FROM %s e', ContainsDecimals::class), ]; }
📜 Review details
Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (10)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RandomTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php(1 hunks)tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php(1 hunks)
🚧 Files skipped from review as they are similar to previous changes (2)
- tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/SignTest.php
- tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/CbrtTest.php
🧰 Additional context used
🧠 Learnings (5)
📓 Common learnings
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#263
File: src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Numrange.php:19-21
Timestamp: 2025-03-11T12:32:10.726Z
Learning: In the postgresql-for-doctrine repository, PostgreSQL range functions have distinct implementations for different data types. The `Numrange` function works with numeric/decimal values and is tested using the `ContainsDecimals` fixture with properties typed as `float`. In contrast, the `Int4range` function works with 32-bit integers and is tested using the `ContainsIntegers` fixture with properties typed as `int`. While the PHP implementations share a similar structure (extending `BaseFunction`), they are semantically different as they handle different PostgreSQL data types.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (2)
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#318
File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9
Timestamp: 2025-03-29T03:31:17.114Z
Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.
🧬 Code Graph Analysis (6)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucket.php (1)
WidthBucket(17-33)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php (1)
WidthBucketTest(9-31)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Degrees.php (1)
Degrees(15-21)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (2)
DegreesTest(9-31)getStringFunctions(11-16)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Radians.php (1)
Radians(15-21)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php (2)
RadiansTest(9-31)getStringFunctions(11-16)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php (1)
Log(15-31)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php (2)
LogTest(9-31)getStringFunctions(11-16)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Exp.php (1)
Exp(15-21)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (2)
ExpTest(9-31)getStringFunctions(11-16)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (2)
src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Pi.php (1)
Pi(15-31)tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (2)
PiTest(9-31)getStringFunctions(11-16)
🔇 Additional comments (28)
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ExpTest.php (4)
1-11: LGTM! Proper file structure and class setup.The file header, namespace declaration, imports, and class definition follow the expected conventions. The class correctly extends the custom
TestCasefrom the same namespace.
12-17: LGTM! Correct function mapping.The
getStringFunctions()method properly maps the DQL function name 'EXP' to theExpclass implementation, following the expected pattern for registering custom functions.
19-25: LGTM! Expected SQL statements look correct.The expected SQL statements properly reflect how Doctrine would transform the DQL:
- Adds scalar aliases (
AS sclr_0)- Transforms table aliases (
e→c0_)- Maintains the EXP function calls correctly
Both literal value and entity property scenarios are covered.
27-33: LGTM! DQL statements provide comprehensive test coverage.The DQL statements test both:
- EXP function with a literal numeric value (11)
- EXP function with an entity property (
e.decimal1)Using
ContainsDecimalsentity is appropriate for testing mathematical functions that work with decimal values, which aligns with the function's purpose.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/PiTest.php (4)
1-8: LGTM! Proper file structure and imports.The PHP file header, namespace declaration, and imports are correctly structured. The imports are appropriate -
ContainsDecimalsentity for testing and thePifunction class being tested.
10-17: LGTM! Correct function registration.The
getStringFunctions()method properly maps the 'PI' string to thePiclass, which is the standard pattern for registering custom DQL functions in Doctrine.
19-25: LGTM! Expected SQL statements are accurate.The expected SQL statements correctly represent how Doctrine should translate the DQL queries:
PI()becomesPI() AS sclr_0with proper alias generationPI() + e.decimal1becomesPI() + c0_.decimal1 AS sclr_0with entity alias transformation frometoc0_
27-33:✅ Verification successful
Verify entity consistency between unit and integration tests.
The DQL statements are well-formed and test both standalone
PI()usage and arithmetic operations with entity properties. However, there's an inconsistency in entity usage:
- Unit test uses
ContainsDecimalsentity- Integration test uses
ContainsNumericsentityWhile this may be intentional (different fixtures for different test purposes), please verify that both entities have the required
decimal1property and that this difference is intended.
🏁 Script executed:
#!/bin/bash # Description: Verify that both ContainsDecimals and ContainsNumerics entities have the decimal1 property # Search for decimal1 property in ContainsDecimals entity echo "=== ContainsDecimals entity ===" fd -t f -e php | xargs grep -l "ContainsDecimals" | head -5 | xargs cat | grep -A5 -B5 "decimal1" echo -e "\n=== ContainsNumerics entity ===" # Search for decimal1 property in ContainsNumerics entity fd -t f -e php | xargs grep -l "ContainsNumerics" | head -5 | xargs cat | grep -A5 -B5 "decimal1"Length of output: 4050
Entity consistency confirmed: both entities declare
decimal1
BothContainsDecimals(unit tests) andContainsNumerics(integration tests) define the requireddecimal1property. The use of different fixtures for unit vs. integration testing is intentional—no changes required.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php (4)
12-17: LGTM! Function registration follows established pattern.The string function registration correctly maps 'LN' to the Ln class, following the standard pattern for DQL function registration in this codebase.
19-25: LGTM! SQL statements are correctly formatted.The expected SQL statements properly test both literal values and entity fields, using the correct PostgreSQL LN function syntax.
27-33: LGTM! DQL statements match expected SQL output.The DQL statements correctly use the ContainsDecimals fixture (appropriate for decimal operations based on the retrieved learnings) and will properly translate to the expected SQL.
10-10:⚠️ Potential issueAdd missing TestCase import.
The class extends
TestCasebut there's no import statement for it, which will cause a fatal error.Add the missing import at the top of the file:
use Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsDecimals; use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ln; +use PHPUnit\Framework\TestCase;⛔ Skipped due to learnings
Learnt from: martin-georgiev PR: martin-georgiev/postgresql-for-doctrine#318 File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9 Timestamp: 2025-03-29T03:31:17.114Z Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.Learnt from: martin-georgiev PR: martin-georgiev/postgresql-for-doctrine#318 File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9 Timestamp: 2025-03-29T03:31:17.114Z Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php (5)
12-17: LGTM! Correct function registration.The
getStringFunctionsmethod correctly maps the DQL function name to its implementation class, following the established pattern.
19-25: LGTM! Expected SQL statements are correct.The expected SQL statements properly represent the PostgreSQL
WIDTH_BUCKETfunction with the correct number of parameters (4) and proper field/literal transformations.
27-33: LGTM! DQL statements cover key usage patterns.The DQL statements appropriately test both entity property usage (
e.decimal1) and literal value usage (15), providing good coverage for theWIDTH_BUCKETfunction transformation.
7-7:❓ Verification inconclusive
Verify fixture consistency between unit and integration tests.
The unit test uses
ContainsDecimalsfixture while the integration test intests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.phpusesContainsNumericsfixture. Please ensure this is intentional and both fixtures provide appropriate test data for theWIDTH_BUCKETfunction.
🏁 Script executed:
#!/bin/bash # Description: Verify the properties and structure of both test fixtures to ensure consistency. # Check ContainsDecimals fixture properties echo "=== ContainsDecimals fixture properties ===" ast-grep --pattern 'class ContainsDecimals { $$$ }' echo -e "\n=== ContainsNumerics fixture properties ===" ast-grep --pattern 'class ContainsNumerics { $$$ }' # Also check if there are other WIDTH_BUCKET tests using different fixtures echo -e "\n=== Other WIDTH_BUCKET test usages ===" rg -A 3 -B 1 "WIDTH_BUCKET.*ContainsDecimals\|WIDTH_BUCKET.*ContainsNumerics"Length of output: 484
Here’s a deeper inspection to locate and peek into both fixtures, and to see exactly how they’re used in your WIDTH_BUCKET tests:
🏁 Script executed:
#!/bin/bash # Locate fixture classes and inspect definitions echo "=== Locate ContainsDecimals class ===" rg -n "class ContainsDecimals" || echo "ContainsDecimals class not found" echo -e "\n=== Locate ContainsNumerics class ===" rg -n "class ContainsNumerics" || echo "ContainsNumerics class not found" # Capture file paths DEC_FILE=$(rg -l "class ContainsDecimals") NUM_FILE=$(rg -l "class ContainsNumerics") # Print the first chunk of each fixture to review properties if [ -n "$DEC_FILE" ]; then echo -e "\n=== Contents of $DEC_FILE (first 50 lines) ===" sed -n '1,50p' "$DEC_FILE" fi if [ -n "$NUM_FILE" ]; then echo -e "\n=== Contents of $NUM_FILE (first 50 lines) ===" sed -n '1,50p' "$NUM_FILE" fi # Show how each fixture is referenced in WIDTH_BUCKET tests echo -e "\n=== WIDTH_BUCKET test references ===" rg -n "WIDTH_BUCKET" -C 2 tests/Unit tests/IntegrationLength of output: 6620
Ensure fixture alignment in WIDTH_BUCKET tests
Unit tests import
ContainsDecimals(decimal1, decimal2, decimal3 all as DECIMAL) while integration tests operate onContainsNumerics(integer, bigint, and decimal columns with specific precision/scale). Please confirm this divergence is intentional and that both fixtures exercise theWIDTH_BUCKETlogic correctly:• fixtures/MartinGeorgiev/Doctrine/Entity/ContainsDecimals.php
• fixtures/MartinGeorgiev/Doctrine/Entity/ContainsNumerics.php
• tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.php
• tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/WidthBucketTest.phpVerify that:
- Unit tests only need a pure decimal-type entity for AST serialization assertions.
- Integration tests cover actual numeric‐type behavior (integer/bigint/decimal precision).
- Any precision/scale differences won’t invalidate the expected bucket results.
1-9:⚠️ Potential issueAdd missing import for TestCase.
The class extends
TestCasebut the import statement is missing.Add the missing import:
+use Tests\Unit\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase; use Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsDecimals; use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\WidthBucket;⛔ Skipped due to learnings
Learnt from: martin-georgiev PR: martin-georgiev/postgresql-for-doctrine#318 File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9 Timestamp: 2025-03-29T03:31:17.114Z Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), not PHPUnit's TestCase, and therefore don't need an explicit import statement.Learnt from: martin-georgiev PR: martin-georgiev/postgresql-for-doctrine#318 File: tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/XmlAggTest.php:1-9 Timestamp: 2025-03-29T03:31:17.114Z Learning: Tests in the `Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions` namespace extend a custom `TestCase` class from the same namespace (`Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TestCase`), rather than PHPUnit's TestCase, and therefore don't need an explicit import.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/DegreesTest.php (5)
1-34: LGTM! Well-structured unit test following established patterns.The test implementation correctly follows the project's testing conventions and provides comprehensive coverage for the DEGREES function with both literal values and entity properties.
12-17: Function mapping implementation is correct.The
getStringFunctions()method properly maps the 'DEGREES' string to theDegrees::class, following the established pattern for DQL function registration.
19-25: Expected SQL statements are well-defined.The SQL expectations correctly represent the PostgreSQL DEGREES function usage with both literal values and entity properties. The table alias and field references are consistent.
27-33: DQL statements properly match expected SQL.The DQL statements correctly use
sprintffor dynamic entity class names and maintain consistency with the expected SQL patterns. Good test coverage with both literal and property-based usage.
7-7:✅ Verification successful
Verify fixture consistency across test types.
The unit test uses
ContainsDecimalsfixture, while the integration test (from relevant code snippets) usesContainsNumerics. Please verify that this fixture choice is intentional and appropriate for the DEGREES function testing strategy.
🏁 Script executed:
#!/bin/bash # Description: Check fixture usage consistency across DEGREES function tests # Expected: Verify if different fixtures are intentionally used for unit vs integration tests echo "=== Checking fixture usage in DEGREES tests ===" rg -A 3 -B 3 "ContainsDecimals|ContainsNumerics" tests/**/DegreesTest.php echo "=== Checking other mathematical function tests for fixture patterns ===" rg -A 2 "class.*Test extends" tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ | head -20Length of output: 2081
🏁 Script executed:
#!/bin/bash # Search for all occurrences of the two fixtures in the test suite echo "=== Searching for ContainsNumerics across tests ===" rg -Hn "ContainsNumerics" -g "tests/**/*.php" || echo "No occurrences of ContainsNumerics found." echo echo "=== Searching for ContainsDecimals across tests ===" rg -Hn "ContainsDecimals" -g "tests/**/*.php" || echo "No occurrences of ContainsDecimals found."Length of output: 20869
Fixture usage is intentional and consistent
Unit tests under
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/…all use the ContainsDecimals fixture, while integration tests undertests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/…use ContainsNumerics. This pattern applies uniformly (includingDegreesTest.php), so no changes are necessary.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php (2)
10-17: LGTM! Test structure follows established patterns.The test class structure, namespace usage, and method implementations follow the established conventions in this codebase. The extension of the custom
TestCaseclass and the three protected method pattern are consistent with other function tests.
7-7:✅ Verification successful
Verify entity choice consistency.
The unit test uses
ContainsDecimalsentity while the integration test usesContainsNumerics. Please verify this is intentional and consistent with the testing patterns for decimal vs numeric data types in PostgreSQL.
🏁 Script executed:
#!/bin/bash # Description: Check if ContainsDecimals entity is used consistently in other mathematical function tests # Expected: Find similar usage patterns in other math function unit tests echo "Checking ContainsDecimals usage in other unit tests:" fd "Test\.php$" tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ --exec grep -l "ContainsDecimals" {} \; echo -e "\nChecking ContainsNumerics usage in integration tests:" fd "Test\.php$" tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ --exec grep -l "ContainsNumerics" {} \; echo -e "\nChecking entity properties in ContainsDecimals:" ast-grep --pattern 'class ContainsDecimals { $$$ }'Length of output: 3028
Math function tests use consistent entity classes
All unit tests under
tests/Unit/.../FunctionsuseContainsDecimals, and all integration tests undertests/Integration/.../FunctionsuseContainsNumerics, matching the decimal vs. numeric mapping you’ve defined. No changes are required here.tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php (4)
12-17: LGTM! Function mapping is correct.The function mapping correctly associates the 'RADIANS' DQL function with the
Radiansclass implementation.
27-33: LGTM! DQL statements are well-structured.The DQL statements correctly test both literal values and entity properties, and the use of
sprintfwith the class constant is a good practice for maintainability.
19-25:✅ Verification successful
Verify expected SQL statement accuracy.
The expected SQL statements look correct for PostgreSQL RADIANS function, but please ensure they match the actual output from Doctrine's SQL generation.
Consider running a test to verify these SQL statements match actual Doctrine output:
🏁 Script executed:
#!/bin/bash # Description: Check if similar arithmetic functions have the same SQL generation pattern # Look for similar arithmetic function tests to compare SQL patterns rg -A 5 "getExpectedSqlStatements" tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ | grep -E "(DEGREES|EXP|LOG|POWER)" -A 3Length of output: 2485
SQL generation for RADIANS is accurate
The expected SQL statements in RadiansTest match the pattern used by other arithmetic‐function tests (DEGREES, EXP, LOG, POWER) and correctly reflect Doctrine’s output. No changes required.
7-7:❌ Incorrect review comment
Verify entity consistency across test types.
The unit test uses
ContainsDecimalsentity while the integration test usesContainsNumerics. Based on the retrieved learnings, different entities are used for different data types, but this inconsistency should be verified.Please verify that using different entities between unit and integration tests is intentional:
Also applies to: 22-24, 30-31
🏁 Script executed:
#!/bin/bash # Description: Check entity usage patterns across RADIANS tests and similar function tests # Search for other unit tests to see which entities they use echo "=== Unit test entity usage patterns ===" rg -A 3 -B 1 "ContainsDecimals\|ContainsNumerics\|ContainsIntegers" tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ echo "=== Integration test entity usage patterns ===" rg -A 3 -B 1 "ContainsDecimals\|ContainsNumerics\|ContainsIntegers" tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/ echo "=== Checking entity fixture definitions ===" fd -t f "ContainsDecimals\|ContainsNumerics" --exec cat {}Length of output: 618
#!/bin/bash
Search for entity references in unit tests
echo "=== Unit test entity usage patterns ==="
rg -n "ContainsDecimals|ContainsNumerics|ContainsIntegers" tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Search for entity references in integration tests
echo "=== Integration test entity usage patterns ==="
rg -n "ContainsDecimals|ContainsNumerics|ContainsIntegers" tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Locate the entity definitions
echo "=== Entity class definitions ==="
rg -n "class ContainsDecimals" -tphp
rg -n "class ContainsNumerics" -tphp
🏁 Script executed:
#!/usr/bin/env bash set -e echo "=== Unit Tests: Entity Imports ===" rg -n "use Fixtures\\\\MartinGeorgiev\\\\Doctrine\\\\Entity\\\\Contains" -n tests/Unit echo "=== Integration Tests: Entity Imports ===" rg -n "use Fixtures\\\\MartinGeorgiev\\\\Doctrine\\\\Entity\\\\Contains" -n tests/Integration echo "=== Integration Tests: Radians References ===" rg -n "Radians" -n tests/Integration echo "=== Locate Entity Class Files ===" fd -e php "ContainsDecimals.php" "ContainsNumerics.php" || true echo "=== Show Entity Class Definitions ===" rg -n "class ContainsDecimals" -n . rg -n "class ContainsNumerics" -n .Length of output: 18860
Ignore entity consistency suggestion.
There is no integration test for the Radians AST function undertests/Integration/.../Functions/, so there’s no mismatch between unit- and integration-test fixtures. Disregard the previous request to verify different entities.Likely an incorrect or invalid review comment.
| \sprintf('SELECT LOG(8) FROM %s e', ContainsDecimals::class), | ||
| \sprintf('SELECT LOG(e.decimal1) FROM %s e', ContainsDecimals::class), | ||
| \sprintf('SELECT LOG(10, e.decimal2) FROM %s e', ContainsDecimals::class), |
There was a problem hiding this comment.
Fix argument count mismatch in DQL statements.
The first two DQL statements use LOG with only 1 argument, which is inconsistent with the Log class requirement of exactly 2 arguments.
Apply this diff to fix the argument count:
- \sprintf('SELECT LOG(8) FROM %s e', ContainsDecimals::class),
- \sprintf('SELECT LOG(e.decimal1) FROM %s e', ContainsDecimals::class),
+ \sprintf('SELECT LOG(10, 8) FROM %s e', ContainsDecimals::class),
+ \sprintf('SELECT LOG(10, e.decimal1) FROM %s e', ContainsDecimals::class),📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| \sprintf('SELECT LOG(8) FROM %s e', ContainsDecimals::class), | |
| \sprintf('SELECT LOG(e.decimal1) FROM %s e', ContainsDecimals::class), | |
| \sprintf('SELECT LOG(10, e.decimal2) FROM %s e', ContainsDecimals::class), | |
| \sprintf('SELECT LOG(10, 8) FROM %s e', ContainsDecimals::class), | |
| \sprintf('SELECT LOG(10, e.decimal1) FROM %s e', ContainsDecimals::class), | |
| \sprintf('SELECT LOG(10, e.decimal2) FROM %s e', ContainsDecimals::class), |
🤖 Prompt for AI Agents
In tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php around
lines 31 to 33, the DQL statements call the LOG function with only one argument,
but the Log class requires exactly two arguments. Update the first two LOG calls
to include two arguments by adding a second argument, such as a base value, to
match the expected function signature.
| 'SELECT LOG(8) AS sclr_0 FROM ContainsDecimals c0_', | ||
| 'SELECT LOG(c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_', | ||
| 'SELECT LOG(10, c0_.decimal2) AS sclr_0 FROM ContainsDecimals c0_', |
There was a problem hiding this comment.
Fix argument count mismatch in expected SQL statements.
The first two expected SQL statements use LOG with only 1 argument, but according to the Log class implementation, the function requires exactly 2 arguments (both getMinArgumentCount() and getMaxArgumentCount() return 2).
Apply this diff to fix the argument count:
- 'SELECT LOG(8) AS sclr_0 FROM ContainsDecimals c0_',
- 'SELECT LOG(c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_',
+ 'SELECT LOG(10, 8) AS sclr_0 FROM ContainsDecimals c0_',
+ 'SELECT LOG(10, c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_',📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| 'SELECT LOG(8) AS sclr_0 FROM ContainsDecimals c0_', | |
| 'SELECT LOG(c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_', | |
| 'SELECT LOG(10, c0_.decimal2) AS sclr_0 FROM ContainsDecimals c0_', | |
| 'SELECT LOG(10, 8) AS sclr_0 FROM ContainsDecimals c0_', | |
| 'SELECT LOG(10, c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_', | |
| 'SELECT LOG(10, c0_.decimal2) AS sclr_0 FROM ContainsDecimals c0_', |
🤖 Prompt for AI Agents
In tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php around
lines 22 to 24, the expected SQL statements use the LOG function with only one
argument, but the Log class requires exactly two arguments. Update the first two
SQL statements to include two arguments in the LOG function call to match the
required argument count, ensuring the test expectations align with the function
implementation.
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Get the implementation of the Log class
cat src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php
Length of output: 665
@martin-georgiev You're absolutely right to question my suggestion. After checking the actual implementation of the Log class, I see that it supports both single-argument and two-argument variants:
protected function getMinArgumentCount(): int
{
return 1;
}
protected function getMaxArgumentCount(): int
{
return 2;
}The PostgreSQL LOG function allows both forms:
- LOG(x) - logarithm base 10 (single argument)
- LOG(b, x) - logarithm with specified base (two arguments)
The test cases correctly test both variants. My previous suggestion was incorrect, and the existing test is properly structured.
🧬 Code Graph Analysis Results
Relevant snippets for tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
File: src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/Log.php
Lines: 15-31
class Log extends BaseArithmeticFunction
{
protected function getFunctionName(): string
{
return 'LOG';
}
protected function getMinArgumentCount(): int
{
return 1;
}
protected function getMaxArgumentCount(): int
{
return 2;
}
}This class defines the LOG function for Doctrine ORM DQL. It specifies the function name as 'LOG' and allows between 1 and 2 arguments.
File: tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php
Lines: 9-31
class LogTest extends NumericTestCase
{
protected function getStringFunctions(): array
{
return [
'LOG' => Log::class,
];
}
public function test_log(): void
{
$dql = 'SELECT LOG(10, 100) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1';
$result = $this->executeDqlQuery($dql);
$this->assertEqualsWithDelta(2.0, $result[0]['result'], 0.0001);
}
public function test_log_with_entity_property(): void
{
$dql = 'SELECT LOG(10, n.decimal1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
$result = $this->executeDqlQuery($dql);
$this->assertEqualsWithDelta(1.0211892990699381, $result[0]['result'], 0.000001);
}
}This integration test class for the LOG function extends NumericTestCase and includes tests that execute DQL queries using the LOG function with numeric literals and entity properties, asserting expected results with floating point tolerance.
Additional related test method patterns from other function tests (e.g., LnTest, PiTest, ExpTest, SignTest, DegreesTest, etc.)
These test classes follow a similar pattern with methods:
getStringFunctions()returning an array mapping the function name to its class.getExpectedSqlStatements()returning expected SQL strings for various DQL inputs.getDqlStatements()returning DQL strings to be tested.
Examples from tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php:
protected function getStringFunctions(): array
{
return [
'LN' => Ln::class,
];
}
protected function getExpectedSqlStatements(): array
{
return [
'SELECT LN(12) AS sclr_0 FROM ContainsDecimals c0_',
'SELECT LN(c0_.decimal1) AS sclr_0 FROM ContainsDecimals c0_',
];
}
protected function getDqlStatements(): array
{
return [
\sprintf('SELECT LN(12) FROM %s e', ContainsDecimals::class),
\sprintf('SELECT LN(e.decimal1) FROM %s e', ContainsDecimals::class),
];
}This pattern is consistent across many function test classes and is relevant for understanding the structure and intent of the LogTest unit test.
Summary:
The above snippets provide context on:
- The implementation of the
LogDQL function class. - Integration tests verifying the
Logfunction's behavior with actual DQL queries and expected numeric results. - The typical structure of unit tests for similar DQL functions, including methods for registering the function, expected SQL, and DQL statements.
These are directly relevant to understanding and potentially addressing the user comment on the LogTest.php file.
✏️ Learnings added
Learnt from: martin-georgiev
PR: martin-georgiev/postgresql-for-doctrine#383
File: tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LogTest.php:22-24
Timestamp: 2025-05-23T11:24:46.876Z
Learning: The LOG function in PostgreSQL/Doctrine implementation supports both single-argument form (LOG(x) for base 10 logarithm) and two-argument form (LOG(b, x) for logarithm with specified base).
Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.
tests/Unit/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RadiansTest.php
Show resolved
Hide resolved
martin-georgiev
changed the title
CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN, and WIDTH_BUCKET.CBRT, DEGREES, EXP, LN, LOG, PI, POWER, RADIANS, RANDOM, SIGN and WIDTH_BUCKET
Summary by CodeRabbit
New Features
Documentation
Tests