Nextras\Orm – dalsi orm, fork YetOrmu

speciální selecty (auto join do jiné tabulky)

netusim co by to melo znamenat :D

další automatické inserty do jiných tabulek při uložení nové entity

onPersist by nestacilo?

Pěkné, určitě vyzkouším. Ale zůstává jeden problém, který mi taky trochu vadil už u YetORMu a asi je spjatý s NDb. Mohu vytvořit kolekci jinak, než jako Ndb Selection?
Konkrétně v tomto případě bych vůbec nechtěl vytvářet entitu Tag a pracovat s tagy jako s objekty. Tag je vlastnost entity Book a rád bych napsal getTags() tak, aby mi vracela pole stringů. (Což myslím nejde napsat ze směru od $book->cosi, ale pomocí query). Ale s výsledkem bych rád pracoval stejně jako s klasickou kolekcí (typicky na ni budu aplikovat order by). Dá se tohle nějak pořešit?

//Edit: Koukám, že mezitím popsal podobný problém @castamir. Prostě tím, že to funguje nad Ndb, tak musím entity a kolekce tvořit pomocí ActiveRow a Selection. Asi jsem si jen zatím nezvykl na tuto filosofii a trochu se bojím toho, že co nebudu umět zapsat, tam mi nepomůže ani čistá SQL query, kde by to napsat šlo..
Výhoda je naprostá jednoduchost a transparentnost těchto ORMů, protože ActiveRow za nás vyřeší většinu práce s generováním dotazů.

Editoval Šaman (27. 4. 2013 22:36)

@enumag +1

Mám asi týden na to dokončit ten svůj (chci ho použít v novém projektu). Dělám si k němu i generátor (já vím, jsem nehorázně zhnilej psát ty kostry entit ručně :D )

Jestli se ti to podaří, tak snad konečně začnu s klidným svědomím používat ORM framework :)
V Doctrině2 jsem válčil s jejich DQL, v Petrovo ORMu s neexistující dokumentací, Fabikovo DAO bylo docela fajn, ale narazil jsem na pár problémů, které jsem vyřešil migrací k YetORM. S tím jsem zatím nejvíc spokojený, takže jestli odstraníš i jeho slabiny, tak bude důvod k oslavě.

@tharos a i ostatni: zde je nejaky road plan:

• validace pred persistenci
• zbaveni se zavislosti na nette\database\table, pridani vrstvy pro mapovani, proste nejakeho mapperu, ale bude to velice easy :)
• parser pro use statement (idealne nekde vygrabovat)
• pridani podpory pro napovidani entity pro IDE

/**
 * @property Book[]|EntityCollection $books
 */
class Author extends Entity {}

• automaticka sprava vazev, 1:N, M:N. pribudou dalsi tridy *collection, ktere budou automaticky implementovat spravu techto vazeb. nebude tak treba tento boilerplate. Api by mohlo vypadat treba takto

/**
 * @property HasOneCollection $author (author_id, book)
 */
class Book extends Entity {}
/**
 * @property HasManyCollection $books (book, author_id)
 * @property HasManyCollection $translatedBooks (book, translator_id)
 */
class Author extends Entity {}

Kolekce samozrejme budou mit patricne api a metody pro jejich persistovani. Ano, je mi jasne, ze narazim na plno problemu, ale tak nejak si to vysnivam :)

Editoval hrach (28. 4. 2013 0:33)

hrach napsal(a):

• parser pro use statement (idealne nekde vygrabovat)

Kdyby Tě zajímal ten z „mého ORMka“, tak tady ho máš:

<?php

namespace Tharos\Reflection;

/**
 * @author Vojtěch Kohout
 */
class Aliases
{

	/** @var array */
	private $aliases = array();

	/** @var string */
	private $current = '';

	/** @var string */
	private $lastPart = '';


	public function resetCurrent()
	{
		$this->current = $this->lastPart = '';
	}

	/**
	 * @param string $name
	 */
	public function appendToCurrent($name)
	{
		if ($this->current !== '') {
			$this->current .= '\\';
		}
		$this->current .= $this->lastPart = $name;
	}

