web-dev-qa-db-fra.com

Comment créer plusieurs requêtes de clause Where en utilisant Laravel Eloquent?

J'utilise le constructeur de requêtes Laravel Eloquent et j'ai une requête pour laquelle je veux une clause WHERE sur plusieurs conditions. Cela fonctionne, mais ce n'est pas élégant.

Exemple:

$results = User::where('this', '=', 1)
    ->where('that', '=', 1)
    ->where('this_too', '=', 1)
    ->where('that_too', '=', 1)
    ->where('this_as_well', '=', 1)
    ->where('that_as_well', '=', 1)
    ->where('this_one_too', '=', 1)
    ->where('that_one_too', '=', 1)
    ->where('this_one_as_well', '=', 1)
    ->where('that_one_as_well', '=', 1)
    ->get();

Y a-t-il une meilleure façon de faire cela, ou devrais-je m'en tenir à cette méthode?

phplaraveleloquentlaravel-query-builder
320
veksen

Dans Laravel 5. vous pouvez utiliser plus de détails où la classification est passée:

$query->where([
    ['column_1', '=', 'value_1'],
    ['column_2', '<>', 'value_2'],
    [COLUMN, OPERATOR, VALUE],
    ...
])

Personnellement, je n'ai pas trouvé de cas d'utilisation correspondant à plusieurs appels where, mais vous pouvez l'utiliser.

Depuis juin 2014, vous pouvez passer un tableau à where

Tant que vous voulez que tous les opérateurs wheres utilisent and, vous pouvez les regrouper comme suit:

$matchThese = ['field' => 'value', 'another_field' => 'another_value', ...];

// if you need another group of wheres as an alternative:
$orThose = ['yet_another_field' => 'yet_another_value', ...];

Ensuite:

$results = User::where($matchThese)->get();

// with another group
$results = User::where($matchThese)
    ->orWhere($orThose)
    ->get();

Ce qui précède entraînera une telle requête:

SELECT * FROM users
  WHERE (field = value AND another_field = another_value AND ...)
  OR (yet_another_field = yet_another_value AND ...)
488
Jarek Tkaczyk

Les portées de requête peuvent vous aider à rendre votre code plus lisible.

http://laravel.com/docs/eloquent#query-scopes

Mise à jour de cette réponse avec un exemple:

Dans votre modèle, créez des méthodes d'étendues comme ceci:

public function scopeActive($query)
{
    return $query->where('active', '=', 1);
}

public function scopeThat($query)
{
    return $query->where('that', '=', 1);
}

Ensuite, vous pouvez appeler ces portées lors de la création de votre requête:

$users = User::active()->that()->get();
79
Luis Dalmolin

Vous pouvez utiliser des sous-requêtes dans des fonctions anonymes comme ceci:

 $results = User::where('this', '=', 1)
            ->where('that', '=', 1)
            ->where(function($query) {
                /** @var $query Illuminate\Database\Query\Builder  */
                return $query->where('this_too', 'LIKE', '%fake%')
                    ->orWhere('that_too', '=', 1);
            })
            ->get();
62
Juljan

Dans ce cas, vous pouvez utiliser quelque chose comme ceci:

User::where('this', '=', 1)
    ->whereNotNull('created_at')
    ->whereNotNull('updated_at')
    ->where(function($query){
        return $query
        ->whereNull('alias')
        ->orWhere('alias', '=', 'admin');
    });

Il devrait vous fournir une requête du type:

SELECT * FROM `user` 
WHERE `user`.`this` = 1 
    AND `user`.`created_at` IS NOT NULL 
    AND `user`.`updated_at` IS NOT NULL 
    AND (`alias` IS NULL OR `alias` = 'admin')
31
alexglue

Conditions utilisant Array:

$users = User::where([
       'column1' => value1,
       'column2' => value2,
       'column3' => value3
])->get();

Produira une requête semblable à celle-ci: 

SELECT * FROM TABLE WHERE column1=value1 and column2=value2 and column3=value3

Conditions utilisant la fonction anonyme:

$users = User::where('column1', '=', value1)
               ->where(function($query) use ($variable1,$variable2){
                    $query->where('column2','=',$variable1)
                   ->orWhere('column3','=',$variable2);
               })
              ->where(function($query2) use ($variable1,$variable2){
                    $query2->where('column4','=',$variable1)
                   ->where('column5','=',$variable2);
              })->get();

Produira une requête semblable à celle-ci: 

SELECT * FROM TABLE WHERE column1=value1 and (column2=value2 or column3=value3) and (column4=value4 and column5=value5)
21
srmilon

