Use the connection passed to ActiveQuery result methods for schema reflection and typecasting while populating records. (#21049)

Author: terabytesoftw

framework/CHANGELOG.md

@@ -153,6 +153,7 @@ Yii Framework 2 Change Log
 - Bug #17545: Apply PostgreSQL transaction isolation levels after starting the transaction, via the new `yii\db\pgsql\Transaction` class resolved through `yii\db\Connection::$transactionMap` (terabytesoftw)
 - Bug #16043: Fix `yii\db\oci\Schema::findColumns()` to report `null` size for `DATE`, `TIMESTAMP` and `INTERVAL` columns instead of their internal storage byte length (terabytesoftw)
 - Bug #12763: Apply an explicitly configured PostgreSQL `defaultSchema` as the session `search_path` when opening the connection (terabytesoftw)
+- Bug #19852: Use the connection passed to `ActiveQuery` result methods for schema reflection and typecasting while populating records (terabytesoftw)
 
 2.0.56 under development
 ------------------------

framework/UPGRADE-22.md

@@ -317,6 +317,9 @@ Notable changes include:
   types; `getRawValuesFromTraversableObject()` was removed.
 - MSSQL `PDO`, `DBLibPDO`, and `SqlsrvPDO` overrides now declare native PDO-compatible parameter and return types.
 - `yii\rbac\DbManager` and its new cascade extension points declare native parameter and return types.
+- The database connection used to fetch query results is now passed through `Query::populate()`,
+  `ActiveQueryTrait::createModels()`, `ActiveRecord::populateRecord()`, and `ActiveRecord::getTableSchema()`. Overrides
+  of these methods must accept the new optional `$db` parameter and forward it when calling the parent implementation.
 
 Run the application's static analysis and test suite after upgrading. Pay particular attention to classes extending
 `Action`, `InlineAction`, `InConditionBuilder`, a database query builder, a database schema class, an MSSQL PDO wrapper,
@@ -348,6 +351,28 @@ Yii2 `22.0` adds standalone action discovery through `Module::$actionMap`, `Modu
 
 ## Database abstraction layer
 
+### Active Record population uses the query connection
+
+Passing a connection to `ActiveQuery::all()`, `one()`, `batch()`, or `each()` now uses the same connection for schema
+reflection and column typecasting. Previously, the rows were fetched from the supplied connection but
+`ActiveRecord::populateRecord()` reflected the schema through `ActiveRecord::getDb()`.
+
+Custom overrides of `populateRecord()` must accept and forward the connection:
+
+```php
+public static function populateRecord($record, $row, $db = null): void
+{
+    parent::populateRecord($record, $row, $db);
+
+    // Custom population logic.
+}
+```
+
+The attribute list still comes from `attributes()`, which reflects the schema through `getDb()` by default. A model
+whose table is only reachable through another connection must define that connection on the model by overriding
+`getDb()`, or declare its attribute list explicitly by overriding `attributes()`. The same applies to `primaryKey()`,
+which join deduplication and other primary-key dependent features resolve through the default schema.
+
 ### Composite `IN` and `NOT IN` conditions
 
 `yii\db\conditions\InCondition` now normalizes `Traversable` columns and values to arrays and caches the normalized

framework/db/ActiveQuery.php

@@ -10,6 +10,8 @@
 
 use yii\base\InvalidConfigException;
 
+use function reset;
+
 /**
  * ActiveQuery represents a DB query associated with an Active Record class.
  *
@@ -220,16 +222,18 @@ public function prepare($builder)
     /**
      * {@inheritdoc}
      */
-    public function populate($rows)
+    public function populate($rows, $db = null)
     {
         if (empty($rows)) {
             return [];
         }
 
-        $models = $this->createModels($rows);
+        $models = $this->createModels($rows, $db);
+
         if (!empty($this->join) && $this->indexBy === null) {
             $models = $this->removeDuplicatedModels($models);
         }
+
         if (!empty($this->with)) {
             $this->findWith($this->with, $models);
         }
@@ -244,7 +248,7 @@ public function populate($rows)
             }
         }
 
-        return parent::populate($models);
+        return parent::populate($models, $db);
     }
 
     /**
@@ -303,17 +307,20 @@ private function removeDuplicatedModels($models)
 
     /**
      * Executes query and returns a single row of result.
-     * @param Connection|null $db the DB connection used to create the DB command.
-     * If `null`, the DB connection returned by [[modelClass]] will be used.
-     * @return T|null a single row of query result. Depending on the setting of [[asArray]],
-     * the query result may be either an array or an ActiveRecord object. `null` will be returned
-     * if the query results in nothing.
+     *
+     * @param Connection|null $db the DB connection used to create the DB command. If `null`, the DB connection returned
+     * by [[modelClass]] will be used.
+     *
+     * @return T|null a single row of query result. Depending on the setting of [[asArray]], the query result may be
+     * either an array or an ActiveRecord object. `null` will be returned if the query results in nothing.
      */
     public function one($db = null)
     {
         $row = parent::one($db);
+
         if ($row !== false) {
-            $models = $this->populate([$row]);
+            $models = $this->populate([$row], $db);
+
             return reset($models) ?: null;
         }
 

framework/db/ActiveQueryTrait.php

@@ -106,24 +106,35 @@ public function with()
 
     /**
      * Converts found rows into model instances.
-     * @param array $rows
-     * @return array|ActiveRecord[]
+     *
+     * @param array $rows The rows to be converted into model instances. Each array element represents a row of data.
+     * @param Connection|null $db The database connection used to retrieve the rows.
+     *
+     * @return array|BaseActiveRecord[] The model instances created from the rows. If [[asArray]] is true, the rows
+     * will be returned as is.
      * @since 2.0.11
      */
-    protected function createModels($rows)
+    protected function createModels($rows, $db = null)
     {
         if ($this->asArray) {
             return $rows;
         } else {
             $models = [];
-            /** @var ActiveRecord $class */
+            /** @var class-string<BaseActiveRecord> $class */
             $class = $this->modelClass;
+
             foreach ($rows as $row) {
                 $model = $class::instantiate($row);
-                $modelClass = get_class($model);
-                $modelClass::populateRecord($model, $row);
+
+                if ($model instanceof ActiveRecord) {
+                    $model::populateRecord($model, $row, $db);
+                } else {
+                    $model::populateRecord($model, $row);
+                }
+
                 $models[] = $model;
             }
+
             return $models;
         }
     }

framework/db/ActiveRecord.php

@@ -425,12 +425,19 @@ public static function tableName()
 
     /**
      * Returns the schema information of the DB table associated with this AR class.
-     * @return TableSchema the schema information of the DB table associated with this AR class.
+     *
+     * @param Connection|null $db The database connection used to retrieve the schema. If `null`, the connection
+     * returned by [[getDb()]] will be used.
+     *
      * @throws InvalidConfigException if the table for the AR class does not exist.
+     *
+     * @return TableSchema The schema information of the DB table associated with this AR class.
      */
-    public static function getTableSchema()
+    public static function getTableSchema($db = null)
     {
-        $tableSchema = static::getDb()
+        $db = $db ?? static::getDb();
+
+        $tableSchema = $db
             ->getSchema()
             ->getTableSchema(static::tableName());
 
@@ -503,15 +510,19 @@ public function transactions()
 
     /**
      * {@inheritdoc}
+     *
+     * @param Connection|null $db The database connection used to retrieve the row and its schema.
      */
-    public static function populateRecord($record, $row)
+    public static function populateRecord($record, $row, $db = null)
     {
-        $columns = static::getTableSchema()->columns;
+        $columns = static::getTableSchema($db)->columns;
+
         foreach ($row as $name => $value) {
             if (isset($columns[$name])) {
                 $row[$name] = $columns[$name]->phpTypecast($value);
             }
         }
+
         parent::populateRecord($record, $row);
     }
 

framework/db/BatchQueryResult.php

@@ -172,7 +172,7 @@ protected function fetchData()
 
         $rows = $this->getRows();
 
-        return $this->query->populate($rows);
+        return $this->query->populate($rows, $this->db);
     }
 
     /**

framework/db/Query.php

@@ -272,22 +272,28 @@ public function all($db = null)
 
         $rows = $this->createCommand($db)->queryAll();
 
-        return $this->populate($rows);
+        return $this->populate($rows, $db);
     }
 
     /**
      * Converts the raw query results into the format as specified by this query.
-     * This method is internally used to convert the data fetched from database
-     * into the format as required by this query.
-     * @param array $rows the raw query result from database
-     * @return array the converted query result
+     *
+     * This method is internally used to convert the data fetched from database into the format as required by this
+     * query.
+     *
+     * @param array $rows The raw query result from database.
+     * @param Connection|null $db The database connection used to retrieve the rows.
+     *
+     * @return array The converted query result.
      */
-    public function populate($rows)
+    public function populate($rows, $db = null)
     {
         if ($this->indexBy === null) {
             return $rows;
         }
+
         $result = [];
+
         foreach ($rows as $row) {
             $result[ArrayHelper::getValue($row, $this->indexBy)] = $row;
         }