[9.x] Cross-database support for all relations

src/Illuminate/Database/Eloquent/Builder.php

@@ -750,6 +750,8 @@ protected function eagerLoadRelation(array $models, $name, Closure $constraints)
 
         $constraints($relation);
 
+        $this->query->prependDatabaseNameIfCrossDatabaseQuery($relation->getBaseQuery());
+
         // Once we have the results, we just match those back up to their parent models
         // using the relationship instance. Then we just return the finished arrays
         // of models which have been eagerly hydrated and are readied for return.

src/Illuminate/Database/Eloquent/Concerns/QueriesRelationships.php

@@ -54,6 +54,8 @@ public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', C
             $relation->getRelated()->newQueryWithoutRelationships(), $this
         );
 
+        $this->query->prependDatabaseNameIfCrossDatabaseQuery($hasQuery->getQuery());
+
         // Next we will call any given callback as an "anonymous" scope so they can get the
         // proper logical grouping of the where clauses if needed by this Eloquent query
         // builder. Then, we will be ready to finalize and return this query instance.

src/Illuminate/Database/Eloquent/Relations/BelongsToMany.php

@@ -210,9 +210,12 @@ protected function performJoin($query = null)
         // model instance. Then we can set the "where" for the parent models.
         $query->join(
             $this->table,
-            $this->getQualifiedRelatedKeyName(),
-            '=',
-            $this->getQualifiedRelatedPivotKeyName()
+            function ($join) {
+                $join->on($this->getQualifiedRelatedKeyName(), '=', $this->getQualifiedRelatedPivotKeyName());
+                if (is_null($this->using)) {
+                    $join->setConnection($this->parent->getConnection());
+                }
+            }
         );
 
         return $this;
@@ -334,6 +337,10 @@ public function using($class)
     {
         $this->using = $class;
 
+        foreach ($this->query?->getQuery()->joins ?? [] as $join) {
+            $join->setConnection((new $class)->getConnection());
+        }
+
         return $this;
     }
 

src/Illuminate/Database/Eloquent/Relations/HasManyThrough.php

@@ -109,7 +109,13 @@ protected function performJoin(Builder $query = null)
 
         $farKey = $this->getQualifiedFarKeyName();
 