Plusieurs clauses where

    $query=DB::table('users')
        ->whereRaw("users.id BETWEEN 1003 AND 1004")
        ->whereNotIn('users.id', [1005,1006,1007])
        ->whereIn('users.id',  [1008,1009,1010]);
    $query->where(function($query2) use ($value)
    {
        $query2->where('user_type', 2)
            ->orWhere('value', $value);
    });

   if ($user == 'admin'){
        $query->where('users.user_name', $user);
    }

obtenant finalement le résultat

    $result = $query->get();
9
Majbah Habib

La méthode whereColumn peut recevoir un tableau de plusieurs conditions. Ces conditions seront jointes à l'aide de l'opérateur and.

Exemple: 

$users = DB::table('users')
            ->whereColumn([
                ['first_name', '=', 'last_name'],
                ['updated_at', '>', 'created_at']
            ])->get();

$users = User::whereColumn([
                ['first_name', '=', 'last_name'],
                ['updated_at', '>', 'created_at']
            ])->get();

Pour plus d'informations, consultez cette section de la documentation https://laravel.com/docs/5.4/queries#where-clauses

8
Alex Quintero
Model::where('column_1','=','value_1')->where('column_2 ','=','value_2')->get();

OR

// If you are looking for equal value then no need to add =
Model::where('column_1','value_1')->where('column_2','value_2')->get();

OR

Model::where(['column_1' => 'value_1','column_2' => 'value_2'])->get();
7
DsRaj
$projects = DB::table('projects')->where([['title','like','%'.$input.'%'],
    ['status','<>','Pending'],
    ['status','<>','Not Available']])
->orwhere([['owner', 'like', '%'.$input.'%'],
    ['status','<>','Pending'],
    ['status','<>','Not Available']])->get();
5
Lim Kean Phang

Veillez à appliquer d'autres filtres aux sous-requêtes, sinon le ou pourrait rassembler tous les enregistrements.

$query = Activity::whereNotNull('id');
$count = 0;
foreach ($this->Reporter()->get() as $service) {
        $condition = ($count == 0) ? "where" : "orWhere";
        $query->$condition(function ($query) use ($service) {
            $query->where('branch_id', '=', $service->branch_id)
                  ->where('activity_type_id', '=', $service->activity_type_id)
                  ->whereBetween('activity_date_time', [$this->start_date, $this->end_date]);
        });
    $count++;
}
return $query->get();
5
adamk

Vous pouvez utiliser eloquent dans Laravel 5.

Tous les résultats

UserModel::where('id_user', $id_user)
                ->where('estado', 1)
                ->get();

Résultats partiels

UserModel::where('id_user', $id_user)
                    ->where('estado', 1)
                    ->pluck('id_rol');
3
Cristhian Carreño

utiliser la condition whereIn et passer le tableau

$array = [1008,1009,1010];

User::whereIn('users.id', $array)->get();

2
Rahul Tathod

Sans un exemple réel, il est difficile de faire une recommandation. Cependant, je n'ai jamais eu besoin d'utiliser autant de clauses WHERE dans une requête et cela peut indiquer un problème avec la structure de vos données.

Il peut être utile que vous en appreniez sur la normalisation des données: http://en.wikipedia.org/wiki/Third_normal_form

2
Aaron Cicali

Vous pouvez utiliser array dans la clause where comme indiqué ci-dessous.

$result=DB::table('users')->where(array(
'column1' => value1,
'column2' => value2,
'column3' => value3))
->get();
1
Abhijeet Navgire
DB::table('users')
            ->where('name', '=', 'John')
            ->orWhere(function ($query) {
                $query->where('votes', '>', 100)
                      ->where('title', '<>', 'Admin');
            })
            ->get();
1
pardeep

Selon ma suggestion, si vous filtrez ou recherchez

alors vous devriez aller avec:

        $results = User::query();
        $results->when($request->that, function ($q) use ($request) {
            $q->where('that', $request->that);
        });
        $results->when($request->this, function ($q) use ($request) {
            $q->where('this', $request->that);
        });
        $results->when($request->this_too, function ($q) use ($request) {
            $q->where('this_too', $request->that);
        });
        $results->get();
0
Dhruv Raval

En utilisant purement Eloquent, implémentez-le comme tel. Ce code renvoie tous les utilisateurs connectés dont les comptes sont actifs. $users = \App\User::where('status', 'active')->where('logged_in', true)->get();

0
Craig GeRa

Utilisez ceci

$users = DB::table('users')
                    ->where('votes', '>', 100)
                    ->orWhere('name', 'John')
                    ->get();
0
Sooraj Thekkepatt