As a developer, one of the more tedious parts of building web applications is working with databases. Writing SQL queries, handling relationships between tables, running migrations to update schemas – these things require a lot of effort to get right, especially when requirements change often in typical web projects.
This is where Laravel’s Eloquent ORM shines. Eloquent makes interacting with databases more intuitive through a powerful object-oriented interface. It aims to reduce the complexities and headaches that come with persistent data storage and querying.
In this guide, I provide a simplified intro to working with databases in Laravel through Eloquent models. I’ll focus on the big concepts more than technical intricacies or edge cases. My goal is to equip you with enough knowledge to get started building web apps without drowning in academic definitions or jargon early on!
Models Represent Your Database Structure and Behavior
The fundamental idea in Eloquent is the “model,” which represents a database table. So, if you have a user’s table, create a corresponding User model class to encapsulate all the logic for that table.
This includes tasks like:
- Defining data columns as model properties: Specify the structure of your database table by declaring corresponding properties in the model, creating a seamless connection between code and data.
- Creating/updating user records: Utilize the model to effortlessly create and update user records without the need for raw SQL queries, enhancing code readability and maintainability.
- Searching for users based on column values: Leverage dynamic finder methods to perform queries based on specific column values, simplifying the process of retrieving relevant data from the database.
- Defining relationships to other models: Establish connections between models to reflect and manage relational data, enabling efficient querying and utilization of interconnected information.
- Enforcing data validation rules: Implement data validation rules within the model to ensure the integrity and accuracy of data stored in the database, enhancing security and reliability.
- Other business logic and behavior: Extend the model to encapsulate additional business logic and behavior, providing a centralized and organized location for handling complex functionalities related to the database entity.
So, your entire database structure and requirements get wrapped up in a collection of models. This provides an object-oriented way to work with persistent storage of data compared to always writing manual SQL queries everywhere.
As an example, let’s say your user’s table has firstname, lastname, email and created_at columns. This would be modeled as:
class User extends Model {
public string $firstname;
public string $lastname;
public string $email;
public DateTime $created_at;
// Rest of model behavior
}
And you can start creating and storing user records without raw SQL:
$user = new User;
$user->firstname = “John”;
$user->lastname = “Doe”;
$user->email = “john@doe.com”;
$user->save();
So, models give you a higher level of abstraction over database tables to better express your application’s domain.
Migrations Handle Schema Changes Over Time
As requirements evolve, you may need to modify database schemas and tables. Adding new columns, indexes, foreign keys, etc. These changes need to be handled systematically to track the state of databases in version control and across environments.
This is where Laravel migrations come in. Migrations provide a database-independent way to alter schemas over time in a consistent, incremental fashion. To successfully implement these Laravel migrations, you need to hire Laravel developers who have a proper understanding of the Laravel ecosystem,
For example, you might create an initial create_users_table migration when developing a feature:
public function up()
{
Schema::create(‘users’, function (Blueprint $table) {
$table->id();
$table->string(‘firstname’);
$table->string(‘lastname’);
$table->string(’email’)->unique();
$table->timestamps();
});
}
This migration outlines the steps taken to create a new user table. Later in development, you might add contact phone like:
public function up()
{
Schema::table(‘users’, function (Blueprint $table) {
$table->string(‘phone’)->nullable();
});
}
Migrations serve as a log of every schema modification required for your models. Laravel tracks which migrations have run already against the database. It lets you evolve schemas predictably across staging/production environments as codebases grow.
Fetching and Manipulating Model Data
Once your underlying database tables and models are set up through migrations, you can focus more on useful application logic rather than structural DB changes. Let’s go through some common ways you would interact with models:
Creating new model records is intuitive through new model instances:
$user = new User;
$user->firstname = “John”;
$post = new Post;
$post->title = “My First Post”;
Finding saved models based on primary key ID:
$user = User::find(123);
$post = Post::find(456);
More dynamic finder methods to query based on different column values:
$user = User::where(’email’, ‘[email protected]’)->first();
$posts = Post::where(‘active’, true)->orderBy(‘title’)->get();
You can update and delete models conveniently, too:
$user->email = “[email protected]”;
$user->save();
$post->delete();
Chaining ->where() and ->orderBy() constraints allows building up complex retrieval logic while hiding away SQL syntax.
Defining Relationships Between Models
Relational data is crucial for web apps. Users have many posts, posts belonging to categories, etc. Defining relationships helps query and use interconnected data:
class User extends Model {
public function posts()
{
return $this->hasMany(Post::class);
}
}
class Post extends Model {
public function user()
{
return $this->belongsTo(User::class);
}
}
You can access related entities conveniently:
$user = User::find(1);
foreach ($user->posts as $post) {
echo $post->title;
}
$post = Post::find(1);
echo $post->user->firstname;
Eloquent handles managing the underlying foreign key constraints and joins queries automatically. This helps build domain logic that closely mirrors how data entities interconnect.
Final Words
This is everything you need to know about the fundamentals of Laravel Eloquent and what its purpose is. However, there are many additional capabilities Eloquent provides for modeling database-backed applications like:
- Attribute casting – Eloquent’s attribute casting allows seamless conversion of data types, enhancing code readability. For example, date attributes can be cast to the Carbon type, ensuring convenient manipulation of date and time information within the application.
- Query Scope: Query scopes in Eloquent provide a clean and reusable way to encapsulate common query logic within models. Developers can define scoped methods, such as scopeActive, to easily retrieve specific sets of data without cluttering the code with repetitive query conditions.
- Serialization: Eloquent simplifies the process of serializing models to JSON, a crucial feature for building APIs or handling AJAX requests. By customizing attributes included in the serialized output and incorporating dynamic attribute calculations, developers can efficiently tailor data responses to meet specific requirements.
- Testing fixtures: Eloquent supports the creation of testing fixtures through the factory helper, enabling developers to set up a consistent testing environment with predefined data. This feature streamlines the testing process by ensuring a reliable and reproducible state for various scenarios.
- Raw query access: For scenarios where fine-grained control over SQL queries is necessary, Eloquent provides raw query access. Developers can execute raw SQL queries using the DB facade, allowing flexibility in handling specific database operations outside the typical Eloquent conventions.
- Soft Deleting Records: Eloquent supports soft deletes, allowing developers to “delete” records by marking them as such without permanently removing them from the database. This feature is valuable for scenarios where data retention and recoverability are critical.
- Advanced Eloquent Collections: Eloquent collections extend the capabilities of standard Laravel collections, offering powerful methods for data manipulation and analysis. Developers can take advantage of features like filtering, mapping and reducing to streamline the processing of result sets retrieved from the database.
You can find and look for Laravel developers with proper expertise through an IT staff augmentation company. Alternatively, you can set up an ODC to retain management and control over the project.