	/**
	 * @param string $name
	 */
	public function setLast($name)
	{
		$this->lastPart = $name;
	}

	public function finishCurrent()
	{
		$this->aliases[$this->lastPart] = $this->current;
		$this->resetCurrent();
	}

	/**
	 * @return array
	 */
	public function getAll()
	{
		return $this->aliases;
	}

}

<?php

namespace Tharos\Reflection;

use Tharos\Exception\UtilityClassException;

/**
 * @author Vojtěch Kohout
 */
class AliasesParser
{

	const STATE_WAITING_FOR_USE = 1;

	const STATE_GATHERING = 2;

	const STATE_IN_AS_PART = 3;

	const STATE_JUST_FINISHED = 4;


	/**
	 * @throws UtilityClassException
	 */
	public function __construct()
	{
		throw new UtilityClassException('Cannot instantiate utility class ' . get_called_class() . '.');
	}

	/**
	 * @param string $source
	 * @return array
	 */
	public static function parseSource($source)
	{
		$aliases = new Aliases;

		$states = array(
			self::STATE_WAITING_FOR_USE => function ($token) use ($aliases) {
				if (is_array($token) and $token[0] === T_USE) {
					$aliases->resetCurrent();
					return AliasesParser::STATE_GATHERING;
				}
				return AliasesParser::STATE_WAITING_FOR_USE;
			},
			self::STATE_GATHERING => function ($token) use ($aliases) {
				if (is_array($token)) {
					if ($token[0] === T_STRING) {
						$aliases->appendToCurrent($token[1]);
					} elseif ($token[0] === T_AS) {
						return AliasesParser::STATE_IN_AS_PART;
					}
				} else {
					if ($token === ';') {
						$aliases->finishCurrent();
						return AliasesParser::STATE_WAITING_FOR_USE;
					} elseif ($token === ',') {
						$aliases->finishCurrent();
					}
				}
				return AliasesParser::STATE_GATHERING;
			},
			self::STATE_IN_AS_PART => function ($token) use ($aliases) {
				if (is_array($token)) {
					if ($token[0] === T_STRING) {
						$aliases->setLast($token[1]);
						$aliases->finishCurrent();
						return AliasesParser::STATE_JUST_FINISHED;
					}
				}
				return AliasesParser::STATE_IN_AS_PART;
			},
			self::STATE_JUST_FINISHED => function ($token) use ($aliases) {
				if ($token === ';') {
					return AliasesParser::STATE_WAITING_FOR_USE;
				}
				return AliasesParser::STATE_GATHERING;
			}
		);

		$state = $states[self::STATE_WAITING_FOR_USE];
		foreach (token_get_all($source) as $token) {
			$state = $states[$state($token)];
			if (is_array($token)) {
				$token[3] = token_name($token[0]);
			}
		}

		return $aliases->getAll();
	}

}

Je to takovej callback-based stavovej automat. :) Měl by pokrývat vše myslitelné (včetně as, aliasů, více hodnot oddělených čárkou)…

• automaticka sprava vazev, 1:N, M:N

Já teď u sebe zapisuji vazby v kostce takhle:

/**
 * @property Tag[] $tags m:hasMany
 * @property Author|null $author m:hasOne
 * @property Author|null $maintainer m:hasOne(maintainer_id)
 * @property Something[] $somethings m:belongsToMany(book_id:something)
 */

Naimplementoval jsem si i trochu neobvyklé vazby belongsToMany a belongsToOne, přičemž v závorce se u všech vazeb dají vždy ještě upřesnit vazební sloupce a tabulky. No, zatím to obsáhlo vše, co jsem potřeboval. Super je, že u většiny entit se pak dá vše zapsat jen pomocí anotací.

K tomuhle už bohužel kód takhle snadno nepošlu, protože logika celého toho mapování je spletitější…

Určitě parsuj (jakýmkoliv způsobem) use statement, protože pak se ty anotace úžasně pročistí.

No, přeji příjemnou zábavu. :)

