php définition - Comment créer plusieurs requêtes where clause en utilisant Laravel Eloquent?





cours telecharger (13)


utiliser dans quel état et passer le tableau $ array = [1008,1009,1010]; User :: whereIn ('users.id', $ array) -> get ();

J'utilise le constructeur de requête Laravel Eloquent et j'ai une requête où 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 un meilleur moyen de le faire, ou devrais-je m'en tenir à cette méthode?




Conditions utilisant Array:

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

Va produire une requête comme ci-dessous:

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

Conditions utilisant la fonction antonyme:

$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();

Va produire une requête comme ci-dessous:

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



Veillez à appliquer tous les 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();



Vous pouvez utiliser éloquent dans Laravel 5.3

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');



Plusieurs où les clauses

    $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);
    }

finalement obtenir le résultat

    $result = $query->get();



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




Dans Laravel 5.3, vous pouvez utiliser plus de wheres granulaires passées en tableau:

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

Personnellement, je n'ai pas trouvé de cas d'utilisation pour cela sur plusieurs appels d'appels, mais le fait est que vous pouvez l'utiliser.

Depuis juin 2014, vous pouvez passer un tableau à

Tant que vous voulez utiliser toutes les fonctions and opérateurs, vous pouvez les grouper de la façon suivante:

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

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

Alors:

$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 ...)



    $projects = DB::table('projects')->where([['title','like','%'.$input.'%'],
                                                ['status','<>','Pending'],
                                                ['status','<>','Not Available']])
                                    ->orwhere([['owner', 'like', '%'.$input.'%'],
                                                ['status','<>','Pending'],
                                                ['status','<>','Not Available']])->get();



$variable = array('this' => 1,
                    'that' => 1
                    'that' => 1,
                    'this_too' => 1,
                    'that_too' => 1,
                    'this_as_well' => 1,
                    'that_as_well' => 1,
                    'this_one_too' => 1,
                    'that_one_too' => 1,
                    'this_one_as_well' => 1,
                    'that_one_as_well' => 1);

foreach ($variable as $key => $value) {
    User::where($key, '=', $value);
}



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 comme:

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')



Vous pouvez utiliser des sous-requêtes dans une fonction anonyme 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();



Sans un vrai exemple, 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 vous être utile de connaître la normalisation des données: http://en.wikipedia.org/wiki/Third_normal_form




<=> Opérateur de vaisseau spatial

Ajouté en PHP 7

L' opérateur de vaisseau spatial <=> est le dernier opérateur de comparaison ajouté en PHP 7. Il s'agit d'un opérateur binaire non associatif ayant la même priorité que les opérateurs d'égalité ( == != , === !== ). Cet opérateur permet une comparaison tridirectionnelle plus simple entre les opérandes gauche et droit.

L'opérateur résulte en une expression entière de:

  • 0 lorsque les deux opérandes sont égaux
  • Inférieur à 0 lorsque l'opérande gauche est inférieur à l'opérande droit
  • Supérieur à 0 lorsque l'opérande gauche est supérieur à l'opérande droit

par exemple

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Une bonne application pratique de l'utilisation de cet opérateur serait dans les rappels de type comparaison censés renvoyer un entier zéro, négatif ou positif basé sur une comparaison à trois voies entre deux valeurs. La fonction de comparaison transmise à usort est un exemple.

Avant PHP 7, vous écririez ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Depuis PHP 7, vous pouvez écrire ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});




php laravel eloquent