1. Routing:
```php
Route::get('/route', 'ControllerName@method');
```
2. Controller:
```php
php artisan make:controller ControllerName
```
3. Views:
```php
return view('view_name', ['data' => $data]);
```
4. Database Migration:
```php
php artisan make:migration create_table_name
```
5. Model:
```php
php artisan make:model ModelName
```
6. Eloquent ORM (Querying the database):
```php
$results = ModelName::where('column', '=', 'value')->get();
```
7. Blade Templates (Displaying data in views):
```php
<h1>{{ $variable }}</h1>
```
8. Middleware (Adding middleware to routes):
```php
Route::middleware(['middleware_name'])->group(function () {
// Routes here
});
```
9. Validation (Validating user input):
```php
$validatedData = $request->validate([
'field' => 'required|string|max:255',
]);
```
10. Authentication (User authentication):
```php
// Login
Auth::attempt(['email' => $email, 'password' => $password]);
// Logout
Auth::logout();
```
11. Database Seeders (Populating database with sample data):
```php
php artisan db:seed
```
12. Middleware (Creating custom middleware):
```php
php artisan make:middleware MiddlewareName
```
13. Middleware (Assigning middleware to a route):
```php
Route::get('/route', 'ControllerName@method')->middleware('middleware_name');
```
14. Eloquent Relationships (Defining model relationships):
```php
// One-to-Many
public function comments()
{
return $this->hasMany(Comment::class);
}
// Many-to-Many
public function roles()
{
return $this->belongsToMany(Role::class);
}
```
15. Form Requests (Creating form request classes for validation):
```php
php artisan make:request RequestName
```
16. Using Form Request in Controller (Validating using a form request):
```php
public function store(RequestName $request)
{
// Validation passed, process the request
}
```
17. Database Relationships (Accessing related data):
```php
// Accessing related data
$comments = $post->comments;
// Lazy Eager Loading
$posts = Post::with('comments')->get();
```
18. CRUD Operations (Basic database operations):
```php
// Create
$model = new ModelName;
$model->column = 'value';
$model->save();
// Read
$model = ModelName::find($id);
// Update
$model->update(['column' => 'new_value']);
// Delete
$model->delete();
```
19. Validation Custom Error Messages (Customizing validation error messages):
```php
$validatedData = $request->validate([
'field' => 'required|string|max:255',
], [
'field.required' => 'Custom error message for required field',
]);
```
20. Resource Controllers (Generating resource controllers):
```php
php artisan make:controller ResourceController --resource
```
21. Resource Routes (Defining resource routes):
```php
Route::resource('resource', 'ResourceController');
```
22. Middleware Groups (Grouping middleware for routes):
```php
Route::middleware(['middleware1', 'middleware2'])->group(function () {
// Routes here
});
```
23. Request Input (Accessing input data from requests):
```php
$inputValue = $request->input('input_name');
```
24. Sending Emails (Sending emails using Laravel's built-in Mail class):
```php
Mail::to('email@example.com')->send(new MyEmailClass($data));
```
25. Queue Jobs (Pushing jobs to the queue for background processing):
```php
dispatch(new MyJob($data));
```
26. Middleware Priority (Defining priority for middleware):
```php
protected $middlewarePriority = [
\Illuminate\Auth\Middleware\Authenticate::class,
\Illuminate\Session\Middleware\StartSession::class,
// ...
];
```
27. Localization (Translating your application):
```php
__('messages.welcome');
```
28. File Uploads (Handling file uploads):
```php
$file = $request->file('file_input_name');
$file->store('directory');
```
29. Validation Rule for Unique Field (Validating a unique field):
```php
$validatedData = $request->validate([
'email' => 'required|email|unique:users',
]);
```
30. Authentication Middleware (Protecting routes with authentication middleware):
```php
Route::middleware(['auth'])->group(function () {
// Authenticated routes here
});
```
31. Database Query Builder (Using the query builder for complex queries):
```php
$users = DB::table('users')
->where('votes', '>', 100)
->orderBy('name')
->get();
```
32. Creating and Handling Events (Defining and handling events):
```php
// Create an event class
php artisan make:event EventName
// Trigger the event
event(new EventName($data));
// Listen to the event
protected $listen = [
EventName::class => [
ListenerClass::class,
],
];
```
33. Caching (Using Laravel's built-in caching):
```php
$value = Cache::remember('key', $minutes, function () {
return computeValue();
});
```
34. File Downloads (Offering file downloads in responses):
```php
return response()->download($pathToFile);
```
35. Form Method Spoofing (Using HTTP verbs like PUT and DELETE in forms):
```php
<form method="POST" action="/resource" enctype="multipart/form-data">
@method('PUT')
@csrf
<!-- form fields -->
</form>
```
36. Dependency Injection (Injecting dependencies into controllers or services):
```php
public function __construct(MyService $service)
{
$this->service = $service;
}
```
37. Authentication Scaffolding (Generating authentication views and routes):
```php
php artisan make:auth
```
38. Middleware Parameters (Passing parameters to middleware):
```php
Route::middleware(['middleware_name:param1,param2'])->group(function () {
// Routes here
});
```
39. Database Factories (Creating database factories for test data):
```php
$factory->define(Model::class, function (Faker $faker) {
return [
'column' => $faker->name,
// Other attributes
];
});
```
40. Testing (Writing and running tests using PHPUnit):
```php
public function test_example()
{
$response = $this->get('/');
$response->assertStatus(200);
}
```
41. Middleware Terminable Middleware (Terminable middleware for post-request processing):
```php
public function terminate($request, $response)
{
// Perform actions after the response has been sent
}
```
42. Accessing Request Input (Accessing request data within a controller method):
```php
$value = $request->input('input_name');
```
43. Eloquent Pluck (Retrieving a single column's value from a model):
```php
$name = ModelName::where('column', 'value')->pluck('name');
```
44. Dependency Container (Binding custom implementations to Laravel's service container):
```php
$this->app->bind(MyInterface::class, MyImplementation::class);
```
45. Eloquent Collection Methods (Working with collections of Eloquent models):
```php
$collection = ModelName::where('column', 'value')->get();
$filtered = $collection->filter(function ($item) {
return $item->someField > 10;
});
```
46. Pagination (Paginating query results):
```php
$paginatedResults = ModelName::paginate(10);
```
47. Eloquent Mutators (Defining mutators for model attributes):
```php
public function getColumnNameAttribute($value)
{
return strtoupper($value);
}
```
48. Eloquent Accessors (Defining accessors for model attributes):
```php
public function getColumnNameAttribute($value)
{
return ucfirst($value);
}
```
49. Dependency Injection in Blade Templates (Injecting dependencies into Blade views):
```php
@inject('dependency', 'App\Services\DependencyClass')
{{ $dependency->method() }}
```
50. Environment Configuration (Accessing environment configuration variables):
```php
$value = env('ENV_VARIABLE', 'default_value');
```
51. Middleware with Parameters (Passing parameters to custom middleware):
```php
Route::middleware(['middleware_name:param1,param2'])->group(function () {
// Routes here
});
```
52. Named Routes (Defining and using named routes):
```php
Route::get('route', 'Controller@method')->name('route.name');
```
53. Artisan Command (Creating custom Artisan commands):
```php
php artisan make:command MyCommand
```
54. Authorization (Defining and checking user authorization):
```php
if (Gate::allows('policy_name', $model)) {
// Authorized action
}
```
55. Task Scheduling (Scheduling tasks using Laravel's scheduler):
```php
protected function schedule(Schedule $schedule)
{
$schedule->command('my:command')->daily();
}
```
56. Middleware Groups with Prefixes (Using middleware groups with route prefixes):
```php
Route::prefix('admin')->middleware(['auth', 'admin'])->group(function () {
// Admin routes here
});
```
57. Eloquent Scopes (Defining reusable query scopes on models):
```php
public function scopeActive($query)
{
return $query->where('status', 'active');
}
```
58. File Storage (Working with files using Laravel's file storage system):
```php
$path = Storage::disk('public')->put('folder', $file);
```
59. Localization with Parameters (Using parameters in translated strings):
```php
__('messages.welcome', ['name' => $username])
```
60. Database Transactions (Performing actions within a database transaction):
```php
DB::beginTransaction();
try {
// Database operations
DB::commit();
} catch (\Exception $e) {
// Handle errors
DB::rollback();
}
```
61. API Routes (Defining API routes with JSON responses):
```php
Route::apiResource('resource', 'ResourceController');
```
62. Queue Workers (Starting queue workers for processing jobs):
```php
php artisan queue:work
```
63. Dependency Injection in Controllers (Injecting dependencies into controller methods):
```php
public function index(DependencyClass $dependency)
{
// Access $dependency here
}
```
64. Resource Controllers with API Resource (Generating API resource controllers):
```php
php artisan make:controller ApiController --api
```
65. Resource Routes for API (Defining API resource routes):
```php
Route::apiResource('resource', 'ApiController');
```
66. Resource Transformations (Transforming data using resources):
```php
return new ResourceClass($data);
```
67. Validation Rule for Unique Field Except Self (Validating a unique field except for the current record):
```php
$validatedData = $request->validate([
'email' => 'required|email|unique:users,email,'.$user->id,
]);
```
68. Working with Cookies (Setting and retrieving cookies):
```php
return response('Hello')->cookie('name', 'value', $minutes);
$value = $request->cookie('name');
```
69. Event Listeners (Creating and registering event listeners):
```php
protected $listen = [
'EventClass' => [
'EventListenerClass',
],
];
```
70. Task Scheduling in Cron (Scheduling tasks in the system's cron):
```php
* * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1
```
71. Rate Limiting (Applying rate limits to routes):
```php
$router->middleware('throttle:60,1')->group(function () {
// Route here
});
```
72. Middleware with Conditional Logic (Applying middleware with conditional logic):
```php
Route::middleware(['middleware_name'])->when(true, function ($router) {
// Middleware applied conditionally
});
```
73. Database Eloquent Raw Queries (Executing raw SQL queries):
```php
$results = DB::select('SELECT * FROM table WHERE column = ?', [$value]);
```
74. Middleware Stacks (Using middleware stacks for multiple middleware in a group):
```php
Route::middleware(['web', 'auth', 'middleware_name'])->group(function () {
// Routes here
});
```
75. Middleware Global Middleware (Defining global middleware in Kernel.php):
```php
protected $middleware = [
// Middleware classes
];
```
76. Database Eloquent Chunking (Chunking large query results):
```php
ModelName::chunk(200, function ($models) {
foreach ($models as $model) {
// Process each model
}
});
```
77. Database Eloquent Model Events (Using model events for triggering actions):
```php
protected $dispatchesEvents = [
'created' => ModelCreatedEvent::class,
];
```
78. Eloquent Query Caching (Caching Eloquent query results):
```php
$results = Cache::remember('cache_key', $minutes, function () {
return ModelName::where('column', '=', 'value')->get();
});
```
79. Dependency Container Binding (Binding a custom service into the container):
```php
$this->app->bind('CustomServiceInterface', 'CustomServiceImplementation');
```
80. Dynamic Blade Component (Using dynamic Blade components):
```php
<x-dynamic-component :type="$componentType" />
```
81. Database Eloquent Soft Deletes (Using soft deletes for database records):
```php
use Illuminate\Database\Eloquent\SoftDeletes;
class ModelName extends Model
{
use SoftDeletes;
}
```
82. Working with Artisan Tinker (Using the interactive Artisan Tinker console):
```php
php artisan tinker
```
83. Database Migrations Rollback (Rolling back database migrations):
```php
php artisan migrate:rollback
```
84. Database Seeding with Faker (Seeding the database with fake data using Faker):
```php
public function run()
{
factory(App\User::class, 50)->create();
}
```
85. Database Query Log (Displaying the executed queries in the log):
```php
DB::enableQueryLog();
// Your queries here
$queries = DB::getQueryLog();
```
86. Route Model Binding (Binding route parameters to model instances):
```php
Route::get('resource/{model}', function (Model $model) {
return $model;
});
```
87. Eloquent Polymorphic Relationships (Defining polymorphic relationships):
```php
public function commentable()
{
return $this->morphTo();
}
```
88. Eloquent Global Scopes (Defining global scopes for models):
```php
protected static function boot()
{
parent::boot();
static::addGlobalScope(new MyScope);
}
```
89. Named Routes with Parameters (Defining named routes with parameters):
```php
Route::get('user/{id}', 'UserController@show')->name('user.profile');
```
90. Resourceful Resource Names (Customizing resourceful resource names):
```php
Route::resource('photos', 'PhotoController')->parameters([
'photos' => 'admin.photo',
]);
```
91. Database Eloquent Query Joins (Performing joins in Eloquent queries):
```php
$results = ModelA::join('table_b', 'table_a.column', '=', 'table_b.column')
->where('table_b.column', '=', 'value')
->get();
```
92. Rate Limiting with Customization (Customizing rate limiting behavior):
```php
protected function resolveRequestSignature($request)
{
return sha1($request->route('id') . $request->ip());
}
```
93. Database Eloquent Subqueries (Using subqueries in Eloquent queries):
```php
$subquery = DB::table('subtable')->select('subcolumn')->where('subcondition', '=', 'subvalue');
$results = DB::table('maintable')->whereIn('maincolumn', $subquery)->get();
```
94. File Validation (Validating file uploads in a request):
```php
$validatedData = $request->validate([
'file_input' => 'required|file|mimes:pdf,doc,docx|max:2048',
]);
```
95. Database Eloquent Union (Combining query results using union):
```php
$queryA = ModelA::where('column', '=', 'valueA');
$queryB = ModelB::where('column', '=', 'valueB');
$results = $queryA->union($queryB)->get();
```
96. Form Validation Using Rule Objects (Validating form inputs using custom validation rules):
```php
use App\Rules\CustomRule;
$validatedData = $request->validate([
'field' => ['required', new CustomRule],
]);
```
97. Database Eloquent Raw Expressions (Using raw expressions in Eloquent queries):
```php
$results = ModelName::select(DB::raw('SUM(column) as total'))->groupBy('group_column')->get();
```
98. Scheduled Jobs with Custom Frequency (Scheduling jobs with custom frequencies):
```php
$schedule->job(new MyCustomJob)->everyMinutes(15);
```
99. Database Eloquent Transactions (Using database transactions with Eloquent):
```php
DB::transaction(function () {
// Database operations
});
```
100. Multiple Middleware in Controller Constructor (Applying multiple middleware in a controller's constructor):
```php
public function __construct()
{
$this->middleware('middleware1');
$this->middleware('middleware2');
}
```
101. Form Validation Error Messages (Customizing form validation error messages):
```php
$messages = [
'field.required' => 'The field is required.',
];
$validatedData = $request->validate([
'field' => 'required',
], $messages);
```
102. Database Eloquent Aggregates (Using aggregates like `count`, `sum`, and `avg`):
```php
$count = ModelName::where('column', '=', 'value')->count();
$average = ModelName::where('column', '=', 'value')->avg('numeric_column');
```
103. Database Eloquent Relationships with Constraints (Defining relationships with additional constraints):
```php
public function comments()
{
return $this->hasMany(Comment::class)->where('approved', true);
}
```
104. Middleware Parameter Binding (Binding route parameters to middleware):
```php
public function handle($request, Closure $next, $parameter)
{
// Middleware logic
}
```
105. Middleware Priority with Groups (Defining middleware priority within groups):
```php
protected $middlewareGroups = [
'web' => [
MiddlewareA::class,
MiddlewareB::class,
],
];
```
106. Route Caching (Caching routes for improved performance):
```php
php artisan route:cache
```
107. Database Eloquent Upserts (Performing upserts - insert or update if exists):
```php
ModelName::updateOrInsert(
['unique_column' => 'value'],
['other_column' => 'new_value']
);
```
108. Database Eloquent Transactions with Closure (Using transactions with closures):
```php
DB::transaction(function () {
// Database operations
});
```
109. Resource Routes with Middleware (Defining resource routes with middleware):
```php
Route::resource('resource', 'ResourceController')->middleware('middleware_name');
```
110. Database Eloquent Increment/Decrement (Incrementing and decrementing column values):
```php
ModelName::where('column', '=', 'value')->increment('counter_column');
ModelName::where('column', '=', 'value')->decrement('counter_column');
```
111. Custom Artisan Command with Arguments (Creating a custom Artisan command with arguments):
```php
php artisan make:command MyCommand --command=command:name {argument}
```
112. Database Eloquent Query Logging (Enabling and disabling query logging):
```php
DB::enableQueryLog();
// Perform queries
$queries = DB::getQueryLog();
```
113. Database Eloquent Aggregated Relationships (Using aggregated relationships with `withCount`):
```php
$posts = Post::withCount('comments')->get();
```
114. Resource Controllers with Route Prefix (Using a prefix with resource controllers):
```php
Route::prefix('admin')->group(function () {
Route::resource('resource', 'ResourceController');
});
```
115. Database Eloquent Model Serialization (Customizing model serialization):
```php
protected $hidden = ['password'];
protected $appends = ['custom_attribute'];
```
116. Custom Validation Rule Objects with Parameters (Creating custom validation rules with parameters):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value)
{
// Custom validation logic
}
}
```
117. Database Eloquent Soft Deletes Restore (Restoring soft deleted models):
```php
ModelName::withTrashed()->where('column', '=', 'value')->restore();
```
118. Database Eloquent Raw Updates (Performing raw updates in Eloquent):
```php
ModelName::where('column', '=', 'value')->update(['column' => DB::raw('column + 1')]);
```
119. Database Migrations with Foreign Keys (Defining foreign key constraints in migrations):
```php
$table->foreign('foreign_id')->references('id')->on('related_table')->onDelete('cascade');
```
120. Custom Exception Handling (Customizing exception handling in `app/Exceptions/Handler.php`):
```php
public function render($request, Throwable $exception)
{
if ($exception instanceof MyCustomException) {
return response()->view('custom-error', [], 500);
}
return parent::render($request, $exception);
}
```
121. Database Eloquent Polymorphic Pivot Tables (Working with polymorphic pivot tables):
```php
public function tags()
{
return $this->morphToMany(Tag::class, 'taggable')
->withPivot(['taggable_type', 'taggable_id'])
->wherePivot('taggable_type', 'post');
}
```
122. Database Eloquent Relationships with Custom Keys (Defining relationships with custom foreign keys):
```php
public function user()
{
return $this->belongsTo(User::class, 'custom_user_id');
}
```
123. Testing HTTP Responses (Asserting HTTP responses in tests):
```php
$response = $this->get('/example-route');
$response->assertStatus(200);
$response->assertSee('Expected Text');
```
124. Database Eloquent Dynamic Scopes (Creating dynamic query scopes in models):
```php
public function scopePopular($query)
{
return $query->orderBy('views', 'desc');
}
```
125. API Resource Collections (Returning resource collections in APIs):
```php
return ResourceClass::collection($collection);
```
126. Database Migrations with Indexes (Defining indexes in database migrations):
```php
$table->string('email')->unique();
$table->index(['column1', 'column2']);
```
127. Testing Database Transactions (Testing database operations within transactions):
```php
use Illuminate\Foundation\Testing\Transaction;
protected $transaction;
protected function setUp(): void
{
parent::setUp();
$this->transaction = $this->app->make(Transaction::class);
}
public function testDatabaseTransactions()
{
$this->transaction->within(function () {
// Database operations
});
}
```
128. Database Eloquent Query Select Subsets (Selecting specific columns in Eloquent queries):
```php
$results = ModelName::where('column', '=', 'value')->select('column1', 'column2')->get();
```
129. Custom Validation Messages for Rules (Customizing validation error messages for specific rules):
```php
$messages = [
'field.required' => 'Custom error message for required field',
];
$validatedData = $request->validate([
'field' => 'required',
], $messages);
```
130. Database Eloquent Query Logging for Debugging (Logging queries for debugging purposes):
```php
DB::listen(function ($query) {
Log::info($query->sql);
Log::info($query->bindings);
Log::info($query->time);
});
```
131. Database Eloquent Batch Updates (Performing batch updates with Eloquent):
```php
ModelName::whereIn('id', [1, 2, 3])->update(['column' => 'new_value']);
```
132. Custom Validation Rule with Message (Creating a custom validation rule with a custom error message):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value)
{
return $value === 'custom_value';
}
public function message()
{
return 'The field must be "custom_value".';
}
}
```
133. Database Eloquent Soft Deletes with Query Builder (Using query builder with soft deletes):
```php
ModelName::withTrashed()->where('column', '=', 'value')->restore();
```
134. Eloquent Relationships with Intermediate Tables (Defining many-to-many relationships with intermediate tables):
```php
public function roles()
{
return $this->belongsToMany(Role::class)->using(UserRole::class)->withTimestamps();
}
```
135. Database Migrations Renaming Columns (Renaming columns in database migrations):
```php
Schema::table('table_name', function (Blueprint $table) {
$table->renameColumn('old_column_name', 'new_column_name');
});
```
136. Testing Authentication with Laravel Passport (Testing authentication with Laravel Passport):
```php
use Laravel\Passport\Passport;
Passport::actingAs($user);
$response = $this->get('/api/resource');
$response->assertStatus(200);
```
137. Database Eloquent Query Chunking (Chunking large query results with a callback):
```php
ModelName::chunk(200, function ($models) {
foreach ($models as $model) {
// Process each model
}
});
```
138. Eloquent Polymorphic Relations with Custom Types (Defining polymorphic relationships with custom types):
```php
public function comments()
{
return $this->morphMany(Comment::class, 'commentable')->where('type', '=', 'custom_type');
}
```
139. Artisan Command Options and Arguments (Creating custom Artisan commands with options and arguments):
```php
php artisan make:command MyCommand --option=default_value {argument}
```
140. Custom Validation Rule for Validation Parameters (Creating custom validation rules with parameters):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value, $parameters)
{
return $value === $parameters[0];
}
public function message()
{
return 'The field must match the parameter: :value';
}
}
```
141. Database Eloquent One-to-One Eager Loading (Eager loading one-to-one relationships):
```php
$users = User::with('profile')->get();
```
142. Custom Validation Rule for Conditional Validation (Creating custom validation rules with conditional logic):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value, $parameters)
{
if ($parameters[0] === 'conditional_value') {
return $value === 'required_value';
}
return true;
}
public function message()
{
return 'The field must match the condition.';
}
}
```
143. Database Eloquent Eager Loading Constraints (Eager loading relationships with constraints):
```php
$users = User::with(['posts' => function ($query) {
$query->where('published', true);
}])->get();
```
144. Custom Validation Rule with Message Replacement (Custom validation rule with message replacement):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value)
{
return $value === 'custom_value';
}
public function message()
{
return 'The field must be "custom_value". :value';
}
}
```
145. Database Eloquent Many-to-Many Eager Loading (Eager loading many-to-many relationships):
```php
$users = User::with('roles')->get();
```
146. Custom Validation Rule for Database Uniqueness (Creating custom validation rules for checking database uniqueness):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value)
{
return !DB::table('table')->where('column', $value)->exists();
}
public function message()
{
return 'The field must be unique in the database.';
}
}
```
147. Database Eloquent Global Scope Removal (Removing global scopes temporarily):
```php
$query = ModelName::withoutGlobalScope(MyScope::class)->get();
```
148. Custom Validation Rule for File Validation (Creating custom validation rules for file validation):
```php
// Custom validation rule class
class MyCustomRule implements Rule
{
public function passes($attribute, $value)
{
return File::exists($value);
}
public function message()
{
return 'The file does not exist.';
}
}
```
149. Database Eloquent Joining Subqueries (Joining subqueries in Eloquent queries):
```php
$subquery = DB::table('subtable')->select('subcolumn')->where('subcondition', '=', 'subvalue');
$results = DB::table('maintable')
->joinSub($subquery, 'alias', function ($join) {
$join->on('maintable.column', '=', 'alias.subcolumn');
})
->get();
```
150. Custom Validation Rule for Password Confirmation (Creating custom validation rules for password confirmation):
```php
// Custom validation rule class
class ConfirmPasswordRule implements Rule
{
public function passes($attribute, $value, $parameters)
{
return Hash::check($value, $parameters[0]);
}
public function message()
{
return 'The password confirmation does not match.';
}
}
```
151. Database Eloquent Subquery with Aliases (Using subqueries with aliases in Eloquent queries):
```php
$subquery = DB::table('subtable')
->select('subcolumn')
->whereColumn('maintable.column', '=', 'subtable.column');
$results = DB::table('maintable')
->select('column', 'alias.subcolumn')
->joinSub($subquery, 'alias')
->get();
```
152. Custom Validation Rule for Unique Composite Key (Creating custom validation rules for unique composite keys):
```php
// Custom validation rule class
class UniqueCompositeRule implements Rule
{
public function passes($attribute, $values)
{
return !DB::table('table')
->where('column1', $values[0])
->where('column2', $values[1])
->exists();
}
public function message()
{
return 'The combination of :attribute1 and :attribute2 must be unique.';
}
}
```
153. Database Eloquent Raw Joins with Bindings (Using raw joins with bindings in Eloquent queries):
```php
$results = ModelName::join(DB::raw('table b on a.column = :binding'), ['binding' => $value])
->get();
```
154. Custom Validation Rule for Date Validation (Creating custom validation rules for date validation):
```php
// Custom validation rule class
class DateValidationRule implements Rule
{
public function passes($attribute, $value)
{
return Carbon::parse($value)->isWeekday();
}
public function message()
{
return 'The date must be a weekday.';
}
}
```
155. Database Eloquent Left Join (Performing left joins in Eloquent queries):
```php
$results = ModelA::leftJoin('table_b', 'table_a.column', '=', 'table_b.column')
->where('table_b.column', '=', 'value')
->get();
```
156. Custom Validation Rule for Unique Constraint on Update (Creating custom validation rules for unique constraints on update):
```php
// Custom validation rule class
class UniqueOnUpdateRule implements Rule
{
public function passes($attribute, $value)
{
return !DB::table('table')
->where('column', '=', $value)
->where('id', '<>', $parameters[0])
->exists();
}
public function message()
{
return 'The :attribute is already taken.';
}
}
```
- Entering the English page