Forem: Parixit Patel

Some of the ways to optimize eloquent query on Laravel

Parixit Patel — Thu, 01 Oct 2020 11:01:34 +0000

When we are working with large numbers of data & needs a frequent call to database queries then we must optimize database queries to make the application faster. I have listed some of the ways which can be useful to optimize a query.

Use Indexes

By using a database index, We can significantly improve the speed of retrieving data from a table because it's used to quickly find rows without having to scan the whole table every time. We can add an index for columns which we are frequently using in where clause like integer or boolean columns, datetime columns, etc.

Lets assume we have ~2 million records on Orders table and we want Orders of perticular Product. So we will query like below :

$orders = Orders::where('product_id', $productId)->get();

When the above query runs, it will scan all of the 2 million rows (as we didn't use any index yet) and return orders of that product. It will take around ~2 sec which is not good. Use EXPLAIN it will show 2 millions rows scanned and no key used.

Use EXPLAIN statement which provides information about how MySQL executes statements, which are available keys, which key is used to scan records and how many rows scanned etc..

Now add an index on Orders table.

In laravel, We can add index on migration by using $table->index() method like below :

Schema::table('orders', function (Blueprint $table) {
    $table->index('product_id');
});

This will create new index orders_product_id_index. Now if you run same query it will only take ~500 ms. Run EXPLAIN you will see difference in number of rows scanned, possible_keys and key.

We can also create Compound Index if we use multiple WHERE clauses in the query. which will include every field from WHERE clause. The order of the fields in a compound index can also have an impact. Generally, they should be ordered most common to the least common.

Say our query is :

$orders = Orders::where(['product_id' => $productId, 'status' => 1])->get();

We could add a compound index like this :

Schema::table('orders', function (Blueprint $table) {
    $table->index(['product_id', 'status']);
});

Prevent n+1 database queries

Consider example to understand what is n+1 query :

$customers = Customer::findMany($ids);
$orders = collect();

foreach ($customers as $customer) {
    $orders = $orders->merge($customer->orders);
}

When the above query executes SQL query like this gets generated :

SELECT * FROM customers WHERE id IN ($ids);
SELECT * FROM orders WHERE customer_id = $id; // execute in loop foreach customer

Here, the second query will be executed for each customer so if we have 500 customers it will be executed 500 times. So total 1 ( Query to get customers data) and 500 (Query to get orders for each customer) will be executed. So we can say n+1 query executes here for a single operation.

To prevent n+1 query, we can use eager loading technique. In which we can get everything in single query by using model relation.

$orders = Customer::findMany($ids)->with('orders')->get();

The above query will generate SQL :

SELECT * FROM customers INNER JOIN orders ON customers.id = orders.customer_id WHERE customers.id IN ($ids);

Eager Loading is best practice when we are working with relational tables.

*Do not use asterisk wildcard (***) everywhere*

$orders = Orders::all();

Many times while we are fetching data from the database we run queries like above. which will select all the data from the table but This is a bad practice you must avoid. Because it will perform extra queries, sometimes we don't use all of the columns and it will affect the performance of the application when the number of records increases on the database.

Best practice is to select fields which actually in use.

Use raw methods for a raw expression

Sometimes we need Raw Expression in a query which will be achieved by using raw methods like selectRaw, whereRaw , havingRaw , orderByRaw etc.

Which we are using it like :

$products = Products::select('name','quantity','description',\DB::raw("GROUP_CONCAT(orders.id) AS orders"))
                  ->leftJoin('orders','orders.product_id','=','product_id');
                  ->where('orders.status', 1)
                  ->get();

Notice that, here it will run 2 queries into one.

First query :

$products = Products::select('name','quantity','description')
                ->leftJoin('orders','orders.product_id','=','product_id');
                ->where('orders.status', 1)
                ->get();

Another query :

\DB::raw("GROUP_CONCAT(orders.id) AS orders")

In order to use both queries into one, we should use it like this :

$products = Products::selectRaw('name,quantity,description,GROUP_CONCAT(orders.id) as orders')
                ->leftJoin('orders','orders.product_id','=','product_id');
                ->where('orders.status', 1)
                ->get();

Same for where clause :

$orders = Orders::whereRaw('YEAR(order_date) = YEAR(CURRENT_DATE)');

I hope these techniques will decrease the execution time of eloquent queries.

Laravel + Vue.js Demo Application

Parixit Patel — Wed, 29 Jul 2020 11:27:55 +0000

Check this out : Laravel + Vue.js Demo Application

This repository demonstrate the use of Vue.js with Laravel that can be useful for beginners. Review the code to understand how different components working.

It demonstrate use of VueJs concepts like Two Way Binding, Computed Property, Components, Sub-Components, Vue Router, Vue Portal, Filters, CRUD etc.. Also contains useful components like Testimonials, Accordion, Carousel, Counter etc.

...

Laravel IP Whitelisting

Parixit Patel — Mon, 20 Jul 2020 13:09:49 +0000

Simple Laravel Package to increase the security of the website by permitting access for users having whitelisted IP Addresses.

In this package, you can add IP Addresses into whitelist which you want to allow access to your site. All other users coming from IPs that are not in the whitelist will automatically be blocked and won't access the site.

Check out the package: Laravel IP Whitelisting

PHP 7 - Two useful operators, You Need to Know

Parixit Patel — Fri, 17 Jul 2020 13:50:11 +0000

Spaceship operator:

We all are using comparison operators like greater than (>), less than (<), greater than equals(>=), less than equals (<=), etc. These operators are very useful in daily programming tasks.

In PHP 7, We have one more comparison operator Spaceship Operator (<=>). This operator is used to compare expressions.

It will Return 0 if values on either side are equal, Return 1 if the value on the left is greater, Return -1 if the value on the right is greater.

<?php

echo 5 <=> 5; // Output 0 as 5 equals to 5
echo 4 <=> 5; // Output -1 as 4 is less than 5
echo 6 <=> 5; // Output 1 as 6 is greater than 5

Example :

Suppose, we have an array of products having product name & price like below :

$products = [
                ['name' => 'Product 1', 'price' => '25'],
                ['name' => 'Product 2', 'price' => '50'],
                ['name' => 'Product 3', 'price' => '46'],
                ['name' => 'Product 4', 'price' => '80'],
                ['name' => 'Product 5', 'price' => '15'],
            ];

And we want to sort it by price so that products with the highest price should come first on the array. For that, we can use usort function of PHP with a spaceship operator like below :

<?php

usort($products, function ($prod1, $prod2) {
    return $prod2['price'] <=> $prod1['price'];
});

print_r($products);

Output :

// The output will be sorted products by price in descending order.

$products = [
                ['name' => 'Product 4', 'price' => '80'],
                ['name' => 'Product 2', 'price' => '50'],
                ['name' => 'Product 3', 'price' => '46'],
                ['name' => 'Product 1', 'price' => '25'],               
                ['name' => 'Product 5', 'price' => '15'],
            ];

Null coalescing operator:

Another cool operator is Null Coalescing Operator (??). which can be replacement of the ternary operator ( isset($a) ? $a : $b ) in conjunction with isset() function.

If you ever used Javascript or VueJs you might be familiar with this operator already.

The null coalescing operator returns its first operand if it exists and is not NULL; otherwise, it returns its second operand.

<?php

$authorName = $author ?? 'Unknown'; 
// Output author name if $author is set or else 'Unknown'

// This is equivalent to:
$authorName = isset($author) ? $author : 'Unknown';

The null coalescing operator can be chained and will return the first defined value from chain.

<?php

$authorName = $author ?? $currentUser ?? 'Unknown';

It will return author name from first defined value out of $author, $currentUser if both are not set then return 'Unknown'.

...

Laravel Service Providers

Parixit Patel — Fri, 17 Jul 2020 13:07:49 +0000

In this post, we will discuss Service Providers and how Service Providers used to register classes. There are two important methods of service providers Boot and Register. So will discuss these two methods.

Service providers are the central place of all Laravel application bootstrapping. Your own application, as well as all of Laravel's core services, are bootstrapped via service providers.

In simple terms, Service Provider is used for registering things, including registering service container bindings. So it's a place where you can register service container bindings.

Service providers contains register and boot method. Within the register method, you should only define service container bindings. You have always access to service containers from service provider via $this->app.

To register the service provider, you just need to add an entry to the provider's array in the config/app.php file. These are all of the service provider classes that will be loaded for your application.

Let's understand both methods register and boot by creating a custom service provider.

In Laravel, you can use the command-line utility tool Artisan to create custom providers. Just hit below artisan command to create a provider.

php artisan make:provider ProductServiceProvider

This will create new file ProductServiceProvider.php under app/providers.

The content of this file will be looks like :

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class ProductServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap the application services.
     *
     * @return void
     */
    public function boot()
    {
        //
    }

    /**
     * Register the application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

Here, we have created our first custom service provider Now add an entry in providers array under config/app.php file so that laravel loads this provider along with other providers during bootstrapping process.

So open config/app.php file and append line App\Providers\ProductServiceProvider::class

'providers' => [
        App\Providers\ProductServiceProvider::class,
],

Till now we have created a custom service provider and added an entry on providers array. But still, our service provider doesn't do anything special here. it's just a blank template. So let's try to register class binding inside the register method.

Open ProductServiceProvider.php file and update with below code :

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Library\ProductClass;
use App\Repositories\ProductRepository;

class ProductServiceProvider extends ServiceProvider
{
    public function boot()
    {
    }

    public function register()
    {
        $this->app->bind(ProductRepository::class, ProductClass::class);
    }
}

In the register method, we've added our service container binding. So, whenever the App\Repositories\ProductRepository dependency needs to be resolved, it'll call the closure function, and it returns the instance of App\Library\ProductClass class.

Let's create ProductRepository and ProductClass :

App\Repositories\ProductRepository.php

<?php

namespace App\Repositories;

Interface ProductRepository
{
    public function listAll();
}

App\Library\ProductClass.php

<?php

namespace App\Library;

use App\Repositories\ProductRepository;
use App\Models\Products;

class ProductClass implements ProductRepository
{
    public function listAll()
    {
        return Products::all();
    }
}

So we have ProductClass and ProductRepository class created. Now inject dependency somewhere on a controller.

For that, create Controller and put below code inside it :

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Repositories\ProductRepository;

class ProductController extends Controller
{
    protected $prodRepository;

    public function __construct(ProductRepository $prodRepository)
    {
        $this->prodRepository = $prodRepository;
    }

    public function index()
    {
        $products = $this->prodRepository->listAll();
        return view('prodducts.list',['products'=>$products]);
    }
}

When the above code executed it will list products on the webpage. This is a basic concept of the service provider and the beauty of this concept is you can easily swap to other implementation. If you need implementation of SomeOtherClass instead of ProductClass then you just need to update ProductServiceProvider binding with other classes.

That's it, We have created custom service provider ProductServiceProvider and bind the ProductRepository interface inside the register method. Then we create ProductClass which implements the ProductRepository interface. And demonstrate how dependency injected on ProductController.

Boot Method

Boot method, which you can use to extend the core functionality or create custom functionality. In this method, you could access all the services that were registered using the register method of the service provider.

For Example,

You could use this method to add a custom validator,

public function boot()
{
    Validator::extend('custom_validator', function ($attribute, $value, $parameters, $validator) {
        // validation logic goes here...
    });
}

You could use to register a view composer,

public function boot()
{
    View::composer(
        'custom', 'App\Http\ViewComposers\CustomComposer'
    );
}

You could use to share the data across multiple views,

public function boot()
{
    View::share('key', 'value');
}

Hope this post helps you to understand Service Provider uses and the creation of custom service providers.

Thank you.

Laravel Service Container

Parixit Patel — Thu, 16 Jul 2020 08:28:13 +0000

In this post, we will discuss the most important aspect of Laravel framework Service Container.

Let's understand the definition first...

The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection. Dependency injection is a fancy phrase that essentially means this: class dependencies are “injected” into the class via the constructor or, in some cases, “setter” methods.

In simple terms, the service container is a container that holds all the bindings that need to run Laravel application smoothly.you can bind almost everything you’d like to instantiate programmatically later in your application when needed. That means Service Container holds a single object of all of our various bindings.

So whenever, you need to use any inbuilt or custom service you can type-hint in a class constructor or method it will automatically be injected from service container as its container that holds all class dependencies.

Let's assume, we have one class with the name MathService which used to do some basic operations like addition, multiplication, etc. Below is the code of this class.

App\Services\MathService.php

<?php

namespace App\Services;
class MathService
{
    public function doAddition($numbers)
    {
        return array_sum($numbers);
    }

    public function doMultiplication($numbers)
    {
        return array_product($numbers);
    }
}

As you can see, there two methods on \App\Services\MathService class doAddition which calculates the sum of numbers provided in array using array_sum function and doMultiplication which multiplies all the numbers provided as an array using array_product function.

To use services provided by \App\Services\MathService class we first need to bind it with service containers. the binding will be like following, we just need to pass the path of MathService class and it will be bind on the container.

<?php

App::bind('MathService',\App\Services\MathService::class);

By doing this, we are telling laravel to store \App\Services\MathService class in the container with label MathService and return it back when we need an instance of a class. This is one time binding of class and can get any number of instances from our application.

Now suppose we require service provided by \App\Services\MathService class in any of our application functionality. To achieve this, we first need to resolve service that we already bound in the container and then call respective methods.

To resolve service from our application can use either of two ways...

<?php

$mathService = app()->make('MathService');

// or

$mathService = resolve('MathService');

The service is resolved now. we can call doAddition & doMultiplication methods from our application.

<?php

$sum = $mathService->doAddition([40, 20, 10]);
$product = $mathService->doMultiplication([4, 2, 3]);

print_r($sum);
print_r($product);

// Result: Sum => 70, Product => 24

Automatic Dependency Injection

Important note from the Laravel documentation:

There is no need to bind classes into the container if they do not depend on any interfaces. The container does not need to be instructed on how to build these objects since it can automatically resolve these objects using reflection.

Here, Actually we don't need to bind class on the container. We can just type-hint dependencies directly on the method or constructor of a controller like below.

<?php

function index(MathService $mathService)
{
    $sum = $mathService->doAddition([40, 20, 10]);
    $product = $mathService->doMultiplication([4, 2, 3]);
}

This is just the basic of service container in which we bind service and use it on our app. But remember, All the binding of services like this should be always on register method of Service Providers.

Interface binding

On Service Container we can also bind a specific implementation of an interface to it, in this way whenever we resolve this interface we will end up with the concrete class that is bound to it.

For the above example, We can create Interface and two classes with different implementation and bind any of the implementations to the container.

Let's create MathServiceInterface

App\Services\MathServiceInterface.php

<?php

namespace App\Services;
Interface MathServiceInterface
{
    public function doAddition(array $numbers);

    public function doMultiplication(array $numbers);
}

MathService which implements MathServiceInterface

App\Services\MathService.php

<?php

namespace App\Services;
class MathService implements MathServiceInterface
{
    public function doAddition($numbers)
    {
        return array_sum($numbers);
    }

    public function doMultiplication($numbers)
    {
        return array_product($numbers);
    }
}

CustomMathService which also implements MathServiceInterface

App\Services\CustomMathService.php

<?php

namespace App\Services;
class CustomMathService implements MathServiceInterface
{
    public function doAddition($numbers)
    {
        $sum = 0;
        foreach($numbers as $num)
        {
            $sum = $sum + $num;
        }
        return $sum;
    }

    public function doMultiplication($numbers)
    {
        $product = 1;
        foreach($numbers as $num)
        {
            $product = $product*$num;
        }
        return $product;
    }
}

As you can see, we have two different classes MathService & CustomMathService with a different implementation of doAddition & doMultiplication methods.

Now instead of binding these classes on container lets bind MathServiceInterface with the container.

<?php

App::bind('\App\Services\MathServiceInterface', function () {
    return new \App\Services\MathService();
});

Here, when MathServiceInterface will be resolved, Laravel gives us an instance of MathService class. And by calling methods using this instance will get results using MathService class implementation.

Controller:

<?php

public function index() {
    $mathService = app()->make('\App\Services\MathServiceInterface');
    $sum = $mathService->doAddition([40, 20, 10]);
    $product = $mathService->doMultiplication([4, 2, 3]);   
    /*
    This will calculate results 
    using MathService class implementation
    */
}

