Autodetect stringification behaviour

Author: janedbal

extension.neon

@@ -8,7 +8,6 @@ parameters:
 		objectManagerLoader: null
 		searchOtherMethodsForQueryBuilderBeginning: true
 		queryBuilderFastAlgorithm: false
-		stringifyExpressions: true
 	featureToggles:
 		skipCheckGenericClasses:
 			- Doctrine\ODM\MongoDB\Mapping\ClassMetadata
@@ -66,7 +65,6 @@ parametersSchema:
 		objectManagerLoader: schema(string(), nullable())
 		searchOtherMethodsForQueryBuilderBeginning: bool()
 		queryBuilderFastAlgorithm: bool()
-		stringifyExpressions: bool()
 	])
 
 conditionalTags:
@@ -117,7 +115,6 @@ services:
 		arguments:
 			queryBuilderClass: %doctrine.queryBuilderClass%
 			argumentsProcessor: @doctrineQueryBuilderArgumentsProcessor
-			stringifyExpressions: %doctrine.stringifyExpressions%
 		tags:
 			- phpstan.broker.dynamicMethodReturnTypeExtension
 	-
@@ -141,7 +138,6 @@ services:
 		class: PHPStan\Type\Doctrine\CreateQueryDynamicReturnTypeExtension
 		arguments:
 			objectMetadataResolver: @PHPStan\Type\Doctrine\ObjectMetadataResolver
-			stringifyExpressions: %doctrine.stringifyExpressions%
 		tags:
 			- phpstan.broker.dynamicMethodReturnTypeExtension
 	-

rules.neon

@@ -17,7 +17,6 @@ parametersSchema:
 		reportDynamicQueryBuilders: bool()
 		reportUnknownTypes: bool()
 		allowNullablePropertyForRequiredField: bool()
-		stringifyExpressions: bool()
 	])
 
 rules:

src/Type/Doctrine/CreateQueryDynamicReturnTypeExtension.php

@@ -11,6 +11,7 @@
 use Doctrine\ORM\Query;
 use PhpParser\Node\Expr\MethodCall;
 use PHPStan\Analyser\Scope;
+use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\Doctrine\Query\QueryResultTypeBuilder;
@@ -36,14 +37,14 @@ final class CreateQueryDynamicReturnTypeExtension implements DynamicMethodReturn
 	/** @var DescriptorRegistry */
 	private $descriptorRegistry;
 
-	/** @var bool */
-	private $stringifyExpressions;
+	/** @var PhpVersion */
+	private $phpVersion;
 
-	public function __construct(ObjectMetadataResolver $objectMetadataResolver, DescriptorRegistry $descriptorRegistry, bool $stringifyExpressions)
+	public function __construct(ObjectMetadataResolver $objectMetadataResolver, DescriptorRegistry $descriptorRegistry, PhpVersion $phpVersion)
 	{
 		$this->objectMetadataResolver = $objectMetadataResolver;
 		$this->descriptorRegistry = $descriptorRegistry;
-		$this->stringifyExpressions = $stringifyExpressions;
+		$this->phpVersion = $phpVersion;
 	}
 
 	public function getClass(): string
