How does Pipeline handle Laravel multi-condition queries?

                                                                                                                                                  

The following tutorial column will introduce to you how Pipeline handles Laravel multi-condition queries. I hope it will be helpful to everyone! Original title: Laravel Eloquent Query Filter using PipelineOriginal link: hafiqiqmal93.medium.com/laravel-eloquent-query-sfilter-using-pipeline-7c6f2673d5da

pipeline

is one of Laravel's particularly useful features. Pipeline is also one of the most commonly used components in Laravel, such as middleware.

One of the features of Laravel which surely useful is the pipeline

. Pipelines is one of the most used components in the Laravel for example middleware.

Basically, through pipes, we can pass objects through the task stack and get the results through callbacks.

Basically, with a pipeline we can pass an object through a stack of tasks and get the result via a callback.

The benefit of pipelines for query filtering is that we Tons of shit can be reduced to a few lines. Before using pipelines, we usually wrote a controller to obtain the Eloquent instance of the user model and splice some conditions based on the query string.

The benefit of pipeline for query filtering is that we can reduce tons of lines to several lines. Being unaware of the pipelines, we would usually set up a controller, get an instance of Eloquent of User model , and apply some condition based on query string.

Let’s take a look at the Shishan query method below.

Let’s see below queries.

$query = User::query();if ($request->username) {
    $query->where('username', 'LIKE', "%$request->username%");}if ($request->email) {
    $query->where('email', 'LIKE', "%$request->email%");}if ($request->address) {
    $query->where('address', 'LIKE', "%$request->address%");}if ($request->occupation) {
    $query->where('occupation', 'LIKE', "%$request->occupation%");}return $query->get();

The shortcomings are obvious. The filtering conditions are constantly piling up like a mountain of shit, and a large number of duplicate codes appear. In addition, the maintainability of the code is a bit of a headache.

The drawback is that, it's obviously that filters conditions will continue to grow as well as duplication of the same filter for other query. In other hand, the maintainability of the code kind of headache.

Let’s take a look at the elegant way pipelines are handled

There is where Pipeline become a hero

return User::query()->filter([ 
    UsernameFilter::class,
    EmailFilter::class,
    AddressFilter::class,
    OccupationFilter::class])->get();

Simple and short, right? Take a look at the following stepsSimple and short right? But before that,

1. Create a trait class named "Filterable" and write a scope method

Create a trait named

Filterable

and create a scope

1. <pre class="brush:php;toolbar:false">class Filterable{         public function scopeFilter($query, array $through)        {                     return app(Pipeline::class)                    -&gt;send($query)                                -&gt;through($through)                                -&gt;thenReturn();            }}</pre>Then, you can happily use it in any Model Reuse it, such as User model

Then, use it in any model that you prefer, for example User model

class User {
    use Filterable; }

2. Create a Filter, for example

UsernameFilter

2. Create a filter for example UsernameFilter

class UsernameFilter {
    public function handle($query, $next)
    {        
        if (request()->mobile_phone) {           
           $query->where('username', request()->mobile_phone);      
        }         
        return $next($query);  
    }}

Instructions:

The usage is just like this

User::query()->filter([UsernameFilter::class])->get();

or

OR

you still Pipes can be used by passing properties.

If you want for more accessibility to the pipeline, you can also pass an attribute.

class StringFilter {
    public function handle($query, $next, $column) {
        if (request()->{$column}) {           
            $query->where($column, 'LIKE', request()->{$column});      
        } 
        return $next($query); 
    }}

Use like this

The usage is just like this

User::query()->filter([
   'StringFilter:username',
   'StringFilter:email',])->get();

Get it done, be elegant!

Done. Simple and clean

Recommended: "

The latest five Laravel video tutorials

" ##

The above is the detailed content of How does Pipeline handle Laravel multi-condition queries?. For more information, please follow other related articles on the PHP Chinese website!