Now if we want other implementation called CustomMathService of MathServicesInterface then just need to change in binding.

<?php

App::bind('\App\Services\MathServiceInterface', function () {
    return new \App\Services\CustomMathService();
});

The code will still work the same as earlier but with a different implementation of CustomMathService class. this way we can de-couple any of interface implementation easily by changing just binding.

Another way to resolve is by using reflection.

<?php

App::bind(\App\Services\MathServiceInterface::class, \App\Services\CustomMathService::class);

This will bind class and resolve it using reflection. By doing this, don't need to resolve using resolve() method. We can just type-hint dependency on a constructor.

Controller:

<?php

protected $mathService;

public function __construct(\App\Services\MathServiceInterface $mathService)
{
    $this->mathService = $mathService;
}

public function index() {
    $sum = $this->mathService->doAddition([40, 20, 10]);
    $product = $this->mathService->doMultiplication([4, 2, 3]);
}

Hope this post helps you to get some insights about service container.

For detailed information about Service Containers: https://laravel.com/docs/7.x/container

Thanks for reading.

Laravel Request Lifecycle

Parixit Patel — Wed, 15 Jul 2020 14:10:29 +0000

As you know, Laravel is a framework with rich features. but you ever wondered How Laravel handles these features? How request handles at different stages when you hit URL on the browser and return response? If these questions arise in your mind then you are on the right track. In this post, we'll discuss the backbone of Laravel called "Request Lifecycle".

