PHP code example of fyre / orm

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

fyre / orm example snippets

use Fyre\ORM\ModelRegistry;

$modelRegistry = new ModelRegistry($container);

$container->singleton(ModelRegistry::class);

$modelRegistry = $container->use(ModelRegistry::class);

$modelRegistry->addNamespace($namespace);

$model = $modelRegistry->build($classAlias);

$modelRegistry->clear();

$model = $modelRegistry->createDefaultModel();

$defaultModelClass = $modelRegistry->getDefaultModelClass();

$namespaces = $modelRegistry->getNamespaces();

$hasNamespace = $modelRegistry->hasNamespace($namespace);

$isLoaded = $modelRegistry->isLoaded($alias);

$modelRegistry->removeNamespace($namespace);

$modelRegistry->setDefaultModelClass($defaultModelClass);

$modelRegistry->unload($alias);

$model = $modelRegistry->use($alias, $classAlias);

$query = $model->deleteQuery($options);

$connection = $model->getConnection($type);

protected array $connectionKeys = [
    self::WRITE => 'default',
    self::READ => 'read_replica'
];

$query = $model->insertQuery();

$query = $model->replaceQuery();

$query = $model->selectQuery($options);

$model->setConnection($connection, $type);

$query = $model->subquery($options);

$query = $model->updateQuery($options);

$query = $model->updateBatchQuery($options);

$aliasField = $model->aliasField($field, $alias);

$alias = $model->getAlias();

$autoIncrementKey = $model->getAutoIncrementKey();

$classAlias = $model->getClassAlias();

$displayName = $model->getDisplayName();

protected string $displayName = 'display_name';

$primaryKeys = $model->getPrimaryKey();

$routeKey = $model->getRouteKey();

$tableSchema = $model->getSchema();

$table = $model->getTable();

protected string $table = 'my_table';

$model->setAlias($alias);

$model->setClassAlias($classAlias);

$model->setDisplayName($displayName);

$model->setTable($table);

$entityLocator->map($alias, $className);

$model->loadInto($entity, $contain);

$entity = $model->newEmptyEntity();

$entity = $model->newEntity($data, $options);

$entities = $model->newEntities($data, $options);

$model->patchEntity($entity, $data, $options);

$model->patchEntities($entities, $data, $options);

$result = $model->delete($entity, $options);

$affectedRows = $model->deleteAll($conditions);

$result = $model->deleteMany($entities, $options);

$exists = $model->exists($conditions);

$query = $model->find($data);

$entity = $model->get($primaryValues, $data);

$entity = $model->resolveRouteBinding($value, $field, $parent);

$result = $model->save($entity, $options);

$result = $model->saveMany($entities, $options);

$affectedRows = $model->updateAll($data, $conditions);

$model->addRelationship($relationship);

$relationship = $model->getRelationship($name);

$relationships = $model->getRelationships();

$hasRelationship = $model->hasRelationship($name);

$model->removeRelationship($name);

$model->addBehavior($name, $options);

$behavior = $model->getBehavior($name);

$hasBehavior = $model->hasBehavior($name);

$model->removeBehavior($name);

$rules = $model->getRules();

$validator = $model->getValidator();

$model->setRules($rules);

