Warn when queries cannot be resolved unexpectedly

hemberger · hemberger · commit 1a39cc66b39f · 2023-02-14T19:55:47.000-08:00
Fixes #504. This adds new functionality to debug mode to warn about queries that cannot be resolved due to the presence of non-literal string variables in the query. This helps to identify places where you might expect a query to be resolvable, but an inline parameter or a variable query fragment prevent it. Some scenarios where this might occur include string query fragments where using `@phpstandba-inference-placeholder` may be needed, e.g. /** @var string $condition */ $query = 'SELECT * FROM table WHERE ' . $condition; Or when not using prepared statements, e.g. /** @var string $param */ $query = 'SELECT * FROM table WHERE foo=' . $conn->quote($param); Since these queries cannot be analyzed, they will now emit the following warning: > Unresolvable Query: Cannot resolve query with variable type: string. > Consider replacing variable strings with prepared statements or @phpstandba-inference-placeholder. Without this warning, errors in these queries will go undetected. Implementation notes: 1. We make `UnresolvableQueryException` abstract, and add child classes for each type of unresolvable query error so that we can provide customized tips for each one. 2. Special care had to be taken to retain the ability to ignore queries that are _entirely_ StringType, because it was explicitly desired for these queries to not return an error (even in debug mode). This is because such queries are likely part of a s/w layer that we know nothing about. Therefore, we early return before checking parameters for any query that is is a superset of `StringType` (which includes the previous `MixedType` condition, and any mix of the two).
diff --git a/src/QueryReflection/QuerySimulation.php b/src/QueryReflection/QuerySimulation.php
@@ -20,7 +20,8 @@
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 use staabm\PHPStanDba\DbaException;
-use staabm\PHPStanDba\UnresolvableQueryException;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @internal
@@ -30,7 +31,7 @@ final class QuerySimulation
     private const DATE_FORMAT = 'Y-m-d';
 
     /**
-     * @throws UnresolvableQueryException
+     * @throws \staabm\PHPStanDba\UnresolvableQueryException
      */
     public static function simulateParamValueType(Type $paramType, bool $preparedParam): ?string
     {
@@ -94,6 +95,10 @@ public static function simulateParamValueType(Type $paramType, bool $preparedPar
             }
 
             // plain string types can contain anything.. we cannot reason about it
+            if (QueryReflection::getRuntimeConfiguration()->isDebugEnabled()) {
+                throw new UnresolvableQueryStringTypeException('Cannot resolve query with variable type: '.$paramType->describe(VerbosityLevel::precise()));
+            }
+
             return null;
         }
 
