#laravel framework

In the world of Laravel development, a well-structured database is the bedrock of a robust and scalable application. While Laravel's Eloquent ORM provides a powerful abstraction layer for interacting with your data, understanding common database design patterns can significantly enhance your development process. 

These patterns not only promote code organization and maintainability but also enable you to adapt your database structure to the unique needs of your application. By mastering these patterns, you can build efficient, reliable, and easily maintainable Laravel applications that can handle diverse data requirements.

1. Active Record Pattern:

This is the most common pattern used by Eloquent ORM in Laravel. It encapsulates database logic within model classes, allowing you to interact with the database using object-oriented methods.

Application

This pattern is well-suited for projects of any size and complexity. It simplifies database operations, making them easier to understand and maintain.

Example:

Advantages:

Simplicity: Easy to understand and implement.

Code Reusability: Model methods can be reused throughout your application.

Relationship Management: Built-in support for relationships between models.

Disadvantages:

Tight Coupling: Model logic is tightly coupled to the database, making it harder to test independently.

Complexity: Can become complex for large applications with complex data structures.

2. Data Mapper Pattern:

This pattern separates data access logic from domain logic. It uses a dedicated "mapper" class to translate between domain objects and database records.

Application

This pattern is useful for large-scale applications with complex domain models, as it allows for greater flexibility and modularity. It is particularly useful when working with multiple data sources or when you need to optimize for performance.

Example:

Advantages:

Flexibility: Easily change the database implementation without affecting business logic.

Testability: Easy to test independently from the database.

Modularity: Promotes a modular structure, separating concerns.

Disadvantages:

Increased Complexity: Requires more code and might be overkill for simple applications.

3. Repository Pattern:

This pattern provides an abstraction layer over the data access mechanism, offering a consistent interface for interacting with the database.

Application

This pattern promotes loose coupling and simplifies testing, as you can easily mock the repository and control the data returned. It is often used in conjunction with the Data Mapper pattern.

Example:

Advantages:

Loose Coupling: Decouples business logic from specific data access implementation.

Testability: Easy to mock repositories for testing.

Reusability: Reusable interface for accessing different data sources.

Disadvantages:

Initial Setup: Can require more setup compared to Active Record.

4. Table Inheritance Pattern:

This pattern allows you to create a hierarchical relationship between tables, where child tables inherit properties from a parent table.

Application

This pattern is useful for creating polymorphic relationships and managing data for different types of entities. For example, you could have a User table and separate tables for AdminUser and CustomerUser that inherit from the parent table.

Example:

Advantages:

Polymorphism: Enables handling different types of entities using a common interface.

Code Reusability: Reuses properties and methods from the parent table.

Data Organization: Provides a structured way to organize data for different types of users.

Disadvantages:

Increased Database Complexity: Can lead to a more complex database structure.

5. Schema-less Database Pattern:

This pattern avoids the use of a predefined schema and allows for dynamic data structures. This is commonly used with NoSQL databases like MongoDB.

Application

This pattern is suitable for projects that require highly flexible data structures, such as social media platforms or analytics systems.

Example:

Advantages:

Flexibility: Easily adapt to changing data structures.

Scalability: Suitable for high-volume, rapidly changing data.

High Performance: Efficient for specific use cases like real-time analytics.

Disadvantages:

Increased Complexity: Requires a different approach to querying and data manipulation.

Data Consistency: Can be challenging to maintain data consistency without a schema.

Choosing the Right Pattern:

The best pattern for your project depends on factors like project size, complexity, performance requirements, and your team's experience. It is important to choose patterns that align with the specific needs of your application and ensure long-term maintainability and scalability.

Conclusion:

This exploration of common database design patterns used in Laravel has shed light on the importance of strategic database structuring for building robust and scalable applications. From the simplicity of the Active Record pattern to the sophisticated capabilities of the Data Mapper and Repository patterns, each pattern offers distinct benefits that cater to specific project needs. 

Free ebook: common errors and exceptions in laravel

JSON is short form of JavaScript Object Notation, which is used to store data and since it is very lightweight hence majorly used for transporting data to and from a web server. In earlier days, XML was used for this very purpose but writing and reading XML data was very tedious while JSON on the other hand, is self describing.

In today’s topic I am going to show you how to store JSON data into MySQL and access those data using laravel eloquent query builders.

Storing JSON data in MySQL using Laravel

First let’s create a dummy table using migration command.

Schema::create(json_examples, function (Blueprint $table) {             $table->bigIncrements('id');             $table->string('name');             $table->text('json_details'); //using text datatype to store json             $table->timestamps();         });

As you can see I used text datatype for storing json.

Next, let’s create a corresponding Model for the same

php artisan make:model JsonExample

JsonExample.php

public static function create($data) {     $new = new self();     $new->name = $data['name'];     $new->json_details = $data['json_details''];     $new->save(); }

So in controller we can do something like this:

public function storeEmpData(Request $request) {     ...     $name = $request->name';     $details = ['emp_code' => '001', 'date_of_joining' => Carbon::parse($request->doj), 'salary' => '50000'];         $dataToStore = [         'name' => $name,         'Json_details' => json_encode($details)       ];       //saving data       JsonExample::create($dataToStore); }

Processing Json data in Laravel eloquent.

Json data in where()

We can easily apply conditions on json data in laravel using -> (arrow notation), for example, fetch records where salary is more than 50000.

JsonExample.php

public static function getSalaryMoreThan($salary) {     return self::where('json_details->salary','>',$salary)->get(); }

Access json data using json_extract()

Another example, we need records of employees who joined the company before a date for instance 9th November 2018.

JsonExample.php

public static function getEmployeesBeforeDate($date) {     return self::whereDate("json_extract('json_details', '$.doj')", '<', $date)->get() }

As you can see above, I used json_extract() method which is MySQL’s function to extract a field from JSON column since I can not simply instruct eloquent using arrow operator like

return self::whereDate('json_details->doj', '<', $date)->get()

Rather I have to explicitly tell eloquent to extract json field and then proceed.

JSON data in DB::raw()

Many times we need to use MySQL’s aggregate functions like SUM() as per the requirement, in that case we use DB facade. For example,

select(DB::raw('sum(...)'))

How to access json field in MySQL’s aggregate function ?

It is very simple, let’s take an example, we need to sum total salary of employees.

public static function findTotalSalary() {     return self::select(DB:raw('sum("json_extract('json_details', '$.salary')") as total_salary'))->get(); }

Conclusion

That’s all about this topic friends, I hope you learned something new which you haven’t thought about. I thought I should share this knowledge as I encountered such problem while working on a project today where I do save additional data in json format. Do comment your reviews and experiences below.

Thank you :)

Ebooks available now

You can download this article’s PDF eBooks for offline reading from below:

Issuu

Slide Share

Edocr

AuthorStream

Difference between MongoDB and MySql