Editoval Tharos (28. 4. 2013 10:08)

ad use – jeste by bylo fajn ten tvuj porovnat (vykon :D) s tim, kterej tu kdysi nekdo odkazoval ze je v doctrine, nebo kde…

@Tharos ten pull prosím udělej :) Už dlouho si na to brousím zuby (klasicky není čas …) a když to máš už hotové, tak jedině dobře!

Jakým způsobem lze ORM „nejlépe“ injektovat?

	services:
		selectionFactory: Nextras\Orm\SelectionFactory
		bookDao: BookDao

…ale kam s tímhle? Nějaké

<?php
$selectionFactory->addMap('Author', 'author');
$selectionFactory->addMap('Book', 'book');
$selectionFactory->addMap('Tag', 'tag');
?>

Editoval thunderbuff (29. 4. 2013 0:25)

Ha! proto je lepší nepouštět se do ničeho po půlnoci!
@enumag: Díky za radu, mělo mě to napadnout :-)

Jen tak to zkoušim ;-) BTW: DAO je ošklivý výraz, repository (i když možná méně vystihuje podstatu věci) zní lépe :-P

Editoval thunderbuff (29. 4. 2013 0:54)

Až ti vyjde čas, mohl bys prosím integrovat instalaci composerem?

Prosim prosim, ber to jako jenom ukazku. Cele to chci naprosto kompletne predelat.
O tomto vim, schvalne jsem to odstranil (YetORM) to ma, protoze si myslim, ze by na takovouto akci mela byt metoda zvlast. Bohuzel je to hlavne kvuli hloupemu php chovani, kdy countable vyzaduje metodu count.
Ten nazev metody je spatny, protoze je pak $collection->count() nutne count nad vyfetchovanymi daty.

@Jack06: To má drobnou prerekvizitu, totiž zabudování Neon parseru do Nette reflexe, což se sice už dlouho chystá, ale ještě to nikdo neudělal. Aktuální parser není kompatibilní s formátem co Doctrine používá.

jansfabik napsal(a):
Napadlo mě, že by každý objekt mohl mít i vlastní třídu pro kolekci.

Můžeš uvést use-case, kdy bys ty vlastní metody u Collection potřeboval?

A pak mě ještě napadlo, že by entita mohla mapper mohl automaticky převádět camelCase na underscore_case (dalo by se to samozřejmě i vypnout pro zpětnou kompatibilitu). Je to divné mít někde $person->fullName a jinde zase $book->author_id, bylo by lepší to sjednotit.

Editoval jansfabik (3. 5. 2013 23:13)

Muj orm urcite nebude podporovat mapovani sloupcu na entite do databaze, respektive mapperu. to si ma prave resit mapper.

Vcera sem udelal Bc. ;) tot duvod. Jinak toto je mrtve, bude v brzke dobe uplna nahrada :)

Je to schválně, že nemůžu „nextras/orm“ najít na Packagistovi?
http://easycaptures.com/…61512140.jpg

Díky

@nanuqcz ano, toto byl jednodenni pokus :) napisu to na zacatek vlakna..

vytahnout data z kolekce

to neni uplne tak dofiltrovani kolekce, jako spis proste najit v db nejaky entity, pokud mas takovyto slozitejsi dotaz, nejlepsim resenim je to presunout na vrstvu mapperu – je to v poradku. tj.

PeopleRepository

/**
 * @method Nextras\Orm\Entity\ICollection|Person[] findByAge(int $age)
 */
class PeopleRepository extends Nextras\Orm\Repository\Repository
{}

PoepleMapper

class PeopleMapper exntends Nextras\Orm\Mapper\Mapper
{

	public function findByAge($age)
	{
		return $this->databaseContext->query('SELECT * FROM persons WHERE ...');
	}

}

je to na Mapper vrstve resene proto, ze pouzivas pro filtrovani vyrazy, ktere samozrejme maji neco spolecneho s sql, tj. repository vrstva o nich nema ani paru.

btw, shoudl work inflection Person → People, https://github.com/…/Inflect.php#L79