@@ -113,7 +118,7 @@ public static function simulateParamValueType(Type $paramType, bool $preparedPar
         // all types which we can't simulate and render a query unresolvable at analysis time
         if ($paramType instanceof MixedType || $paramType instanceof IntersectionType) {
             if (QueryReflection::getRuntimeConfiguration()->isDebugEnabled()) {
-                throw new UnresolvableQueryException('Cannot simulate parameter value for type: '.$paramType->describe(VerbosityLevel::precise()));
+                throw new UnresolvableQueryMixedTypeException('Cannot simulate parameter value for type: '.$paramType->describe(VerbosityLevel::precise()));
             }
 
             return null;
diff --git a/src/Rules/PdoStatementExecuteMethodRule.php b/src/Rules/PdoStatementExecuteMethodRule.php
@@ -15,7 +15,7 @@
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
-use PHPStan\Type\MixedType;
+use PHPStan\Type\StringType;
 use staabm\PHPStanDba\PdoReflection\PdoStatementReflection;
 use staabm\PHPStanDba\QueryReflection\PlaceholderValidation;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
@@ -67,7 +67,7 @@ private function checkErrors(MethodReflection $methodReflection, MethodCall $met
         if (null === $queryExpr) {
             return [];
         }
-        if ($scope->getType($queryExpr) instanceof MixedType) {
+        if ($scope->getType($queryExpr)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
@@ -98,7 +98,7 @@ private function checkErrors(MethodReflection $methodReflection, MethodCall $met
             $parameters = $queryReflection->resolveParameters($parameterTypes) ?? [];
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($methodCall->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($methodCall->getLine())->build(),
             ];
         }
 
@@ -111,7 +111,7 @@ private function checkErrors(MethodReflection $methodReflection, MethodCall $met
             }
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($methodCall->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($methodCall->getLine())->build(),
             ];
         }
 
diff --git a/src/Rules/QueryPlanAnalyzerRule.php b/src/Rules/QueryPlanAnalyzerRule.php
@@ -14,8 +14,8 @@
 use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
-use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
+use PHPStan\Type\StringType;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Tests\QueryPlanAnalyzerRuleTest;
 use staabm\PHPStanDba\UnresolvableQueryException;
@@ -94,15 +94,15 @@ public function processNode(Node $callLike, Scope $scope): array
             return [];
         }
 
-        if ($scope->getType($args[$queryArgPosition]->value) instanceof MixedType) {
+        if ($scope->getType($args[$queryArgPosition]->value)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
         try {
             return $this->analyze($callLike, $scope);
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($callLike->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($callLike->getLine())->build(),
             ];
         }
     }
@@ -126,7 +126,7 @@ private function analyze(CallLike $callLike, Scope $scope): array
 
         $queryExpr = $args[0]->value;
 
-        if ($scope->getType($queryExpr) instanceof MixedType) {
+        if ($scope->getType($queryExpr)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
diff --git a/src/Rules/SyntaxErrorInPreparedStatementMethodRule.php b/src/Rules/SyntaxErrorInPreparedStatementMethodRule.php
@@ -14,8 +14,8 @@
 use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
-use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
+use PHPStan\Type\StringType;
 use staabm\PHPStanDba\QueryReflection\PlaceholderValidation;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\UnresolvableQueryException;
@@ -102,7 +102,7 @@ private function checkErrors(CallLike $callLike, Scope $scope): array
 
         $queryExpr = $args[0]->value;
 
-        if ($scope->getType($queryExpr) instanceof MixedType) {
+        if ($scope->getType($queryExpr)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
@@ -115,7 +115,7 @@ private function checkErrors(CallLike $callLike, Scope $scope): array
                 $parameters = $queryReflection->resolveParameters($parameterTypes) ?? [];
             } catch (UnresolvableQueryException $exception) {
                 return [
-                    RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($callLike->getLine())->build(),
+                    RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($callLike->getLine())->build(),
                 ];
             }
         }
@@ -152,7 +152,7 @@ private function checkErrors(CallLike $callLike, Scope $scope): array
             return $ruleErrors;
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($callLike->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($callLike->getLine())->build(),
             ];
         }
     }
diff --git a/src/Rules/SyntaxErrorInQueryFunctionRule.php b/src/Rules/SyntaxErrorInQueryFunctionRule.php
@@ -11,7 +11,7 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
-use PHPStan\Type\MixedType;
+use PHPStan\Type\StringType;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Tests\SyntaxErrorInQueryFunctionRuleTest;
 use staabm\PHPStanDba\UnresolvableQueryException;
@@ -85,7 +85,7 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        if ($scope->getType($args[$queryArgPosition]->value) instanceof MixedType) {
+        if ($scope->getType($args[$queryArgPosition]->value)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
@@ -101,7 +101,7 @@ public function processNode(Node $node, Scope $scope): array
             }
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($node->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($node->getLine())->build(),
             ];
         }
 
diff --git a/src/Rules/SyntaxErrorInQueryMethodRule.php b/src/Rules/SyntaxErrorInQueryMethodRule.php
@@ -10,7 +10,7 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
-use PHPStan\Type\MixedType;
+use PHPStan\Type\StringType;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\UnresolvableQueryException;
 
@@ -79,7 +79,7 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        if ($scope->getType($args[$queryArgPosition]->value) instanceof MixedType) {
+        if ($scope->getType($args[$queryArgPosition]->value)->isSuperTypeOf(new StringType())->yes()) {
             return [];
         }
 
@@ -96,7 +96,7 @@ public function processNode(Node $node, Scope $scope): array
             }
         } catch (UnresolvableQueryException $exception) {
             return [
-                RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($node->getLine())->build(),
+                RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($node->getLine())->build(),
             ];
         }
 
diff --git a/src/UnresolvableQueryException.php b/src/UnresolvableQueryException.php
@@ -2,9 +2,12 @@
 
 namespace staabm\PHPStanDba;
 
-final class UnresolvableQueryException extends DbaException
+/**
+ * @api
+ */
+abstract class UnresolvableQueryException extends DbaException
 {
-    public const RULE_TIP = 'Make sure all variables involved have a non-mixed type and array-types are specified.';
+    abstract public static function getTip(): string;
 
     public function asRuleMessage(): string
     {
diff --git a/src/UnresolvableQueryMixedTypeException.php b/src/UnresolvableQueryMixedTypeException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace staabm\PHPStanDba;
+
+final class UnresolvableQueryMixedTypeException extends UnresolvableQueryException
+{
+    public static function getTip(): string
+    {
+        return 'Make sure all variables involved have a non-mixed type and array-types are specified.';
+    }
+}
diff --git a/src/UnresolvableQueryStringTypeException.php b/src/UnresolvableQueryStringTypeException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace staabm\PHPStanDba;
+
+final class UnresolvableQueryStringTypeException extends UnresolvableQueryException
+{
+    public static function getTip(): string
+    {
+        return 'Consider replacing variable strings with prepared statements or @phpstandba-inference-placeholder.';
+    }
+}
diff --git a/tests/rules/QueryPlanAnalyzerRuleTest.php b/tests/rules/QueryPlanAnalyzerRuleTest.php
@@ -6,6 +6,8 @@
 use PHPStan\Testing\RuleTestCase;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Rules\QueryPlanAnalyzerRule;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @extends RuleTestCase<QueryPlanAnalyzerRule>
@@ -137,7 +139,22 @@ public function testNotUsingIndexInDebugMode(): void
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 61,
-                'Make sure all variables involved have a non-mixed type and array-types are specified.',
+                UnresolvableQueryMixedTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                67,
+                UnresolvableQueryStringTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                70,
+                UnresolvableQueryStringTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                73,
+                UnresolvableQueryStringTypeException::getTip(),
             ],
         ]);
     }
diff --git a/tests/rules/UnresolvablePdoStatementRuleTest.php b/tests/rules/UnresolvablePdoStatementRuleTest.php
@@ -6,7 +6,8 @@
 use PHPStan\Testing\RuleTestCase;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Rules\PdoStatementExecuteMethodRule;
-use staabm\PHPStanDba\UnresolvableQueryException;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @extends RuleTestCase<PdoStatementExecuteMethodRule>
@@ -43,12 +44,17 @@ public function testSyntaxErrorInQueryRule(): void
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 13,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
             ],
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 17,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                54,
+                UnresolvableQueryStringTypeException::getTip(),
             ],
         ]);
     }