Request Lifecycle has different terminologies like Autoloader, kernel, Service Providers, Dispatch Request, and Router. Once you understand all of the terminologies in detail you will be more confident and comfortable with the framework and can extend different functionalities however you like.

So let's dive into the sea...

When a request is made to laravel it will first call public/index.php file. its starting point of each request. Index.php file just contains a few lines of code which will perform initialize actions.

So just open public/index.php file and look into it.

require __DIR__.'/../bootstrap/autoload.php';

It will first include composer autoload (Which will automatically generate class loader for our application) so that we don't have to worry about manual loading any of our classes later on.

$app = require_once __DIR__.'/../bootstrap/app.php';

After that, it will bootstrap laravel framework to use and generate an application instance.

$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);

$response = $kernel->handle(
    $request = Illuminate\Http\Request::capture()
);

$response->send();

$kernel->terminate($request, $response);

Once the application instance generated, the Incoming request will be handled by the kernel. There are two types of kernel in laravel HTTP kernel & Console kernel. So Incoming Request can be handled by either HTTP kernel or Console kernel depending on the request type. These two kernels are the central point of each request.

You can see, the Handle method of the kernel is simple. It takes a request, processes it, and returns a response to the user.

Let's understand HTTP kernel which is placed in app/Http/Kernel.php. If you open this file its extends Illuminate\Foundation\Http\Kernel which is base class of this kernel. Its main duty is to bootstrap framework functionality like Configure Error Handling, Loads Configuration Files, Configure Logging, Detect Environments, and other tasks to be done before the request handled.

HTTP kernel also Register & Execute Middlewares (Manage HTTP session, Detect maintenance mode, verify CSRF token, etc.) which will be called on each request based on configurations.

With the configuration of middleware and other functionalities, HTTP kernel also loads Service Providers. Its most important component of framework and its responsible for bootstrapping framework core features like Database, Routing, Queueing, etc. In short, every feature provided by laravel framework will be bootstrap by Service Providers. Service Providers register all class bindings in the register method and then call the boot method. Providers that are needed for the application are placed in config/app.php configuration file. You can create your own Providers inside app/providers and define it into config/app.php which will be also executed during the bootstrap process.

Thus Bootsraping involves, Initializing configurations, detecting application environment, configure error handling, configure logging and other task needs to execute before request being handled. Apart from this it also registers middleware like Verifying CSRF Token and Reding & Writing HTTP Sessions etc. and bootstraps service providers which are the heart of the framework.

Once the bootstrapping process completed, the request is dispatched to Router. Routers are placed in app/routes.php.These Router calls controller methods as well as run middlewares or returns a view as a response.

So that's it, we have gone through the lifecycle of laravel, understand associated terminologies, and hope it's clear now. The center of attraction here is Bootsraping Process and Service Providers which are the most important part.

Thank you for reading.