@@ -90,7 +91,7 @@ public function getTypeFromMethodCall(
 
 				try {
 					$query = $em->createQuery($queryString);
-					QueryResultTypeWalker::walk($query, $typeBuilder, $this->descriptorRegistry, $this->stringifyExpressions);
+					QueryResultTypeWalker::walk($query, $typeBuilder, $this->descriptorRegistry, $this->phpVersion);
 				} catch (ORMException | DBALException | NewDBALException | CommonException $e) {
 					return new QueryType($queryString, null, null);
 				} catch (AssertionError $e) {

src/Type/Doctrine/Query/QueryResultTypeWalker.php

@@ -3,7 +3,12 @@
 namespace PHPStan\Type\Doctrine\Query;
 
 use BackedEnum;
-use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
+use Doctrine\DBAL\Driver\Mysqli\Driver as MysqliDriver;
+use Doctrine\DBAL\Driver\PDO\MySQL\Driver as PdoMysqlDriver;
+use Doctrine\DBAL\Driver\PDO\PgSQL\Driver as PdoPgSQLDriver;
+use Doctrine\DBAL\Driver\PDO\SQLite\Driver as PdoSQLiteDriver;
+use Doctrine\DBAL\Driver\PgSQL\Driver as PgSQLDriver;
+use Doctrine\DBAL\Driver\SQLite3\Driver as SQLite3Driver;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
@@ -13,8 +18,13 @@
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\ParserResult;
 use Doctrine\ORM\Query\SqlWalker;
+use PDO;
+use PDOException;
+use PHPStan\Php\PhpVersion;
 use PHPStan\ShouldNotHappenException;
+use PHPStan\TrinaryLogic;
 use PHPStan\Type\BooleanType;
+use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantFloatType;
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
@@ -43,7 +53,6 @@
 use function get_class;
 use function gettype;
 use function intval;
-use function is_bool;
 use function is_numeric;
 use function is_object;
 use function is_string;
@@ -67,7 +76,7 @@ class QueryResultTypeWalker extends SqlWalker
 
 	private const HINT_DESCRIPTOR_REGISTRY = self::class . '::HINT_DESCRIPTOR_REGISTRY';
 
-	private const HINT_STRINGIFY_EXPRESSIONS = self::class . '::HINT_STRINGIFY_EXPRESSIONS';
+	private const HINT_PHP_VERSION = self::class . '::HINT_PHP_VERSION';
 
 	/**
 	 * Counter for generating unique scalar result.
@@ -89,6 +98,9 @@ class QueryResultTypeWalker extends SqlWalker
 	/** @var EntityManagerInterface */
 	private $em;
 
+	/** @var PhpVersion */
+	private $phpVersion;
+
 	/**
 	 * Map of all components/classes that appear in the DQL query.
 	 *
@@ -111,18 +123,15 @@ class QueryResultTypeWalker extends SqlWalker
 	/** @var bool */
 	private $hasGroupByClause;
 
-	/** @var bool */
-	private $stringifyExpressions;
-
 	/**
 	 * @param Query<mixed> $query
 	 */
-	public static function walk(Query $query, QueryResultTypeBuilder $typeBuilder, DescriptorRegistry $descriptorRegistry, bool $stringifyExpressions): void
+	public static function walk(Query $query, QueryResultTypeBuilder $typeBuilder, DescriptorRegistry $descriptorRegistry, PhpVersion $phpVersion): void
 	{
 		$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, self::class);
 		$query->setHint(self::HINT_TYPE_MAPPING, $typeBuilder);
 		$query->setHint(self::HINT_DESCRIPTOR_REGISTRY, $descriptorRegistry);
-		$query->setHint(self::HINT_STRINGIFY_EXPRESSIONS, $stringifyExpressions);
+		$query->setHint(self::HINT_PHP_VERSION, $phpVersion);
 
 		$parser = new Parser($query);
 		$parser->parse();
@@ -174,18 +183,18 @@ public function __construct($query, $parserResult, array $queryComponents)
 
 		$this->descriptorRegistry = $descriptorRegistry;
 
-		$stringifyExpressions = $this->query->getHint(self::HINT_STRINGIFY_EXPRESSIONS);
+		$phpVersion = $this->query->getHint(self::HINT_PHP_VERSION);
 
-		if (!is_bool($stringifyExpressions)) {
+		if (!$phpVersion instanceof PhpVersion) { // @phpstan-ignore-line ignore bc promise
 			throw new ShouldNotHappenException(sprintf(
 				'Expected the query hint %s to contain a %s, but got a %s',
-				self::HINT_STRINGIFY_EXPRESSIONS,
-				'boolean',
-				is_object($stringifyExpressions) ? get_class($stringifyExpressions) : gettype($stringifyExpressions)
+				self::HINT_PHP_VERSION,
+				PhpVersion::class,
+				is_object($phpVersion) ? get_class($phpVersion) : gettype($phpVersion)
 			));
 		}
 
-		$this->stringifyExpressions = $stringifyExpressions;
+		$this->phpVersion = $phpVersion;
 
 		parent::__construct($query, $parserResult, $queryComponents);
 	}
@@ -856,21 +865,37 @@ public function walkSelectExpression($selectExpression)
 					}
 					return $enforcedType;
 				});
