LeanMapperQuery

Requête Lean Mapper

Lean Mapper Query est un concept d' objet de requête pour la bibliothèque Lean Mapper qui permet de créer des requêtes complexes à l'aide de jointures automatiques ( idée tirée de la bibliothèque NotORM ). Regardez les classes de base suggérées. Pour la documentation tchèque, consultez le wiki.

Caractéristiques

• se comporte comme un préprocesseur SQL , donc la plupart des expressions SQL sont disponibles
• jointures automatiques utilisant la notation par points ( @book.tags.name )
• possibilité d'interroger des référentiels ou des entités
• prise en charge des filtres implicites

Installation

Il peut être installé via Composer.

 composer require mbohuslavek/leanmapper-query

Qu'est-ce que ça fait ?

Supposons que nous ayons les référentiels suivants :

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

class BookRepository extends BaseRepository
{
}

et les entités suivantes :

 /**
 * @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
{
}

Nous construisons une requête :

LeanMapperQueryQuery; $query->where('@author.name', 'Karel');">

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

Maintenant, si nous voulons obtenir tous les livres dont le nom d'auteur est Karel, nous devons faire ceci :

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

La requête de base de données ressemblera à ceci :

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

Vous pouvez voir qu'il effectue des jointures automatiques via la notation par points . Il prend en charge tous les types de relations connus de Lean Mapper .

Il est très simple d'utiliser les fonctions SQL. Nous pouvons mettre à jour la requête comme ceci :

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

qui change la requête de base de données comme suit :

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

Ne te répète pas

Vous pouvez étendre la classe Query et définir vos propres méthodes.

LeanMapperQueryQuery { public function restrictAvailable() { $this->where('@available', true) ->orderBy('@author.name'); return $this; } } ///////// $query = new BookQuery; $query->restrictAvailable(); $books = $this->bookRepository->find($query);">

 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 );

Interroger des entités

Il est également possible d'interroger une propriété d'entité ( actuellement uniquement les propriétés avec des relations BelongsToMany ou HasMany ). Créons la classe BaseEntity :

LeanMapperQueryEntity { protected static $magicMethodsPrefixes = ['find']; protected function find($field, Query $query) { $entities = $this->queryProperty($field, $query); return $this->entityFactory->createCollection($entities); } } /* * ... */ class Book extends BaseEntity { }">

 class BaseEntity extends LeanMapperQuery Entity
{
	protected static $ magicMethodsPrefixes = [ ' find ' ];

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

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

Notez que BaseEntity doit étendre LeanMapperQuery Entity pour rendre possible ce qui suit.

Nous avons défini la méthode find comme protected car en spécifiant le nom de la méthode dans la propriété $magicMethodsPrefixes , vous pouvez interroger des entités comme ceci :

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

La méthode magique findTags finira par appeler votre méthode protégée find avec « tags » comme premier argument.

La requête de base de données résultante ressemble à ceci :

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

La première condition de la clause where , [tag].[id] IN (1, 2) , est extraite de la traversée de l'entité ( les balises sont interrogées sur les propres balises de cette entité de livre particulière ).

Que pouvez-vous faire d'autre ?

Si nous modifions légèrement BaseRepository et BaseEntity , nous pouvons simplifier le travail avec les objets de requête. Pour y parvenir, examinez les classes de base suggérées . Cela rend possible ce qui suit.

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

// or...

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

Licence

Copyright (c) 2013 Michal Bohuslávek

Sous licence MIT.