Adress comments

Author: fogelito

src/Database/Validator/Operator.php

@@ -221,6 +221,25 @@ private function validateOperatorForAttribute(
                     }
                 }
 
+                // An unbounded power is computed directly by the database. Some engines hard-error on
+                // results that are not real numbers, so reject those up-front with a clear message.
+                if ($method === DatabaseOperator::TYPE_POWER && $this->currentDocument !== null && !isset($values[1])) {
+                    $base = (float)($this->currentDocument->getAttribute($operator->getAttribute()) ?? 0);
+                    $exponent = (float)$values[0];
+
+                    // Zero raised to a negative power is undefined (a division by zero).
+                    if ($base === 0.0 && $exponent < 0) {
+                        $this->message = "Cannot apply power operator: zero raised to a negative power is undefined";
+                        return false;
+                    }
+
+                    // A negative base raised to a fractional exponent is not a real number.
+                    if ($base < 0.0 && \floor($exponent) !== $exponent) {
+                        $this->message = "Cannot apply power operator: a negative base raised to a fractional exponent is undefined";
+                        return false;
+                    }
+                }
+
                 break;
             case DatabaseOperator::TYPE_ARRAY_APPEND:
             case DatabaseOperator::TYPE_ARRAY_PREPEND:

tests/e2e/Adapter/Scopes/OperatorTests.php

@@ -1651,6 +1651,60 @@ public function testOperatorPowerOnZeroOrNegativeBase(): void
         $database->deleteCollection($collectionId);
     }
 
+    /**
+     * A power with no maximum is computed directly by the database. When the result is not a real
+     * number (zero raised to a negative power, or a negative base with a fractional exponent) some
+     * databases throw a hard error. Validation rejects these before they reach the database, so the
+     * update fails the same way on every adapter and the stored value is left untouched.
+     */
+    public function testOperatorUnboundedPowerOnUndefinedBase(): void
+    {
+        $database = static::getDatabase();
+
+        if (!$database->getAdapter()->getSupportForOperators()) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $collectionId = 'operator_power_undefined';
+        $database->createCollection($collectionId);
+        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
+
+        // 0 raised to a negative power is undefined, so the update is rejected and 0 stays 0.
+        $database->createDocument($collectionId, new Document([
+            '$id' => 'zero',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => 0.0,
+        ]));
+        try {
+            $database->updateDocument($collectionId, 'zero', new Document([
+                'value' => Operator::power(-1),
+            ]));
+            $this->fail('Expected the update to be rejected for zero raised to a negative power');
+        } catch (StructureException) {
+            // expected
+        }
+        $this->assertEquals(0.0, $database->getDocument($collectionId, 'zero')->getAttribute('value'));
+
+        // The square root of a negative number is not a real number, so the update is rejected and -4 stays -4.
+        $database->createDocument($collectionId, new Document([
+            '$id' => 'neg',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => -4.0,
+        ]));
+        try {
+            $database->updateDocument($collectionId, 'neg', new Document([
+                'value' => Operator::power(0.5),
+            ]));
+            $this->fail('Expected the update to be rejected for a negative base with a fractional exponent');
+        } catch (StructureException) {
+            // expected
+        }
+        $this->assertEquals(-4.0, $database->getDocument($collectionId, 'neg')->getAttribute('value'));
+
+        $database->deleteCollection($collectionId);
+    }
+
     /**
      * Passing more values than the allowed maximum (10000) to an array operator must be rejected
      * the same way on every adapter. Covers each operator that takes a caller-supplied value list.