The document provides an overview of the Laravel framework's Eloquent ORM and database operations. It discusses how to define Eloquent models and perform common CRUD operations and queries. It also covers relationships, scopes, eager loading, and other features of working with databases using Eloquent.

1. LARAVEL FRAMEWORK
DB OPERATIONS
ELOQUENT MODEL
Sayed Ahmed
Computer Engineering, BUET, Bangladesh (Graduated on
2001)
MSc., Computer Science, Canada
http://www.justetc.net

2. INSTALLING
 You can install by using Composer
 http://getcomposer.org/doc/00-intro.md

3. DB STUFF
 How and where to configure
 app/config/database.php
 Supported Databases
 MySQL, Postgres, SQLite, and SQL Server
 Running A Select Query
 $results = DB::select('select * from users where id =
?', array(1));
 Running An Insert Statement
 DB::insert('insert into users (id, name) values (?, ?)',
array(1, 'Dayle'));

4. DB STUFF
 Running An Update Statement
 DB::update('update users set votes = 100 where
name = ?', array('John'));
 Running A General Statement
 DB::statement('drop table users');
 Listening For Query Events
 DB::listen(function($sql, $bindings, $time) { // });

5. DB STUFF
 Database transactions
 DB::transaction(function() {
 DB::table('users')->update(array('votes' => 1));
 DB::table('posts')->delete();
 })
 Access Connections
 $users = DB::connection('foo')->select(...);
 Access raw PDO instance
 $pdo = DB::connection()->getPdo()
 Reconnect
 DB::reconnect('foo');

6. DB STUFF
 Query Logging
 DB::connection()->disableQueryLog();
 $queries = DB::getQueryLog();
 Note: QueryLogging is enabled by default

7. QUERY BUILDER
 Select : All Rows
 $users = DB::table('users')->get();
 foreach ($users as $user) {
 var_dump($user->name);
 }
 Single Row
 $user = DB::table('users')->where('name',
'John')->first();
 var_dump($user->name);

8. QUERY BUILDER
 Single column from a row
 $name = DB::table('users')->where('name', 'John')-
>pluck('name');
 A List Of Column Values
 $roles = DB::table('roles')->lists('title');
 $roles = DB::table('roles')->lists('title', 'name');
 $users = DB::table('users')->select('name', 'email')-
>get();
 $users = DB::table('users')->distinct()->get();
 -$users = DB::table('users')->select('name as
user_name')->get();

9. QUERY BUILDER
 Where
 $users = DB::table('users')->where('votes', '>',
100)->get();
 $users = DB::table('users') ->where('votes', '>',
100) ->orWhere('name', 'John') ->get();
 Order by, group by
 $users = DB::table('users') ->orderBy('name',
'desc') ->groupBy('count') ->having('count', '>',
100) ->get();

10. QUERY BUILDER
 Offset and limit
 $users = DB::table('users')->skip(10)->take(5)-
>get();

11. JOINS
 Basic
 DB::table('users') ->join('contacts', 'users.id', '=',
'contacts.user_id') ->join('orders', 'users.id', '=',
'orders.user_id') ->select('users.id',
'contacts.phone', 'orders.price');
 Left
 DB::table('users') ->leftJoin('posts', 'users.id', '=',
'posts.user_id') ->get();

12. JOINS
 Complex
 DB::table('users') ->join('contacts', function($join)
{ $join->on('users.id', '=',
'contacts.user_id')- >orOn(...);
 }) ->get();

13. OTHERS
 Advanced whereas
 DB::table('users') ->where('name', '=', 'John') -
>orWhere(function($query) { $query-
>where('votes', '>', 100) ->where('title', '<>',
'Admin'); }) ->get();
 Exists
 DB::table('users') ->whereExists(function($query)
{ $query->select(DB::raw(1)) ->from('orders') -
>whereRaw('orders.user_id = users.id'); }) -
>get();

14. AGGREGATE METHODS
 $users = DB::table('users')->count();
 $price = DB::table('orders')->max('price');
 $price = DB::table('orders')->min('price');
 $price = DB::table('orders')->avg('price');
 $total = DB::table('users')->sum('votes');

15. QUERY BUILDERS
 Raw Expressions
 $users = DB::table('users')
 ->select(DB::raw('count(*) as user_count,
status'))
 ->where('status', '<>', 1) ->groupBy('status') -
>get();

16. INCREMENT/DECREMENT
 DB::table('users')->increment('votes');
 DB::table('users')->increment('votes', 5);
 DB::table('users')->decrement('votes');
 DB::table('users')->decrement('votes', 5);
 DB::table('users')->increment('votes', 1,
array('name' => 'John'));

17. INSERTS
 Inserting Records into a table
 DB::table('users')->insert( array('email' =>
'john@example.com', 'votes' => 0) );
 $id = DB::table('users')->insertGetId(
array('email' => 'john@example.com', 'votes' =>
0) );
 DB::table('users')->insert(array( array('email' =>
'taylor@example.com', 'votes' => 0), array('email'
=> 'dayle@example.com', 'votes' => 0), ));

18. UPDATES
 DB::table('users') ->where('id', 1) -
>update(array('votes' => 1));
 Deletes
 DB::table('users')->where('votes', '<', 100)-
>delete();
 DB::table('users')->delete();
 DB::table('users')->truncate();

19. UNIONS
 $first = DB::table('users')
 ->whereNull('first_name');
 $users = DB::table('users')
 ->whereNull('last_name')->union($first)->get();
 Caching Results
 $users = DB::table('users')->remember(10)-
>get();
 Remember for 10 minutes

20. ELOQUENT ORM
 The Eloquent ORM included with Laravel
provides a beautiful, simple ActiveRecord
implementation for working with your
database. Each database table has a
corresponding "Model" which is used to
interact with that table.

21. ELOQUENT MODEL
 Defining An Eloquent Model
 class User extends Eloquent {}
 By default it will point to the table users
 Lowercase and plural form
 class User extends Eloquent {
 protected $table = 'my_users';
 }
 Note: you can use properties such as primaryKey
and connection
 All table should have createdat and updatedat
columns else use $timestamps = false in the model

22. ELOQUENT MODEL AND DB OPERATIONS
 Retrieve All
 $users = User::all();
 Retrieve by Primary key
 $user = User::find(1);
 var_dump($user->name);
 Retrieve or Throw exception
 $model = User::findOrFail(1); $model =
User::where('votes', '>', 100)->firstOrFail();

23. HANDLING EXCEPTIONS
 Handling Exceptions
 use
IlluminateDatabaseEloquentModelNotFoundEx
ception;
App::error(function(ModelNotFoundException
$e) { return Response::make('Not Found', 404);
});

24. QUERYING
 Querying
 $users = User::where('votes', '>', 100)->take(10)-
>get(); foreach ($users as $user) {
var_dump($user->name); }
 Aggregates
 $count = User::where('votes', '>', 100)->count();
 $users = User::whereRaw('age > ? and votes = 100',
array(25))->get();
 Connection to use
 $user = User::on('connection-name')->find(1);

25. FILLABLE
 The fillable property specifies which attributes
should be mass-assignable. This can be set at
the class or instance level.
 class User extends Eloquent {
 protected $fillable = array('first_name', 'last_name',
'email'); }
 Guarded (not mass assignable)
 class User extends Eloquent {
 protected $guarded = array('id', 'password');
 }

26. BLOCKING AND INSERTION
 Block all attributes from mass assignment
 protected $guarded = array('*');
 Insert a new row
 $user = new User;
 $user->name = 'John';
 $user->save();

27. UPDATE A ROW
 $user = User::create(array('name' =>
'John'));
 Updating a retrieved model
 $user = User::find(1); $user->email =
'john@foo.com'; $user->save();

28. SOME SAVE, UPDATE, DELETE STUFF
 Saving a model and relationship
 $user->push();
 Updates as queries
 $affectedRows = User::where('votes', '>', 100)
 ->update(array('status' => 2));
 Delete by key
 User::destroy(1);
 User::destroy(array(1, 2, 3));
 User::destroy(1, 2, 3);

29.  Updating Model’s Timestamp
 $user->touch();
 Soft Delete
 class User extends Eloquent { protected $softDelete
= true; }
 $table->softDeletes();
 Soft deleted stuff into results (trashed + untrashed)
 $table->softDeletes();
 Only Trashed
 $users = User::onlyTrashed()->where('account_id', 1)-
>get();

30.  Restore softdeleted into active
 $user->restore();
 On query
 User::withTrashed()->where('account_id', 1)-
>restore();
 On relationships
 $user->posts()->restore();

31. FORCEDELETE
 $user->forceDelete();
 $user->posts()->forceDelete();

32. QUERY SCOPES
 Like variable Scope
 Define query scope
 class User extends Eloquent {
 public function scopePopular($query) {
 return $query->where('votes', '>', 100);
 }
 public function scopeWomen($query) {
 return $query->whereGender('W');
 }
 }

33.  Utilize Query Scopes
 $users = User::popular()->women()-
>orderBy('created_at')->get();
 Dynamic Scopes
 class User extends Eloquent {
 public function scopeOfType($query, $type) {
 return $query->whereType($type);
 }
 }

34.  $users = User::ofType('member')->get();

35. RELATIONSHIPS
 One To One
 One To Many
 Many To Many
 Polymorphic Relations

36. DEFINE ONE TO ONE
 class User extends Eloquent {
 public function phone() {
 return $this->hasOne('Phone');
 }
 }
 Use
 $phone = User::find(1)->phone;

37. INVERSE OF A RELATION
 class Phone extends Eloquent {
 public function user() {
 return $this->belongsTo('User');
 }
 }
 class Phone extends Eloquent {
 public function user() {
 return $this->belongsTo('User', 'custom_key');
 }
 }`

38.  class Phone extends Eloquent {
 public function user() {
 return $this->belongsTo('User', 'custom_key');
 }
 }

39. ONE TO MANY
 class Post extends Eloquent {
 public function comments() {
 return $this->hasMany('Comment');
 }
 }
 return $this->hasMany('Comment',
'custom_key');
 $comments = Post::find(1)->comments;
 $comments = Post::find(1)->comments()
 ->where('title', '=', 'foo')->first();

40. INVERSE OF A RELATION
 class Comment extends Eloquent {
 public function post() {
 return $this->belongsTo('Post');
 }
 }

41. MANY TO MANY
 class User extends Eloquent {
 public function roles() {
 return $this->belongsToMany('Role');
 }
 }
 return $this->belongsToMany('Role',
'user_roles');
 return $this->belongsToMany('Role',
'user_roles', 'user_id', 'foo_id');
 $roles = User::find(1)->roles;

42. INVERSE OF A RELATION
 class Role extends Eloquent {
 public function users() {
 return $this->belongsToMany('User');
 }
 }

43. POLYMORPHIC RELATIONS
 Polymorphic relations allow a model to
belong to more than one other model, on a
single association.

44.  class Photo extends Eloquent { public
function imageable() { return $this-
>morphTo(); } } class Staff extends Eloquent
{ public function photos() { return $this-
>morphMany('Photo', 'imageable'); } } class
Order extends Eloquent { public function
photos() { return $this->morphMany('Photo',
'imageable'); } }

45. USE
 $staff = Staff::find(1); foreach ($staff->photos
as $photo) { // }
 $photo = Photo::find(1);
 $imageable = $photo->imageable;

46. QUERYING RELATIONS
 $posts = Post::has('comments')->get()
 $posts = Post::has('comments', '>=', 3)-
>get();

47. DYNAMIC PROPERTIES
 Eloquent allows you to access your relations
via dynamic properties. Eloquent will
automatically load the relationship for you,
and is even smart enough to know whether
to call the get (for one-to-many relationships)
or first (for one-to-one relationships) method

48. EAGER LOADING
 Will hit db 26 times for 25 books
 foreach (Book::all() as $book) { echo $book-
>author->name; }
 Is reduced to two queries
 foreach (Book::with('author')->get() as $book) {
echo $book->author->name; }
 select * from books select * from authors where
id in (1, 2, 3, 4, 5, ...)

49.  With constraints
 $users = User::with(array('posts' =>
function($query) { $query->where('title', 'like',
'%first%'); }))->get();

50. MUST SEE
 http://codehappy.daylerees.com/eloquent-
orm
 http://net.tutsplus.com/tutorials/php/build-
web-apps-from-scratch-with-laravel-the-
eloquent-orm/