-			} elseif ($this->stringifyExpressions) {
+			} else {
 				// Expressions default to Doctrine's StringType, whose
 				// convertToPHPValue() is a no-op. So the actual type depends on
 				// the driver and PHP version.
-				// Here we assume that the value may or may not be casted to
-				// string by the driver.
-				$type = TypeTraverser::map($type, static function (Type $type, callable $traverse): Type {
+
+				$type = TypeTraverser::map($type, function (Type $type, callable $traverse): Type {
 					if ($type instanceof UnionType || $type instanceof IntersectionType) {
 						return $traverse($type);
 					}
+
 					if ($type instanceof IntegerType || $type instanceof FloatType) {
-						return TypeCombinator::union($type->toString(), $type);
+						$stringify = $this->shouldStringifyExpressions($type);
+
+						if ($stringify->yes()) {
+							return $type->toString();
+						} elseif ($stringify->maybe()) {
+							return TypeCombinator::union($type->toString(), $type);
+						}
+
+						return $type;
 					}
 					if ($type instanceof BooleanType) {
-						return TypeCombinator::union($type->toInteger()->toString(), $type);
+						$stringify = $this->shouldStringifyExpressions($type);
+
+						if ($stringify->yes()) {
+							return $type->toString();
+						} elseif ($stringify->maybe()) {
+							return TypeCombinator::union($type->toInteger()->toString(), $type);
+						}
+
+						return $type;
 					}
 					return $traverse($type);
 				});
@@ -1111,6 +1136,8 @@ public function walkInParameter($inParam)
 	 */
 	public function walkLiteral($literal)
 	{
+		$driver = $this->em->getConnection()->getDriver();
+
 		switch ($literal->type) {
 			case AST\Literal::STRING:
 				$value = $literal->value;
@@ -1119,8 +1146,12 @@ public function walkLiteral($literal)
 				break;
 
 			case AST\Literal::BOOLEAN:
-				$value = strtolower($literal->value) === 'true' ? 1 : 0;
-				$type = new ConstantIntegerType($value);
+				$value = strtolower($literal->value) === 'true';
+				if ($driver instanceof PdoPgSQLDriver || $driver instanceof PgSQLDriver) {
+					$type = new ConstantBooleanType($value);
+				} else {
+					$type = new ConstantIntegerType($value ? 1 : 0);
+				}
 				break;
 
 			case AST\Literal::NUMERIC:
@@ -1130,9 +1161,7 @@ public function walkLiteral($literal)
 				if (floatval(intval($value)) === floatval($value)) {
 					$type = new ConstantIntegerType((int) $value);
 				} else {
-
-					if ($this->em->getConnection()->getDatabasePlatform() instanceof AbstractMySQLPlatform) {
-
+					if ($driver instanceof PdoMysqlDriver || $driver instanceof MysqliDriver) {
 						// both pdo_mysql and mysqli hydrates decimal literal (e.g. 123.4) as string no matter the configuration (e.g. PDO::ATTR_STRINGIFY_FETCHES being false) and PHP version
 						// the only way to force float is to use float literal with scientific notation (e.g. 123.4e0)
 						// https://dev.mysql.com/doc/refman/8.0/en/number-literals.html
@@ -1459,4 +1488,105 @@ private function hasAggregateFunction(AST\SelectStatement $AST): bool
 		return false;
 	}
 
+	/**
+	 * See analysis: https://github.com/janedbal/php-database-drivers-fetch-test
+	 *
+	 * Notable 8.1 changes:
+	 * - pdo_mysql: https://github.com/php/php-src/commit/c18b1aea289e8ed6edb3f6e6a135018976a034c6
+	 * - pdo_sqlite: https://github.com/php/php-src/commit/438b025a28cda2935613af412fc13702883dd3a2
+	 * - pdo_pgsql: https://github.com/php/php-src/commit/737195c3ae6ac53b9501cfc39cc80fd462909c82
+	 *
+	 * @param IntegerType|FloatType|BooleanType $type
+	 */
+	private function shouldStringifyExpressions(Type $type): TrinaryLogic
+	{
+		$driver = $this->em->getConnection()->getDriver();
+		$nativeConnection = $this->em->getConnection()->getNativeConnection();
+
+		if ($nativeConnection instanceof PDO) {
+			$stringifyFetches = $this->isPdoStringifyEnabled($nativeConnection);
+
+			if ($driver instanceof PdoMysqlDriver) {
+				$emulatedPrepares = $this->isPdoEmulatePreparesEnabled($nativeConnection);
+
+				if ($stringifyFetches) {
+					return TrinaryLogic::createYes();
+				}
+
+				if ($this->phpVersion->getVersionId() >= 80100) {
+					return TrinaryLogic::createNo(); // DECIMAL / FLOAT already decided in walkLiteral
+				}
+
+				if ($emulatedPrepares) {
+					return TrinaryLogic::createYes();
+				}
+
+				return TrinaryLogic::createNo();
+			}
+
+			if ($driver instanceof PdoSqliteDriver) {
+				if ($stringifyFetches) {
+					return TrinaryLogic::createYes();
+				}
+
+				if ($this->phpVersion->getVersionId() >= 80100) {
+					return TrinaryLogic::createNo();
+				}
+
+				return TrinaryLogic::createYes();
+			}
+
+			if ($driver instanceof PdoPgSQLDriver) {
+				if ($type->isBoolean()->yes()) {
+					if ($this->phpVersion->getVersionId() >= 80100) {
+						return TrinaryLogic::createFromBoolean($stringifyFetches);
+					}
+
+					return TrinaryLogic::createNo();
+
+				} elseif ($type->isFloat()->yes()) {
+					return TrinaryLogic::createYes();
+
+				} elseif ($type->isInteger()->yes()) {
+					return TrinaryLogic::createFromBoolean($stringifyFetches);
+				}
+			}
+		}
+
+		if ($driver instanceof PgSQLDriver) {
+			if ($type->isBoolean()->yes()) {
+				return TrinaryLogic::createNo();
+			} elseif ($type->isFloat()->yes()) {
+				return TrinaryLogic::createYes();
+			} elseif ($type->isInteger()->yes()) {
+				return TrinaryLogic::createNo();
+			}
+		}
+
+		if ($driver instanceof SQLite3Driver) {
+			return TrinaryLogic::createNo();
+		}
+
+		if ($driver instanceof MysqliDriver) {
+			return TrinaryLogic::createNo(); // DECIMAL / FLOAT already decided in walkLiteral
+		}
+
+		return TrinaryLogic::createMaybe();
+	}
+
+	private function isPdoStringifyEnabled(PDO $pdo): bool
+	{
+		// this fails for most PHP versions, see https://github.com/php/php-src/issues/12969
+		try {
+			return (bool) $pdo->getAttribute(PDO::ATTR_STRINGIFY_FETCHES);
+		} catch (PDOException $e) {
+			return false; // default
+		}
+	}
+
+	private function isPdoEmulatePreparesEnabled(PDO $pdo): bool
+	{
+		return (bool) $pdo->getAttribute(PDO::ATTR_EMULATE_PREPARES);
+	}
+
 }