LeanMapperQuery

Lean Mapper-Abfrage

Lean Mapper Query ist ein Konzept eines Abfrageobjekts für die Lean Mapper-Bibliothek, das dabei hilft, komplexe Abfragen mithilfe automatischer Verknüpfungen zu erstellen ( Idee stammt aus der NotORM-Bibliothek ). Schauen Sie sich die vorgeschlagenen Basisklassen an. Die tschechische Dokumentation finden Sie im Wiki.

Merkmale

• verhält sich wie ein SQL Präprozessor, daher sind die meisten SQL-Ausdrücke verfügbar
• automatische Verknüpfungen mit der Punktnotation ( @book.tags.name )
• Möglichkeit, Repositorys oder Entitäten abzufragen
• Unterstützung für implizite Filter

Installation

Es kann über Composer installiert werden.

 composer require mbohuslavek/leanmapper-query

Was macht es?

Angenommen, wir haben die folgenden Repositorys:

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

class BookRepository extends BaseRepository
{
}

und die folgenden Einheiten:

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

Wir erstellen eine Abfrage :

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

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

Wenn wir nun alle Bücher erhalten möchten, deren Autor Karel heißt, müssen wir Folgendes tun:

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

Die Datenbankabfrage sieht folgendermaßen aus:

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

Sie können anhand der Punktnotation erkennen, dass automatische Verknüpfungen durchgeführt werden. Es unterstützt alle dem Lean Mapper bekannten Beziehungstypen.

Es ist sehr einfach, SQL-Funktionen zu verwenden. Wir können die Abfrage wie folgt aktualisieren:

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

wodurch sich die Datenbankabfrage wie folgt ändert:

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

Wiederholen Sie sich nicht

Sie können die Query -Klasse erweitern und Ihre eigenen Methoden definieren.

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

Entitäten abfragen

Es ist auch möglich, eine Entitätseigenschaft abzufragen ( derzeit nur die Eigenschaften mit BelongsToMany oder HasMany -Beziehungen ). Lassen Sie uns die BaseEntity -Klasse erstellen:

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
{
}

Beachten Sie, dass BaseEntity LeanMapperQuery Entity erweitern muss, um Folgendes zu ermöglichen.

Wir haben die Methode find als protected definiert, da Sie durch Angabe des Methodennamens in der Eigenschaft „ $magicMethodsPrefixes Entitäten wie diese abfragen können:

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

Die magische Methode findTags ruft schließlich Ihre geschützte Methode find mit „tags“ als erstem Argument auf.

Die resultierende Datenbankabfrage sieht folgendermaßen aus:

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

Die erste Bedingung in der where Klausel, [tag].[id] IN (1, 2) , wird von der durchlaufenden Entität übernommen ( Tags werden anhand der eigenen Tags dieser bestimmten Buchentität abgefragt ).

Was können Sie sonst noch tun?

Wenn wir BaseRepository und BaseEntity leicht modifizieren, können wir die Arbeit mit Abfrageobjekten vereinfachen. Um dies zu erreichen, sehen Sie sich die vorgeschlagenen Basisklassen an . Es macht Folgendes möglich.

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

// or...

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

Lizenz

Copyright (c) 2013 Michal Bohuslávek

Lizenziert unter der MIT-Lizenz.