-        $query->join($this->throughParent->getTable(), $this->getQualifiedParentKeyName(), '=', $farKey);
+        $query->join(
+            $this->throughParent->getTable(),
+            function ($join) use ($farKey) {
+                $join->on($this->getQualifiedParentKeyName(), '=', $farKey);
+                $join->setConnection($this->parent->getConnection());
+            }
+        );
 
         if ($this->throughParentSoftDeletes()) {
             $query->withGlobalScope('SoftDeletableHasManyThrough', function ($query) {

src/Illuminate/Database/Query/Builder.php

@@ -110,7 +110,7 @@ class Builder implements BuilderContract
     /**
      * The table joins for the query.
      *
-     * @var array
+     * @var \Illuminate\Database\Query\JoinClause[]|null
      */
     public $joins;
 
@@ -367,8 +367,8 @@ protected function createSub($query)
      */
     protected function parseSub($query)
     {
-        if ($query instanceof self || $query instanceof EloquentBuilder || $query instanceof Relation) {
-            $query = $this->prependDatabaseNameIfCrossDatabaseQuery($query);
+        if ($query instanceof self || $query instanceof EloquentBuilder) {
+            $this->prependDatabaseNameIfCrossDatabaseQuery($query instanceof EloquentBuilder ? $query->getQuery() : $query);
 
             return [$query->toSql(), $query->getBindings()];
         } elseif (is_string($query)) {
@@ -383,21 +383,51 @@ protected function parseSub($query)
     /**
      * Prepend the database name if the given query is on another database.
      *
-     * @param  mixed  $query
-     * @return mixed
+     * @param  self  $query
+     * @return void
+     */
+    public function prependDatabaseNameIfCrossDatabaseQuery($query)
+    {
+        if (($database = $query->getConnection()->getDatabaseName()) !== $this->getConnection()->getDatabaseName()) {
+            $schema = '';
+            if ($query->getConnection()->getDriverName() === 'sqlsrv') {
+                $schema = ($query->getConnection()->getConfig('schema') ?? 'dbo').'.';
+            }
+
+            if ($this->shouldPrefixDatabaseName($query->from, $database)) {
+                $query->from($database.'.'.$schema.$query->from);
+                $query->prependDatabaseNameForJoins();
+            }
+        }
+    }
+
+    /**
+     * Prepend the database name to each join table.
+     *
+     * @return void
      */
-    protected function prependDatabaseNameIfCrossDatabaseQuery($query)
+    public function prependDatabaseNameForJoins()
     {
-        if ($query->getConnection()->getDatabaseName() !==
-            $this->getConnection()->getDatabaseName()) {
-            $databaseName = $query->getConnection()->getDatabaseName();
+        foreach ($this->joins ?? [] as $join) {
+            $schema = '';
+            if ($join->getConnection()->getDriverName() === 'sqlsrv') {
+                $schema = ($join->getConnection()->getConfig('schema') ?? 'dbo').'.';
+            }
 
-            if (! str_starts_with($query->from, $databaseName) && ! str_contains($query->from, '.')) {
-                $query->from($databaseName.'.'.$query->from);
+            if ($this->shouldPrefixDatabaseName($join->table, $joinDatabase = $join->getConnection()->getDatabaseName())) {
+                $join->table = $joinDatabase.'.'.$schema.$join->table;
             }
         }
+    }
 
-        return $query;
+    /**
+     * @param  string  $table
+     * @param  string  $database
+     * @return bool
+     */
+    protected function shouldPrefixDatabaseName($table, $database)
+    {
+        return ! str_starts_with($table, $database) && ! str_contains($table, '.');
     }
 
     /**

src/Illuminate/Database/Query/JoinClause.php

@@ -3,6 +3,7 @@
 namespace Illuminate\Database\Query;
 
 use Closure;
+use Illuminate\Database\ConnectionInterface;
 
 class JoinClause extends Builder
 {
@@ -122,6 +123,19 @@ public function newQuery()
         return new static($this->newParentQuery(), $this->type, $this->table);
     }
 
+    /**
+     * Set the connection for this join clause.
+     *
+     * @param  \Illuminate\Database\ConnectionInterface  $connection
+     * @return $this
+     */
+    public function setConnection(ConnectionInterface $connection)
+    {
+        $this->connection = $connection;
+
+        return $this;
+    }
+
     /**
      * Create a new query instance for sub-query.
      *

tests/Database/DatabaseEloquentBelongsToManyWithDefaultAttributesTest.php

@@ -52,7 +52,9 @@ public function getRelationArguments()
         $related->shouldReceive('getKeyName')->andReturn('id');
         $related->shouldReceive('qualifyColumn')->with('id')->andReturn('users.id');
 
-        $builder->shouldReceive('join')->once()->with('club_user', 'users.id', '=', 'club_user.user_id');
+        $builder->shouldReceive('join')->once()->with(
+            m::on(fn ($arg) => is_string($arg)), m::on(fn ($arg) => is_callable($arg))
+        );
         $builder->shouldReceive('where')->once()->with('club_user.club_id', '=', 1);
         $builder->shouldReceive('where')->once()->with('club_user.is_admin', '=', 1, 'and');
 

tests/Database/DatabaseEloquentBuilderTest.php

@@ -763,7 +763,9 @@ public function testEagerLoadRelationsCanBeFlushed()
 
     public function testRelationshipEagerLoadProcess()
     {
-        $builder = m::mock(Builder::class.'[getRelation]', [$this->getMockQueryBuilder()]);
+        $baseBuilder = $this->getMockQueryBuilder();
+        $baseBuilder->shouldReceive('prependDatabaseNameIfCrossDatabaseQuery')->once();
+        $builder = m::mock(Builder::class.'[getRelation]', [$baseBuilder]);
         $builder->setEagerLoads(['orders' => function ($query) {
             $_SERVER['__eloquent.constrain'] = $query;
         }]);
@@ -772,6 +774,7 @@ public function testRelationshipEagerLoadProcess()
         $relation->shouldReceive('initRelation')->once()->with(['models'], 'orders')->andReturn(['models']);
         $relation->shouldReceive('getEager')->once()->andReturn(['results']);
         $relation->shouldReceive('match')->once()->with(['models'], ['results'], 'orders')->andReturn(['models.matched']);
+        $relation->shouldReceive('getBaseQuery')->once()->andReturn(new \stdClass);
         $builder->shouldReceive('getRelation')->once()->with('orders')->andReturn($relation);
         $results = $builder->eagerLoadRelations(['models']);
 

tests/Database/DatabaseEloquentModelTest.php

@@ -545,6 +545,8 @@ public function testEagerLoadingWithColumns()
     public function testWithWhereHasWithSpecificColumns()
     {
         $model = new EloquentModelWithWhereHasStub;
+        $connection = $this->addMockConnection($model);
+        $connection->shouldReceive('getDatabaseName')->andReturn('forge');
         $instance = $model->newInstance()->newQuery()->withWhereHas('foo:diaa,fares');
         $builder = m::mock(Builder::class);
         $builder->shouldReceive('select')->once()->with(['diaa', 'fares']);
@@ -2524,6 +2526,8 @@ protected function addMockConnection($model)
         $connection->shouldReceive('query')->andReturnUsing(function () use ($connection, $grammar, $processor) {
             return new BaseBuilder($connection, $grammar, $processor);
         });
+
+        return $connection;
     }
 
     public function testTouchingModelWithTimestamps()

tests/Database/DatabaseEloquentMorphToManyTest.php

@@ -101,7 +101,9 @@ public function getRelationArguments()
         $related->shouldReceive('qualifyColumn')->with('id')->andReturn('tags.id');
         $related->shouldReceive('getMorphClass')->andReturn(get_class($related));
 
-        $builder->shouldReceive('join')->once()->with('taggables', 'tags.id', '=', 'taggables.tag_id');
+        $builder->shouldReceive('join')->once()->with(
+            m::on(fn ($arg) => is_string($arg)), m::on(fn ($arg) => is_callable($arg))
+        );
         $builder->shouldReceive('where')->once()->with('taggables.taggable_id', '=', 1);
         $builder->shouldReceive('where')->once()->with('taggables.taggable_type', get_class($parent));