code: func (p *PreparedQuery) ExecuteRemote(args *structs.PreparedQueryExecuteRemoteRequest,
  	reply *structs.PreparedQueryExecuteResponse) error {
  	if done, err := p.srv.forward("PreparedQuery.ExecuteRemote", args, args, reply); done {
  		return err
  	}
  	defer metrics.MeasureSince([]string{"prepared-query", "execute_remote"}, time.Now())
  
  	// We have to do this ourselves since we are not doing a blocking RPC.
  	p.srv.setQueryMeta(&reply.QueryMeta)
  	if args.RequireConsistent {
  		if err := p.srv.consistentRead(); err != nil {
  			return err
  		}
  	}
  
  	// Run the query locally to see what we can find.
  	if err := p.execute(&args.Query, reply, args.Connect); err != nil {
  		return err
  	}
  
  	// If they supplied a token with the query, use that, otherwise use the
  	// token passed in with the request.
  	token := args.QueryOptions.Token
  	if args.Query.Token != "" {
  		token = args.Query.Token
  	}
  	if err := p.srv.filterACL(token, &reply.Nodes); err != nil {
  		return err
  	}
  
  	// We don't bother trying to do an RTT sort here since we are by
  	// definition in another DC. We just shuffle to make sure that we
  	// balance the load across the results.
  	reply.Nodes.Shuffle()
  
  	// Apply the limit if given.
  	if args.Limit > 0 && len(reply.Nodes) > args.Limit {
  		reply.Nodes = reply.Nodes[:args.Limit]
  	}
  
  	return nil
  }
docs: // ExecuteRemote is used when a local node doesn't have any instances of a
  // service available and needs to probe remote DCs. This sends the full query
  // over since the remote side won't have it in its state store, and this doesn't
  // do the failover logic since that's already being run on the originating DC.
  // We don't want things to fan out further than one level.