diff --git a/tests/rules/UnresolvablePreparedStatementRuleTest.php b/tests/rules/UnresolvablePreparedStatementRuleTest.php
@@ -6,7 +6,8 @@
 use PHPStan\Testing\RuleTestCase;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Rules\SyntaxErrorInPreparedStatementMethodRule;
-use staabm\PHPStanDba\UnresolvableQueryException;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @extends RuleTestCase<SyntaxErrorInPreparedStatementMethodRule>
@@ -43,7 +44,12 @@ public function testSyntaxErrorInQueryRule(): void
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 11,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                30,
+                UnresolvableQueryStringTypeException::getTip(),
             ],
         ]);
     }
diff --git a/tests/rules/UnresolvableQueryFunctionRuleTest.php b/tests/rules/UnresolvableQueryFunctionRuleTest.php
@@ -6,7 +6,8 @@
 use PHPStan\Testing\RuleTestCase;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Rules\SyntaxErrorInQueryFunctionRule;
-use staabm\PHPStanDba\UnresolvableQueryException;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @extends RuleTestCase<SyntaxErrorInQueryFunctionRule>
@@ -43,12 +44,22 @@ public function testSyntaxErrorInQueryRule(): void
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 9,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
             ],
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 15,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                32,
+                UnresolvableQueryStringTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                37,
+                UnresolvableQueryStringTypeException::getTip(),
             ],
         ]);
     }
diff --git a/tests/rules/UnresolvableQueryMethodRuleTest.php b/tests/rules/UnresolvableQueryMethodRuleTest.php
@@ -6,7 +6,8 @@
 use PHPStan\Testing\RuleTestCase;
 use staabm\PHPStanDba\QueryReflection\QueryReflection;
 use staabm\PHPStanDba\Rules\SyntaxErrorInQueryMethodRule;
