Repository files navigation

This package adds functionalities to the Eloquent model and Query builder for MongoDB, using the original Laravel API.This library extends the original Laravel classes, so it uses exactly the same methods.

• Laravel MongoDB
  • Installation
    • Laravel version Compatibility
    • Laravel
    • Lumen
    • Non-Laravel projects
  • Testing
  • Database Testing
  • Configuration
  • Eloquent
    • Extending the base model
    • Soft Deletes
    • Dates
    • Basic Usage
    • MongoDB-specific operators
    • MongoDB-specific Geo operations
    • Inserts, updates and deletes
    • MongoDB specific operations
  • Relationships
    • Basic Usage
    • belongsToMany and pivots
    • EmbedsMany Relationship
    • EmbedsOne Relationship
  • Query Builder
    • Basic Usage
    • Available operations
  • Schema
    • Basic Usage
    • Geospatial indexes
  • Extending
    • Cross-Database Relationships
    • Authentication
    • Queues
  • Upgrading
    • Upgrading from version 2 to 3

Make sure you have the MongoDB PHP driver installed. You can find installation instructions athttp://php.net/manual/en/mongodb.installation.php

Install the package via Composer:

$ composer require jenssegers/mongodb

In case your Laravel version does NOT autoload the packages, add the service provider toconfig/app.php:

Jenssegers\Mongodb\MongodbServiceProvider::class,

For usage withLumen, add the service provider inbootstrap/app.php. In this file, you will also need to enable Eloquent. You must however ensure that your call to$app->withEloquent(); isbelow where you have registered theMongodbServiceProvider:

$app->register(Jenssegers\Mongodb\MongodbServiceProvider::class);$app->withEloquent();

The service provider will register a MongoDB database extension with the original database manager. There is no need to register additional facades or objects.

When using MongoDB connections, Laravel will automatically provide you with the corresponding MongoDB objects.

For usage outside Laravel, check out theCapsule manager and add:

$capsule->getDatabaseManager()->extend('mongodb',function($config,$name) {$config['name'] =$name;returnnewJenssegers\Mongodb\Connection($config);});

To run the test for this package, run:

docker-compose up

To reset the database after each test, add:

useIlluminate\Foundation\Testing\DatabaseMigrations;

Also inside each test classes, add:

useDatabaseMigrations;

Keep in mind that these traits are not yet supported:

• use Database Transactions;
• use RefreshDatabase;

You can use MongoDB either as the main database, either as a side database. To do so, add a newmongodb connection toconfig/database.php:

'mongodb' => ['driver' =>'mongodb','host' =>env('DB_HOST','127.0.0.1'),'port' =>env('DB_PORT',27017),'database' =>env('DB_DATABASE','homestead'),'username' =>env('DB_USERNAME','homestead'),'password' =>env('DB_PASSWORD','secret'),'options' => [// here you can pass more settings to the Mongo Driver Manager// see https://www.php.net/manual/en/mongodb-driver-manager.construct.php under "Uri Options" for a list of complete parameters that you can use'database' =>env('DB_AUTHENTICATION_DATABASE','admin'),// required with Mongo 3+    ],],

For multiple servers or replica set configurations, set the host to an array and specify each server host:

'mongodb' => ['driver' =>'mongodb','host' => ['server1','server2', ...],    ...'options' => ['replicaSet' =>'rs0',    ],],

If you wish to use a connection string instead of full key-value params, you can set it so. Check the documentation on MongoDB's URI format:https://docs.mongodb.com/manual/reference/connection-string/

'mongodb' => ['driver' =>'mongodb','dsn' =>env('DB_DSN'),'database' =>env('DB_DATABASE','homestead'),],

This package includes a MongoDB enabled Eloquent class that you can use to define models for corresponding collections.

useJenssegers\Mongodb\Eloquent\Model;class Bookextends Model{//}

Just like a normal model, the MongoDB model class will know which collection to use based on the model name. ForBook, the collectionbooks will be used.

To change the collection, pass the$collection property:

useJenssegers\Mongodb\Eloquent\Model;class Bookextends Model{protected$collection ='my_books_collection';}

NOTE: MongoDB documents are automatically stored with a unique ID that is stored in the_id property. If you wish to use your own ID, substitute the$primaryKey property and set it to your own primary key attribute name.

useJenssegers\Mongodb\Eloquent\Model;class Bookextends Model{protected$primaryKey ='id';}// Mongo will also create _id, but the 'id' property will be used for primary key actions like find().Book::create(['id' =>1,'title' =>'The Fault in Our Stars']);

Likewise, you may define aconnection property to override the name of the database connection that should be used when utilizing the model.

useJenssegers\Mongodb\Eloquent\Model;class Bookextends Model{protected$connection ='mongodb';}

When soft deleting a model, it is not actually removed from your database. Instead, a deleted_at timestamp is set on the record.

To enable soft deletes for a model, apply theJenssegers\Mongodb\Eloquent\SoftDeletes Trait to the model:

useJenssegers\Mongodb\Eloquent\SoftDeletes;class Userextends Model{use SoftDeletes;protected$dates = ['deleted_at'];}

For more information checkLaravel Docs about Soft Deleting.

Eloquent allows you to work with Carbon or DateTime objects instead of MongoDate objects. Internally, these dates will be converted to MongoDate objects when saved to the database.

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{protected$dates = ['birthday'];}

This allows you to execute queries like this:

$users = User::where('birthday','>',newDateTime('-18 years'))->get();

Retrieving all models

$users = User::all();

Retrieving a record by primary key

$user = User::find('517c43667db388101e00000f');

Where

$posts =    Post::where('author.name','John')        ->take(10)        ->get();

OR Statements

$posts =    Post::where('votes','>',0)        ->orWhere('is_approved',true)        ->get();

AND statements

$users =    User::where('age','>',18)        ->where('name','!=','John')        ->get();

whereIn

$users = User::whereIn('age', [16,18,20])->get();

When usingwhereNotIn objects will be returned if the field is non-existent. Combine withwhereNotNull('age') to leave out those documents.

whereBetween

$posts = Post::whereBetween('votes', [1,100])->get();

whereNull

$users = User::whereNull('age')->get();

Advanced wheres

$users =    User::where('name','John')        ->orWhere(function ($query) {return$query                ->where('votes','>',100)                ->where('title','<>','Admin');        })->get();

orderBy

$users = User::orderBy('age','desc')->get();

Offset & Limit (skip & take)

$users =    User::skip(10)        ->take(5)        ->get();

groupBy

Selected columns that are not grouped will be aggregated with the$last function.

$users =    Users::groupBy('title')        ->get(['title','name']);

Distinct

Distinct requires a field for which to return the distinct values.

$users = User::distinct()->get(['name']);// Equivalent to:$users = User::distinct('name')->get();

Distinct can be combined withwhere:

$users =    User::where('active',true)        ->distinct('name')        ->get();

Like

$spamComments = Comment::where('body','like','%spam%')->get();

Aggregation

Aggregations are only available for MongoDB versions greater than 2.2.x

$total = Product::count();$price = Product::max('price');$price = Product::min('price');$price = Product::avg('price');$total = Product::sum('price');

Aggregations can be combined withwhere:

$sold = Orders::where('sold',true)->sum('price');

Aggregations can be also used on sub-documents:

$total = Order::max('suborder.price');

NOTE: This aggregation only works with single sub-documents (likeEmbedsOne) not subdocument arrays (likeEmbedsMany).

Incrementing/Decrementing the value of a column

Perform increments or decrements (default 1) on specified attributes:

Cat::where('name','Kitty')->increment('age');Car::where('name','Toyota')->decrement('weight',50);

The number of updated objects is returned:

$count = User::increment('age');

You may also specify additional columns to update:

Cat::where('age',3)    ->increment('age',1, ['group' =>'Kitty Club']);Car::where('weight',300)    ->decrement('weight',100, ['latest_change' =>'carbon fiber']);

Exists

Matches documents that have the specified field.

User::where('age','exists',true)->get();

All

Matches arrays that contain all elements specified in the query.

User::where('roles','all', ['moderator','author'])->get();

Size

Selects documents if the array field is a specified size.

Post::where('tags','size',3)->get();

Regex

Selects documents where values match a specified regular expression.

useMongoDB\BSON\Regex;User::where('name','regex',newRegex('.*doe','i'))->get();

NOTE: you can also use the Laravel regexp operations. These are a bit more flexible and will automatically convert your regular expression string to aMongoDB\BSON\Regex object.

User::where('name','regexp','/.*doe/i')->get();

The inverse of regexp:

User::where('name','not regexp','/.*doe/i')->get();

Type

Selects documents if a field is of the specified type. For more information check:http://docs.mongodb.org/manual/reference/operator/query/type/#op._S_type

User::where('age','type',2)->get();

Mod

Performs a modulo operation on the value of a field and selects documents with a specified result.

User::where('age','mod', [10,0])->get();

Near

$bars = Bar::where('location','near', ['$geometry' => ['type' =>'Point','coordinates' => [            -0.1367563,// longitude51.5100913,// latitude        ],    ],'$maxDistance' =>50,])->get();

GeoWithin

$bars = Bar::where('location','geoWithin', ['$geometry' => ['type' =>'Polygon','coordinates' => [            [                [-0.1450383,51.5069158],                [-0.1367563,51.5100913],                [-0.1270247,51.5013233],                [-0.1450383,51.5069158],            ],        ],    ],])->get();

GeoIntersects

$bars = Bar::where('location','geoIntersects', ['$geometry' => ['type' =>'LineString','coordinates' => [            [-0.144044,51.515215],            [-0.129545,51.507864],        ],    ],])->get();

Inserting, updating and deleting records works just like the original Eloquent. Please checkLaravel Docs' Eloquent section.

Here, only the MongoDB-specific operations are specified.

Raw Expressions

These expressions will be injected directly into the query.

User::whereRaw(['age' => ['$gt' =>30,'$lt' =>40],])->get();

You can also perform raw expressions on the internal MongoCollection object. If this is executed on the model class, it will return a collection of models.

If this is executed on the query builder, it will return the original response.

Cursor timeout

To preventMongoCursorTimeout exceptions, you can manually set a timeout value that will be applied to the cursor:

DB::collection('users')->timeout(-1)->get();

Upsert

Update or insert a document. Additional options for the update method are passed directly to the native update method.

// Query BuilderDB::collection('users')    ->where('name','John')    ->update($data, ['upsert' =>true]);// Eloquent$user->update($data, ['upsert' =>true]);

Projections

You can apply projections to your queries using theproject method.

DB::collection('items')    ->project(['tags' => ['$slice' =>1]])    ->get();DB::collection('items')    ->project(['tags' => ['$slice' => [3,7]]])    ->get();

Projections with Pagination

$limit =25;$projections = ['id','name'];DB::collection('items')    ->paginate($limit,$projections);

Push

Add items to an array.

DB::collection('users')    ->where('name','John')    ->push('items','boots');$user->push('items','boots');

DB::collection('users')    ->where('name','John')    ->push('messages', ['from' =>'Jane Doe','message' =>'Hi John',    ]);$user->push('messages', ['from' =>'Jane Doe','message' =>'Hi John',]);

If youDON'T want duplicate items, set the third parameter totrue:

DB::collection('users')    ->where('name','John')    ->push('items','boots',true);$user->push('items','boots',true);

Pull

Remove an item from an array.

DB::collection('users')    ->where('name','John')    ->pull('items','boots');$user->pull('items','boots');

DB::collection('users')    ->where('name','John')    ->pull('messages', ['from' =>'Jane Doe','message' =>'Hi John',    ]);$user->pull('messages', ['from' =>'Jane Doe','message' =>'Hi John',]);

Unset

Remove one or more fields from a document.

DB::collection('users')    ->where('name','John')    ->unset('note');$user->unset('note');

The only available relationships are:

• hasOne
• hasMany
• belongsTo
• belongsToMany

The MongoDB-specific relationships are:

• embedsOne
• embedsMany

Here is a small example:

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{publicfunctionitems()    {return$this->hasMany(Item::class);    }}

The inverse relation ofhasMany isbelongsTo:

useJenssegers\Mongodb\Eloquent\Model;class Itemextends Model{publicfunctionuser()    {return$this->belongsTo(User::class);    }}

The belongsToMany relation will not use a pivot "table" but will push id's to arelated_ids attribute instead. This makes the second parameter for the belongsToMany method useless.

If you want to define custom keys for your relation, set it tonull:

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{publicfunctiongroups()    {return$this->belongsToMany(            Group::class,null,'user_ids','group_ids'        );    }}

If you want to embed models, rather than referencing them, you can use theembedsMany relation. This relation is similar to thehasMany relation but embeds the models inside the parent object.

REMEMBER: These relations return Eloquent collections, they don't return query builder objects!

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{publicfunctionbooks()    {return$this->embedsMany(Book::class);    }}

You can access the embedded models through the dynamic property:

$user = User::first();foreach ($user->booksas$book) {//}

The inverse relation is automagically available. You don't need to define this reverse relation.

$book = Book::first();$user =$book->user;

Inserting and updating embedded models works similar to thehasMany relation:

$book =$user->books()->save(newBook(['title' =>'A Game of Thrones']));// or$book =$user->books()         ->create(['title' =>'A Game of Thrones']);

You can update embedded models using theirsave method (available since release 2.0.0):

$book =$user->books()->first();$book->title ='A Game of Thrones';$book->save();

You can remove an embedded model by using thedestroy method on the relation, or thedelete method on the model (available since release 2.0.0):

$book->delete();// Similar operation$user->books()->destroy($book);

If you want to add or remove an embedded model, without touching the database, you can use theassociate anddissociate methods.

To eventually write the changes to the database, save the parent object:

$user->books()->associate($book);$user->save();

Like other relations, embedsMany assumes the local key of the relationship based on the model name. You can override the default local key by passing a second argument to the embedsMany method:

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{publicfunctionbooks()    {return$this->embedsMany(Book::class,'local_key');    }}

Embedded relations will return a Collection of embedded items instead of a query builder. Check out the available operations here:https://laravel.com/docs/master/collections

The embedsOne relation is similar to the embedsMany relation, but only embeds a single model.

useJenssegers\Mongodb\Eloquent\Model;class Bookextends Model{publicfunctionauthor()    {return$this->embedsOne(Author::class);    }}

You can access the embedded models through the dynamic property:

$book = Book::first();$author =$book->author;

Inserting and updating embedded models works similar to thehasOne relation:

$author =$book->author()->save(newAuthor(['name' =>'John Doe']));// Similar$author =$book->author()         ->create(['name' =>'John Doe']);

You can update the embedded model using thesave method (available since release 2.0.0):

$author =$book->author;$author->name ='Jane Doe';$author->save();

You can replace the embedded model with a new model like this:

$newAuthor =newAuthor(['name' =>'Jane Doe']);$book->author()->save($newAuthor);

The database driver plugs right into the original query builder.

When using MongoDB connections, you will be able to build fluent queries to perform database operations.

For your convenience, there is acollection alias fortable as well as some additional MongoDB specific operators/operations.

$books =DB::collection('books')->get();$hungerGames =DB::collection('books')        ->where('name','Hunger Games')        ->first();

If you are familiar withEloquent Queries, there is the same functionality.

To see the available operations, check theEloquent section.

The database driver also has (limited) schema builder support. You can easily manipulate collections and set indexes.

Schema::create('users',function ($collection) {$collection->index('name');$collection->unique('email');});

You can also pass all the parameters specifiedin the MongoDB docs to the$options parameter:

Schema::create('users',function ($collection) {$collection->index('username',null,null,        ['sparse' =>true,'unique' =>true,'background' =>true,        ]    );});

Inherited operations:

• create and drop
• collection
• hasCollection
• index and dropIndex (compound indexes supported as well)
• unique

MongoDB specific operations:

• background
• sparse
• expire
• geospatial

All other (unsupported) operations are implemented as dummy pass-through methods because MongoDB does not use a predefined schema.

Read more about the schema builder onLaravel Docs

Geospatial indexes are handy for querying location-based documents.

They come in two forms:2d and2dsphere. Use the schema builder to add these to a collection.

Schema::create('bars',function ($collection) {$collection->geospatial('location','2d');});

To add a2dsphere index:

Schema::create('bars',function ($collection) {$collection->geospatial('location','2dsphere');});

If you're using a hybrid MongoDB and SQL setup, you can define relationships across them.

The model will automatically return a MongoDB-related or SQL-related relation based on the type of the related model.

If you want this functionality to work both ways, your SQL-models will need to use theJenssegers\Mongodb\Eloquent\HybridRelations trait.

This functionality only works forhasOne,hasMany andbelongsTo.

The MySQL model should use theHybridRelations trait:

useJenssegers\Mongodb\Eloquent\HybridRelations;class Userextends Model{use HybridRelations;protected$connection ='mysql';publicfunctionmessages()    {return$this->hasMany(Message::class);    }}

Within your MongoDB model, you should define the relationship:

useJenssegers\Mongodb\Eloquent\Model;class Messageextends Model{protected$connection ='mongodb';publicfunctionuser()    {return$this->belongsTo(User::class);    }}

If you want to use Laravel's native Auth functionality, register this included service provider:

Jenssegers\Mongodb\Auth\PasswordResetServiceProvider::class,

This service provider will slightly modify the internal DatabaseReminderRepository to add support for MongoDB based password reminders.

If you don't use password reminders, you don't have to register this service provider and everything else should work just fine.

If you want to use MongoDB as your database backend, change the driver inconfig/queue.php:

'connections' => ['database' => ['driver' =>'mongodb','table' =>'jobs','queue' =>'default','expire' =>60,    ],],

If you want to use MongoDB to handle failed jobs, change the database inconfig/queue.php:

'failed' => ['driver' =>env('QUEUE_FAILED_DRIVER','database'),'database' =>env('DB_CONNECTION','mongodb'),'table' =>'failed_jobs',],

Or simply set your ownQUEUE_FAILED_DRIVER environment variable tomongodb

QUEUE_FAILED_DRIVER=mongodb

Last, add the service provider inconfig/app.php:

Jenssegers\Mongodb\MongodbQueueServiceProvider::class,

In this new major release which supports the new MongoDB PHP extension, we also moved the location of the Model class and replaced the MySQL model class with a trait.

Please change allJenssegers\Mongodb\Model references toJenssegers\Mongodb\Eloquent\Model either at the top of your model files or your registered alias.

useJenssegers\Mongodb\Eloquent\Model;class Userextends Model{//}

If you are using hybrid relations, your MySQL classes should now extend the original Eloquent model classIlluminate\Database\Eloquent\Model instead of the removedJenssegers\Eloquent\Model.

Instead use the newJenssegers\Mongodb\Eloquent\HybridRelations trait. This should make things more clear as there is only one single model class in this package.

useJenssegers\Mongodb\Eloquent\HybridRelations;class Userextends Model{use HybridRelations;protected$connection ='mysql';}

Embedded relations now return anIlluminate\Database\Eloquent\Collection rather than a custom Collection class. If you were using one of the special methods that were available, convert them to Collection operations.

$books =$user->books()->sortBy('title')->get();