Introduction

The simples way to use where is just to statically call it on your model as Model::where('name', 'Ahmed')->first()

Laravel Query builder is very powerful. It offers a rich set of methods that makes it easy for you to write SQL queries in a very easy way.

One of those methods is the Where method and it has many ways to simplify complex queries

The Query Builder

First of all, you need to understand that where and all its siblings lives in the Builder class. and when you call a static method on the model directory. Most of the times, it will be forwarded to the Eloquent query builder

1public static function __callStatic($method, $parameters)
2{
3    return (new static)->$method(...$parameters);
4}

 1public function __call($method, $parameters)
 2{
 3    if (in_array($method, ['increment', 'decrement', 'incrementQuietly', 'decrementQuietly'])) {
 4        return $this->$method(...$parameters);
 5    }
 6
 7    if ($resolver = $this->relationResolver(static::class, $method)) {
 8        return $resolver($this);
 9    }
10
11    if (Str::startsWith($method, 'through') &&
12        method_exists($this, $relationMethod = Str::of($method)->after('through')->lcfirst()->toString())) {
13        return $this->through($relationMethod);
14    }
15
16    return $this->forwardCallTo($this->newQuery(), $method, $parameters);
17}

The forwardCallTo, forwards the method call to the $this->newQuery() which returns an instance of Builder class

1/**
2 * Get a new query builder for the model's table.
3 *
4 * @return \Illuminate\Database\Eloquent\Builder
5 */
6public function newQuery()
7{
8    return $this->registerGlobalScopes($this->newQueryWithoutScopes());
9}

So by looking into the where method in the Builder class. it’s about 100 lines
. That’s because it can handle many cases. So let’s take them one by one

Simple where condition

The first easy simple way to write a condition in laravel is to just pass the key and value to the where.

1User::where('email', 'root@admin.com')->first()

This will translate to

1SELECT * FROM users WHERE `email` = 'root@admin.com' LIMIT 1

Multiple where

Chain wheres

You can also chain several wheres

1User::where('email', 'root@admin.com')
2	->where('is_active', true)->first()

This will translate to

1SELECT * FROM users WHERE `email` = 'root@admin.com' AND `is_active` = true LIMIT 1

Array of Wheres

Another way to do so is to use an array of where

1User::where([
2	'email' => 'root@admin.com',
3	'is_active' => true
4])->first()

This will translate to

1SELECT * FROM users WHERE `email` = 'root@admin.com' AND `is_active` = true LIMIT 1

Using OrWhere

The OrWhere method is used to add an OR constraint to your queries. It functions similarly to the where method, but adds the condition as an “OR” clause rather than an “AND” clause.

1User::where('email', 'root@admin.com')
2	->orWhere('username', 'admin')->first()

But how we do the is_active when we use OR?

Grouped Conditions

We can use grouped conditions by passing a closure to the where method

1User::where(function($q) {
2  $q->where('email', 'root@admin.com')
3	  ->orWhere('username', 'admin');
4})
5->where('is_active', true)
6->first()

And this will translate to

1SELECT
2*
3FROM `users`
4WHERE (`email` = 'root@admin.com' or `username` = 'admin')
5AND `is_active` = 1
6
7LIMIT 1

And you can have as many nested groupings as you want

When and Where

You can also apply specific wheres only when a condition is true

1$onlyActive = true;
2
3User::where('email', 'root@admin.com')
4->when($onlyActive, function($q) {
5	$q->where('is_active', true);
6})->first()

The where is_active = true will be only applied if the $onlyActive is true

Shortcuts

There are also some shortcuts that can be applied to simplify how you write eloquent

Where{Column}

1User::whereEmail('root@admin.com')->first()

Translates to

1SELECT * FROM `users` WHERE `email` = 'root@admin.com' LIMIT 1

Where{Column}And{Column}

1User::whereEmailAndStatus('root@admin.com','active')->first()

Translates to

1SELECT * FROM `users` WHERE `email` = 'root@admin.com' AND `status` = 'active' LIMIT 1

Where{Column}Or{Column}

1User::whereEmailOrUserName('root@admin.com','admin')->first()

Translates to

1SELECT * FROM `users` WHERE `email` = 'root@admin.com' OR `user_name` = 'admin' LIMIT 1

WhereNull

You can also look for records where the column value is null

1User::whereNull('confirmed_at')->get()

1SELECT * FROM `users` WHERE `confirmed_at` IS NULL

WhereNot

There is also WhereNot to apply “NOT EQUAL TO” condition in your queries.

1User::whereNot('status','active')->all()

Which translates to

1SELECT * FROM `users` WHERE NOT `status` = 'active'

WhereNotNull

A combination of the previous two

1User::whereNotNull('confirmed_at')->all()

Which translates to

1SELECT * FROM `users` WHERE `confiremd_at` IS NOT NULL

Conclusion

We checked together what are the possible ways to use the where method. Let me know if you have any tips or tricks or maybe missed cases I did not cover in the comments.

The number of ways you can chat with generative AI engines continues to grow, from ChatGPT to Claude to Google Bard to Bing AI, and FreedomGPT is one of the latest options you can add to your list of potential conversational partners. Here we’re going to take you through the key features that mark it out as being a little different and show you what it’s like to use.

