This package is abandoned and no longer maintained. No replacement package was suggested.

Small and fast library to make reusable tools persistence backend agnostic.

dev-master 2012-07-10 14:48 UTC

This package is not auto-updated.

Last update: 2016-03-09 06:32:29 UTC


Build Status

Molino is a small and fast library to make reusable tools persistence backend agnostic.

Molino doesn't provide anything for defining models. This means that you have to define the models for the backend you want to work with in a normal way.


You work with a molino, which is just an implementation of the MolinoInterface:

$molino = new Molino();


Each molino must have a name:

$name = $molino->getName();

Creating models

You can create models by using the createModel method with the model class as the first argument:

$article = $molino->create('Model\Article');

Setting and getting data

As using setters and getters is a convention nowadays, Molino doesn't include any method to abstract this. So that you can use setters and getters in a normal way with the models:

$title = $article->getTitle();

Saving models

You can save models by using the saveModel method:


Refreshing models

You can refresh models by using the refreshModel method:


Deleting models

You can delete models by using the deleteModel method:



Molino has three types of queries: select, update and delete, which you can create from the molino:

$selectQuery = $molino->createSelectQuery('Model\Article');
$updateQuery = $molino->createUpdateQuery('Model\Article');
$deleteQuery = $molino->createDeleteQuery('Model\Article');

Molino and model class

You can access to the molino and model class from all queries:

$molino = $query->getMolino();
$modelClass = $query->getModelClass();


The three types of queries can be filtered:

$query->filterEqual('name', 'Pablo');
$query->filterNotEqual('name', 'Pablo');

$query->filterLike('name', 'Pablo*');
$query->filterNotLike('name', '*Pablo');

$query->filterIn('name', array('Pablo', 'Pepe'));
$query->filterNotIn('name', array('Pablo', 'Pepe'));

$query->filterGreater('age', 20);
$query->filterLess('age', 20);
$query->filterGreaterEqual('age', 20);
$query->filterLessEqual('age', 20);

You can also use the filter method, which links to those methods:

$query->filter('name', '==', 'Pablo');
$query->filter('name', '!=', 'Pablo');

$query->filter('name', 'in', array('Pablo', 'Pepe'));
$query->filter('name', 'not_in', array('Pablo', 'Pepe'));

$query->filter('age', '>', 20);
$query->filter('age', '<', 20);
$query->filter('age', '>=, 20);
$query->filter('age', '<=', 2');


You can specify the fields you want to select:

$selectQuery->select(array('title', 'content'));

You can sort, limit, skip:

$selectQuery->sort('name', 'asc'); // asc o desc

You can retrieve all, one and the number of results:

$articles = $selectQuery->all();
$article = $selectQuery->one();
$nbArticles = $selectQuery->count();

Select queries implement both the Countable and IteratorAggregate interfaces:

$nb = count($selectQuery);
foreach ($selectQuery as $model) {
    // ...

Select queries allow you to create an adapter for Pagerfanta:

use Pagerfanta\Pagerfanta;

$adapter = $selectQuery->createPagerfantaAdapter();
$pagerfanta = new Pagerfanta($adapter);


You can set and increment fields:

$updateQuery->set('name', 'Pablo');
$updateQuery->inc('age', 1);

Then you execute the update queries:



Remove queries can only be filtered and executed:


Fluent interface

All queries implement a fluent interface:

$articles = $molino->createSelectQuery('Model\Article')
    ->filterEqual('isActive', true)
    ->sort('createdAt', 'desc')


Molino comes with two molinos:


To work with Mandango:

use Molino\Mandango\Molino;

$molino = new Molino($mandango);
$molino->getName() // mandango

Doctrine ORM

To work with Doctrine ORM:

use Molino\Doctrine\ORM\Molino;

$molino = new Molino($entityManager);
$molino->getName() // doctrine_orm


You can optionally use events with molinos. In order to do that you have to use the class EventMolino, which receives a molino and an event dispatcher. You can use the event molino in a normal way, as it also implements the MolinoInterface it simply wraps a molino for use with events.

EventMolino depends on the Symfony2 EventDispatcher component, since it must receive an instance of Symfony\Component\EventDispatcher\EventDispatcherInterface as event dispatcher.

use Molino\Mandango\Molino;
use Molino\EventMolino;
use Symfony\Component\EventDispatcher\EventDispatcher;

$eventDispatcher = new EventDispatcher();
$mandangoMolino = new Molino($mandango);
$molino = new EventMolino($mandangoMolino, $eventDispatcher);

// using the final molino in a normal way
$model = $molino->createSelectQuery('Model\Article')
    ->filterEqual('is_active', true)
    ->sort('created_at', 'desc')

Event classes

There are two event classes used:

  • Molino\Event\ModelEvent: for events with a model.
  • Molino\Event\QueryEvent: for events with a query.

You can access to the molino in both classes:

$molino = $modelEvent->getMolino();
$molino = $queryEvent->getMolino();

And to the model or query depending on the class:

$model = $modelEvent->getModel();

$query = $queryEvent->getQuery();


The events you can use are saved as constants in the class Molino\Event\Events. They are:

  • CREATE: when creating a model. It uses a ModelEvent.
  • PRE_SAVE: before saving a model. It uses a ModelEvent.
  • POST_SAVE: after saving a model. It uses a ModelEvent.
  • PRE_REFRESH: before refreshing a model. It uses a ModelEvent.
  • POST_REFRESH: after refreshing a model. It uses a ModelEvent.
  • PRE_DELETE: before deleting a model. It uses a ModelEvent.
  • POST_DELETE: after deleting a model. It uses a ModelEvent.
  • CREATE_QUERY: when creating any query (select, update, delete). It uses a QueryEvent.


Assigning an author to the articles automatically when creating articles:

use Molino\Event\Events;
use Molino\Event\ModelEvent;
use Model\Article;

$author = get_author();

$eventDispather->addListener(Events::CREATE, function (ModelEvent $event) use ($author) {
    if ($event->getModel() instanceof Article) {

Filtering all articles queries by an author:

use Molino\Event\Events;
use Molino\Event\QueryEvent;

$author = get_author();

$eventDispather->addListener(Events::CREATE_QUERY, function (QueryEvent $event) use ($author) {
    if ('Model\Article' === $event->getQuery()->getModelClass()) {
        $event->getQuery()->filterEqual('author_id', $author->getId());


You can do many things with Molino, but as you can probably guess you can't do everything as its API is small (though it's like this to be compatible with different backends).

Anyway, this doesn't mean you can't do complex things compatible with different backends. You just need to implement the parts you can't do with Molino directly by discriminating by backend:

if ('mandango' === $molino->getName()) {
    // Mandango implementation
} elseif ('doctrine_orm' === $molino->getName()) {
    // Doctrine ORM implementation
} else {
    throw new \RuntimeException('This application only works with the following molinos: "mandango", "doctrine_orm".');


Pablo Díez -


Molino is licensed under the MIT License. See the LICENSE file for full details.