Support PDOStatement->fetchAll() (#40)

Co-authored-by: Markus Staab <[email protected]>

Author: staabm

README.md

@@ -4,7 +4,7 @@ This extension provides following features:
 
 * the array shape of results can be inferred for `PDOStatement` and `mysqli_result`
   * .. when the query string can be resolved at analysis time. This is even possible for queries containing php-variables, as long as their typ is known in most cases.
-  * builtin we support `mysqli_query`, `mysqli->query`, `PDO->query` and `PDO->prepare`
+  * builtin we support `mysqli_query`, `mysqli->query`, `PDOStatement->fetchAll`, `PDO->query` and `PDO->prepare`
 * `PDO->prepare` knows the array shape of the returned results and therefore can return a generic `PDOStatement`
 * `mysqli->query` knows the array shape of the returned results and therefore can return a generic `mysqli_result`
 * `SyntaxErrorInQueryMethodRule` can inspect sql queries and detect syntax errors - `SyntaxErrorInQueryFunctionRule` can do the same for functions

config/extensions.neon

@@ -9,6 +9,11 @@ services:
         tags:
         	- phpstan.broker.dynamicMethodReturnTypeExtension
 
+    -
+        class: staabm\PHPStanDba\Extensions\PdoStatementFetchDynamicReturnTypeExtension
+        tags:
+        	- phpstan.broker.dynamicMethodReturnTypeExtension
+
     -
         class: staabm\PHPStanDba\Extensions\DeployerRunMysqlQueryDynamicReturnTypeExtension
         tags:

src/Extensions/PdoStatementFetchDynamicReturnTypeExtension.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace staabm\PHPStanDba\Extensions;
+
+use PDO;
+use PDOStatement;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
+use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\Type;
+
+final class PdoStatementFetchDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+    public function getClass(): string
+    {
+        return PDOStatement::class;
+    }
+
+    public function isMethodSupported(MethodReflection $methodReflection): bool
+    {
+        return 'fetchAll' === $methodReflection->getName();
+    }
+
+    public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): Type
+    {
+        $args = $methodCall->getArgs();
+        $defaultReturn = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
+
+        $statementType = $scope->getType($methodCall->var);
+
+        if ($statementType instanceof GenericObjectType) {
+            $genericTypes = $statementType->getTypes();
+
+            if (1 !== \count($genericTypes)) {
+                return $defaultReturn;
+            }
+
+            $fetchType = PDO::FETCH_BOTH;
+            if (\count($args) > 0) {
+                $fetchModeType = $scope->getType($args[0]->value);
+                if (!$fetchModeType instanceof ConstantIntegerType) {
+                    return $defaultReturn;
+                }
+                $fetchType = $fetchModeType->getValue();
+
+                if (!\in_array($fetchType, [PDO::FETCH_ASSOC, PDO::FETCH_NUM, PDO::FETCH_BOTH])) {
+                    return $defaultReturn;
+                }
+            }
+
+            $resultType = $genericTypes[0];
+
+            if ((PDO::FETCH_NUM === $fetchType || PDO::FETCH_ASSOC === $fetchType) && $resultType instanceof ConstantArrayType) {
+                $builder = ConstantArrayTypeBuilder::createEmpty();
+
+                $keyTypes = $resultType->getKeyTypes();
+                $valueTypes = $resultType->getValueTypes();
+
+                foreach ($keyTypes as $i => $keyType) {
+                    if (PDO::FETCH_NUM === $fetchType && $keyType instanceof ConstantIntegerType) {
+                        $builder->setOffsetValueType($keyType, $valueTypes[$i]);
+                    } elseif (PDO::FETCH_ASSOC === $fetchType && $keyType instanceof ConstantStringType) {
+                        $builder->setOffsetValueType($keyType, $valueTypes[$i]);
+                    }
+                }
+
+                return new ArrayType(new IntegerType(), $builder->getArray());
+            }
+
+            return new ArrayType(new IntegerType(), $resultType);
+        }
+
+        return $defaultReturn;
+    }
+}

tests/DbaInferenceTest.php

@@ -20,6 +20,10 @@ public function dataFileAsserts(): iterable
         require_once __DIR__.'/data/pdo-prepare.php';
         yield from $this->gatherAssertTypes(__DIR__.'/data/pdo-prepare.php');
 
+        // make sure class constants can be resolved
+        require_once __DIR__.'/data/pdo-stmt-fetch.php';
+        yield from $this->gatherAssertTypes(__DIR__.'/data/pdo-stmt-fetch.php');
+
         // make sure class constants can be resolved
         require_once __DIR__.'/data/pdo-fetch-types.php';
         yield from $this->gatherAssertTypes(__DIR__.'/data/pdo-fetch-types.php');

tests/data/pdo-stmt-fetch.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PdoStmtFetchTest;
+
+use PDO;
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+    public function fetchAll(PDO $pdo)
+    {
+        $stmt = $pdo->prepare('SELECT email, adaid FROM ada');
+        $stmt->execute();
+        assertType('PDOStatement<array{email: string, 0: string, adaid: int<0, 4294967295>, 1: int<0, 4294967295>}>', $stmt);
+
+        // default fetch-mode is BOTH
+        $all = $stmt->fetchAll();
+        assertType('array<int, array{email: string, 0: string, adaid: int<0, 4294967295>, 1: int<0, 4294967295>}>', $all);
+
+        $all = $stmt->fetchAll(PDO::FETCH_BOTH);
+        assertType('array<int, array{email: string, 0: string, adaid: int<0, 4294967295>, 1: int<0, 4294967295>}>', $all);
+
+        $all = $stmt->fetchAll(PDO::FETCH_NUM);
+        assertType('array<int, array{string, int<0, 4294967295>}>', $all);
+
+        $all = $stmt->fetchAll(PDO::FETCH_ASSOC);
+        assertType('array<int, array{email: string, adaid: int<0, 4294967295>}>', $all);
+
+        // not yet supported fetch types
+        $all = $stmt->fetchAll(PDO::FETCH_OBJ);
+        assertType('array|false', $all); // XXX since php8 this cannot return false
+    }
+}