$model->setValidator($validator);

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterDelete(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterDeleteCommit(Event $event, Entity $entity, array $options) {}

use Fyre\ORM\Result;
use Fyre\Event\Event;

public function afterFind(Event $event, Result $result, array $options): Result {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterRules(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterParse(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterSave(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function afterSaveCommit(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function beforeDelete(Event $event, Entity $entity, array $options) {}

use Fyre\Event\Event;
use Fyre\ORM\Query;

public function beforeFind(Event $event, Query $query, array $options): Query {}

use ArrayObject;
use Fyre\Event\Event;

public function beforeParse(Event $event, ArrayObject $data, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function beforeRules(Event $event, Entity $entity, array $options) {}

use Fyre\Entity\Entity;
use Fyre\Event\Event;

public function beforeSave(Event $event, Entity $entity, array $options) {}

$model->initialize();

$model = $query->getModel();

$model->deleteQuery()
    ->where($conditions)
    ->execute();

$model->insertQuery()
    ->values($values)
    ->execute();

$model->replaceQuery()
    ->values($values)
    ->execute();

$model->selectQuery()
    ->select($fields)
    ->where($conditions)
    ->execute();

$results = $query->all();

$query->clearResult();

$query->contain($contain, $overwrite);

$count = $query->count();

$query->disableAutoFields();

$query->disableBuffering();

$query->enableAutoFields();

$query->enableBuffering();

$entity = $query->first();

$alias = $query->getAlias();

$connectionType = $query->getConnectionType();

php
$contain = $query->getContain();

php
$matching = $query->getMatching();

php
$result = $query->getResult();

php
$query->innerJoinWith($contain, $conditions);

php
$query->leftJoinWith($contain, $conditions);

php
$query->matching($contain, $conditions);

php
$query->notMatching($contain, $conditions);

php
$array = $query->toArray();

php
$model->updateQuery()
    ->set($values)
    ->where($conditions)
    ->execute();

php
$alias = $query->getAlias();

php
$model->updateBatchQuery()
    ->set($values, $keys)
    ->execute();

php
$alias = $query->getAlias();

php
$joins = $relationship->buildJoins($options);

php
$related = $relationship->findRelated($entities, $data);

php
$bindingKey = $relationship->getBindingKey();

php
$conditions = $relationship->getConditions();

php
$foreignKey = $relationship->getForeignKey();

php
$joinType = $relationship->getJoinType();

php
$name = $relationship->getName();

php
$propertyName = $relationship->getProperty();

php
$source = $relationship->getSource();

php
$strategy = $relationship->getStrategy();

php
$target = $relationship->getTarget();

php
$hasMultiple = $relationship->hasMultiple();

php
$isDependent = $relationship->isDependent();

php
$isOwningSide = $relationship->isOwningSide();

php
$relationship->loadRelated($entities, $data);

php
$result = $relationship->saveRelated($entity);

php
$relationship->setBindingKey($bindingKey);

php
$relationship->setConditions($conditions);

php
$relationship->setDependent($dependent);

php
$relationship->setForeignKey($foreignKey);

php
$relationship->setJoinType($joinType);

php
$relationship->setProperty($propertyName);

php
$relationship->setSource($source);

php
$relationship->setStrategy($strategy);

php
$relationship->setTarget($target);

php
$result = $relationship->unlinkAll($entities, $options);

php
$model->belongsTo($name, $data);

php
$model->hasMany($name, $data);

php
$saveStrategy = $relationship->getSaveStrategy();

php
$sort = $relationship->getSort();

php
$relationship->setSaveStrategy($saveStrategy);

php
$relationship->setSort($sort);

php
$model->hasOne($name, $data);

php
$model->manyToMany($name, $data);

php
$junction = $relationship->getJunction();

php
$saveStrategy = $relationship->getSaveStrategy();

php
$sort = $relationship->getSort();

php
$sourceRelationship = $relationship->getSourceRelationship();

php
$targetForeignKey = $relationship->getTargetForeignKey();

php
$targetRelationship = $relationship->getTargetRelationship();

php
$relationship->setJunction($junction);

php
$relationship->setSaveStrategy($saveStrategy);

php
$relationship->setSort($sort);

php
$relationship->setTargetForeignKey($targetForeignKey);

php
$behaviorRegistry = new BehaviorRegistry($container);

php
$container->singleton(BehaviorRegistry::class);

php
$behaviorRegistry = $container->use(BehaviorRegistry::class);

php
$behaviorRegistry->addNamespace($namespace);

php
$behavior = $behaviorRegistry->build($name, $model, $options);

php
$behaviorRegistry->clear();

php
$className = $behaviorRegistry->find($name);

php
$namespaces = $behaviorRegistry->getNamespaces();

php
$hasNamespace = $behaviorRegistry->hasNamespace($namespace);

php
$behaviorRegistry->removeNamespace($namespace);

php
$config = $behavior->getConfig();

php
$model = $behavior->getModel();

php
$model->addBehavior('Timestamp', $options);

php
$rules->add($rule);

php
$rules->existsIn($fields, $name, $options);

php
$rules->isClean($fields, $options);

php
$rules->isUnique($fields, $options);

php
$rules->validate($entity);