There are two main reasons you might want to use FreedomGPT: First, it can run locally on your computer, without any internet access. Second, it’s completely uncensored, which may or may not be an advantage depending on where in the world you live, the restrictions placed on your web access, and what you want out of your AI bots.

In other words, the engine will produce some very controversial takes if prompted in the right way, and you should be prepared for that if you’re going to make use of it. As you may have noticed, ChatGPT will refuse to answer certain categories of questions—covering areas such as financial advice or illegal activities—but FreedomGPT has no such qualms.

It’s also free to use at this point, which combined with the local installation option, may make it worth your while to at least try out. There is a web version available too, which confusingly deals with a different set of AI models and can’t be accessed for free, but it’s the downloadable version that we’re going to be focusing on here.

You can set up FreedomGPT on your computer by heading to the FreedomGPT website and following the link for either the Windows or the macOS download. You’ll then be asked to pick the AI model you want to use with FreedomGPT, and whether you want the full (and slower) version or the fast (and less complete) version of the model.

Your two options are LLaMA, as released publicly by Meta, and Alpaca, a version of LLaMA fine-tuned by Stanford researchers which is more ChatGPT-like in its behavior. You’ll also be shown the download size for each model, and the amount of RAM you need on your local machine.

With the downloading and the installing out of the way, you’re free to start experimenting with FreedomGPT on your Windows or macOS machine. We’ll give you a few ideas here for how you can use the software while staying well away from anything ethically or legally dubious—prompts that ChatGPT would flat-out refuse to respond to.

Using FreedomGPT

FreedomGPT will open up with a ChatGPT-style interface, but at the moment it’s not quite as friendly as the OpenAI-developed alternative. All of your chats are bunched together in the same conversation, and to start again from scratch you need to close down and restart the app, or choose View and Reload from the menus at the top.

At that point, all of your existing chats will be lost for good, and the AI bot isn’t great at remembering what you’ve already said to it either, which means it’s best suited for standalone questions rather than ongoing chats. These aren’t necessarily dealbreakers when it comes to using FreedomGPT, but it’s important to be aware of its limitations.

Up in the top left of the interface, you can switch between the different AI models on offer, and download any that aren’t currently stored on your computer. You’ll also find links to the program’s Discord and GitHub locations online, and these are your best bets for getting help and support with FreedomGPT.

You can interact with FreedomGPT in all the ways you’ll be familiar with from other AI bots: Get explainers on difficult concepts, get ideas for particular projects and activities, hear the pros and cons of a decision you’re weighing up, set up outlines for research that you’re undertaking and so on. It’ll write poetry, come up with idea prompts, and take instructions about the style and tone of its responses.

We didn’t notice too much of a difference between the LLaMA and the Alpaca models, although the latter seemed more comprehensive and more conversational a lot of the time. You can switch between models in the same conversation if you need to, although the program doesn’t leave behind any indication of which model has answered which conversation, which can get confusing.

It’s worth bearing in mind that the offline mode offered by FreedomGPT does offer you certain protections in terms of privacy and not having your conversations monitored, which is something you need to be wary about when using other similar services. We tested FreedomGPT in fully offline mode and can confirm it works as normal—the benefit of having everything installed locally.

In the AI gold rush that we’re currently living through, it’s not clear exactly who the winners and the losers are going to be, but FreedomGPT certainly offers something different for the time being—and if you’ve got more than a passing interest in what AI can offer, it’s something to try out.

A tutorial for displaying continuous numbering of collection items on all pagination pages in a Laravel project.

🌍 The French version of this publication : Pagination Laravel : Afficher une numérotation continue des éléments par page

Pagination in Laravel is a mechanism for dividing data into several pages to facilitate presentation and navigation when there are a large number of results.

Let’s consider a collection of publications or $posts that we retrieve and paginate in the controller’s index method to display 100 per page:

public function index()
{
    $posts = Post::paginate(100);
    return view("posts.index", compact('posts'));
}

On the view resources/views/posts/index.blade.php we can display 100 posts per page and present the links of the different pages of the pagination like this:

@extends('layouts.app')
@section('content')
<table>
        <thead>
            <tr>
                <th>No.</th>
                <th>Title</th>
            </tr>
        </thead>
        <tbody>
            @foreach ($posts as $post)
            <tr>
                <td></td>
                <td></td>
            </tr>
            @endforeach
        </tbody>
    </table>
    
    
    
@endsection

In this source code, $loop->iteration displays the iteration number inside the loop and $posts->links() displays the pagination links.

But notice, for each individual page the iteration starts at 1. This means that if we’re on page 2, the first iteration of that page will be considered the first iteration in the whole pagination.

If we want to display continuous numbering on all pages of a pagination, we can combine the number of elements per page, the current page number and the current iteration:

@foreach ($posts as $post)
<tr>
    <td></td>
    <td></td>
</tr>
@endforeach

In this source code we have :

• $posts->perPage() : number of elements per page
• $posts->currentPage() : current page number

By multiplying the number of elements per page by the current page number minus one, we obtain the starting index for that page. By adding $loop->iteration, we obtain the continuous index for each element of the paginated collection.

So even if you go from page 1 to page 2, the numbering continues from the last index on the previous page.

Take care! 😎