PHPackages                             joseki/leanmapper-query - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. joseki/leanmapper-query

ActiveLibrary[Database & ORM](/categories/database)

joseki/leanmapper-query
=======================

Concept of Query Object for LeanMapper

v1.1.0(10y ago)01.4k[1 issues](https://github.com/Joseki/LeanMapperQuery/issues)1MITPHP

Since Dec 29Pushed 10y ago1 watchersCompare

[ Source](https://github.com/Joseki/LeanMapperQuery)[ Packagist](https://packagist.org/packages/joseki/leanmapper-query)[ RSS](/packages/joseki-leanmapper-query/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (2)Dependencies (2)Versions (5)Used By (1)

Lean Mapper Query
=================

[](#lean-mapper-query)

Lean Mapper Query is a concept of a *query object* for [Lean Mapper library](https://github.com/Tharos/LeanMapper) which helps to build complex queries using automatic joins (*idea taken from [NotORM library](http://www.notorm.com/)*). Look at the [suggested base classes](https://gist.github.com/mbohuslavek/9410266). For Czech documentation have a look at the [wiki](https://github.com/mbohuslavek/LeanMapperQuery/wiki).

Features
--------

[](#features)

- it behaves as an `SQL` preprocessor, hence most SQL expressions are available
- automatic joins using *dot notation* (`@book.tags.name`)
- ability to query both repositories or entities
- support for implicit filters

Installation
------------

[](#installation)

It can be installed via [Composer](http://getcomposer.org/download).

```
composer require mbohuslavek/leanmapper-query:@dev

```

What does it do?
----------------

[](#what-does-it-do)

Suppose we have following repositories:

```
class BaseRepository extends LeanMapper\Repository
{
	public function find(IQuery $query)
	{
		$this->createEntities($query
			->applyQuery($this->createFluent(), $this->mapper)
			->fetchAll()
		);
	}
}

class BookRepository extends BaseRepository
{
}
```

and following entities:

```
/**
 * @property int $id
 * @property string $name
 */
class Tag extends LeanMapper\Entity
{
}

/**
 * @property int $id
 * @property Author $author m:hasOne
 * @property Tag[] $tags m:hasMany
 * @property DateTime $pubdate
 * @property string $name
 * @property bool $available
 */
class Book extends LeanMapper\Entity
{
}

/**
 * @property int $id
 * @property string $name
 * @property Book[] $books m:belongsToMany
 */
class Author extends LeanMapper\Entity
{
}
```

We build a *query*:

```
$query = new LeanMapperQuery\Query;
$query->where('@author.name', 'Karel');
```

Now, if we want to get all books whose author's name is Karel, we have to do this:

```
$bookRepository = new BookRepository(...);
$books = $bookRepository->find($query);
```

Database query will look like this:

```
SELECT [book].*
FROM [book]
LEFT JOIN [author] ON [book].[author_id] = [author].[id]
WHERE ([author].[name] = 'Karel')
```

You can see it performs automatic joins via *dot notation*. It supports all types of relationships which are known to **Lean Mapper**.

It is very easy to use SQL functions. We can update query like this:

```
$query->where('DATE(@pubdate) > %d', '1998-01-01');
$books = $bookRepository->find($query);
```

and change the database query into following:

```
SELECT [book].*
FROM [book]
LEFT JOIN [author] ON [book].[author_id] = [author].[id]
WHERE ([author].[name] = 'Karel') AND (DATE([book].[pubdate]) > '1998-01-01')
```

Don't repeat yourself
---------------------

[](#dont-repeat-yourself)

You can extend `Query` and define own methods.

```
class BookQuery extends LeanMapperQuery\Query
{
	public function restrictAvailable()
	{
		$this->where('@available', TRUE)
			->orderBy('@author.name');
		return $this;
	}
}

/////////

$query = new BookQuery;
$query->restrictAvailable();
$books = $this->bookRepository->find($query);
```

Querying entities
-----------------

[](#querying-entities)

It is also possible to query an entity property (*currently only those properties with `BelongsToMany` or `HasMany` relationships*). Let's build `BaseEntity`:

```
class BaseEntity extends LeanMapperQuery\Entity
{
	protected static $magicMethodsPrefixes = array('find');

	protected function find($field, IQuery $query)
	{
		$entities = $this->queryProperty($field, $query);
		return $this->entityFactory->createCollection($entities);
	}
}

/*
 * ...
 */
class Book extends BaseEntity
{
}
```

*Note that `BaseEntity` extends `LeanMapperQuery\Entity` to make the following possible.*

We have defined the `find` method as `protected` because with specifying the method name in `$magicMethodsPrefixes` property you can query entities like this:

```
$book; // previously fetched instance of an entity from a repository
$query = new LeanMapper\Query;
$query->where('@name !=', 'ebook');
$tags = $book->findTags($query);
```

*The magic method `findTags` will eventually call your protected method `find` with 'tags' as the 1 argument.*

The resulting database query looks like this:

```
SELECT [tag].*
FROM [tag]
WHERE [tag].[id] IN (1, 2) AND ([tag].[name] != 'ebook')
```

The first condition in where clause `[tag].[id] IN (1, 2)` is taken from the entity traversing (*tags are queried against this particular book entity's own tags*).

What else you can do?
---------------------

[](#what-else-you-can-do)

If we slightly modify our `BaseRepository` and `BaseEntity` we can simplify working with query objects. *To achieve this look at the [suggested base classes](https://gist.github.com/mbohuslavek/9410266)*. It makes the following possible.

```
$books = $bookRepository->query()
	->where('@author.name', 'Karel')
	->where('DATE(@pubdate) > ?', '1998-01-01')
	->find();

// or...

$tags = $book->queryTags()
	->where('@name !=', 'ebook')
	->find();
```

License
-------

[](#license)

Copyright (c) 2013 Michal Bohuslávek

Licensed under the MIT license.

###  Health Score

31

—

LowBetter than 68% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity14

Limited adoption so far

Community11

Small or concentrated contributor base

Maturity66

Established project with proven stability

 Bus Factor1

Top contributor holds 98.4% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~277 days

Total

4

Last Release

3690d ago

Major Versions

v0.8 → v1.02015-02-19

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/1245190?v=4)[Miroslav Paulík](/maintainers/castamir)[@castamir](https://github.com/castamir)

---

Top Contributors

[![mibk](https://avatars.githubusercontent.com/u/2324898?v=4)](https://github.com/mibk "mibk (62 commits)")[![castamir](https://avatars.githubusercontent.com/u/1245190?v=4)](https://github.com/castamir "castamir (1 commits)")

### Embed Badge

![Health badge](/badges/joseki-leanmapper-query/health.svg)

```
[![Health](https://phpackages.com/badges/joseki-leanmapper-query/health.svg)](https://phpackages.com/packages/joseki-leanmapper-query)
```

###  Alternatives

[doctrine/orm

Object-Relational-Mapper for PHP

10.2k285.3M6.2k](/packages/doctrine-orm)[jdorn/sql-formatter

a PHP SQL highlighting library

3.9k115.1M102](/packages/jdorn-sql-formatter)[illuminate/database

The Illuminate Database package.

2.8k52.4M9.4k](/packages/illuminate-database)[ramsey/uuid-doctrine

Use ramsey/uuid as a Doctrine field type.

90440.3M211](/packages/ramsey-uuid-doctrine)[reliese/laravel

Reliese Components for Laravel Framework code generation.

1.7k3.4M16](/packages/reliese-laravel)[wildside/userstamps

Laravel Userstamps provides an Eloquent trait which automatically maintains `created\_by` and `updated\_by` columns on your model, populated by the currently authenticated user in your application.

7511.7M13](/packages/wildside-userstamps)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)