-use staabm\PHPStanDba\UnresolvableQueryException;
+use staabm\PHPStanDba\UnresolvableQueryMixedTypeException;
+use staabm\PHPStanDba\UnresolvableQueryStringTypeException;
 
 /**
  * @extends RuleTestCase<SyntaxErrorInQueryMethodRule>
@@ -43,12 +44,22 @@ public function testSyntaxErrorInQueryRule(): void
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 11,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
             ],
             [
                 'Unresolvable Query: Cannot simulate parameter value for type: mixed.',
                 17,
-                UnresolvableQueryException::RULE_TIP,
+                UnresolvableQueryMixedTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                34,
+                UnresolvableQueryStringTypeException::getTip(),
+            ],
+            [
+                'Unresolvable Query: Cannot resolve query with variable type: string.',
+                39,
+                UnresolvableQueryStringTypeException::getTip(),
             ],
         ]);
     }
diff --git a/tests/rules/data/unresolvable-pdo-statement.php b/tests/rules/data/unresolvable-pdo-statement.php
diff --git a/tests/rules/data/unresolvable-query-in-function.php b/tests/rules/data/unresolvable-query-in-function.php
diff --git a/tests/rules/data/unresolvable-query-in-method.php b/tests/rules/data/unresolvable-query-in-method.php
diff --git a/tests/rules/data/unresolvable-statement.php b/tests/rules/data/unresolvable-statement.php

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`	`use PHPStan\Rules\Rule;`
`12`	`12`	`use PHPStan\Rules\RuleErrorBuilder;`
`13`	`13`	`use PHPStan\ShouldNotHappenException;`
`14`		`-use PHPStan\Type\MixedType;`
	`14`	`+use PHPStan\Type\StringType;`
`15`	`15`	`use staabm\PHPStanDba\QueryReflection\QueryReflection;`
`16`	`16`	`use staabm\PHPStanDba\Tests\SyntaxErrorInQueryFunctionRuleTest;`
`17`	`17`	`use staabm\PHPStanDba\UnresolvableQueryException;`
`@@ -85,7 +85,7 @@ public function processNode(Node $node, Scope $scope): array`
`85`	`85`	`return [];`
`86`	`86`	`}`
`87`	`87`
`88`		`- if ($scope->getType($args[$queryArgPosition]->value) instanceof MixedType) {`
	`88`	`+ if ($scope->getType($args[$queryArgPosition]->value)->isSuperTypeOf(new StringType())->yes()) {`
`89`	`89`	`return [];`
`90`	`90`	`}`
`91`	`91`
`@@ -101,7 +101,7 @@ public function processNode(Node $node, Scope $scope): array`
`101`	`101`	`}`
`102`	`102`	`} catch (UnresolvableQueryException $exception) {`
`103`	`103`	`return [`
`104`		`- RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($node->getLine())->build(),`
	`104`	`+ RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($node->getLine())->build(),`
`105`	`105`	`];`
`106`	`106`	`}`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`use PHPStan\Rules\Rule;`
`11`	`11`	`use PHPStan\Rules\RuleErrorBuilder;`
`12`	`12`	`use PHPStan\ShouldNotHappenException;`
`13`		`-use PHPStan\Type\MixedType;`
	`13`	`+use PHPStan\Type\StringType;`
`14`	`14`	`use staabm\PHPStanDba\QueryReflection\QueryReflection;`
`15`	`15`	`use staabm\PHPStanDba\UnresolvableQueryException;`
`16`	`16`
`@@ -79,7 +79,7 @@ public function processNode(Node $node, Scope $scope): array`
`79`	`79`	`return [];`
`80`	`80`	`}`
`81`	`81`
`82`		`- if ($scope->getType($args[$queryArgPosition]->value) instanceof MixedType) {`
	`82`	`+ if ($scope->getType($args[$queryArgPosition]->value)->isSuperTypeOf(new StringType())->yes()) {`
`83`	`83`	`return [];`
`84`	`84`	`}`
`85`	`85`
`@@ -96,7 +96,7 @@ public function processNode(Node $node, Scope $scope): array`
`96`	`96`	`}`
`97`	`97`	`} catch (UnresolvableQueryException $exception) {`
`98`	`98`	`return [`
`99`		`- RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($node->getLine())->build(),`
	`99`	`+ RuleErrorBuilder::message($exception->asRuleMessage())->tip($exception::getTip())->line($node->getLine())->build(),`
`100`	`100`	`];`
`101`	`101`	`}`
`102`	`102`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,12 @@`
`2`	`2`
`3`	`3`	`namespace staabm\PHPStanDba;`
`4`	`4`
`5`		`-final class UnresolvableQueryException extends DbaException`
	`5`	`+/**`
	`6`	`+ * @api`
	`7`	`+ */`
	`8`	`+abstract class UnresolvableQueryException extends DbaException`
`6`	`9`	`{`
`7`		`- public const RULE_TIP = 'Make sure all variables involved have a non-mixed type and array-types are specified.';`
	`10`	`+ abstract public static function getTip(): string;`
`8`	`11`
`9`	`12`	`public function asRuleMessage(): string`
`10`	`13`	`{`