PHPackages fyre/orm - 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. fyre/orm ActiveLibrary[Database & ORM](/categories/database) fyre/orm ======== An ORM library. v13.0(7mo ago)3266↓77.8%16MITPHP Since Mar 15Pushed 7mo ago1 watchersCompare [ Source](https://github.com/elusivecodes/FyreORM)[ Packagist](https://packagist.org/packages/fyre/orm)[ RSS](/packages/fyre-orm/feed)WikiDiscussions main Synced 3w ago READMEChangelog (10)Dependencies (13)Versions (70)Used By (6) FyreORM ======= [](#fyreorm) **FyreORM** is a free, open-source database ORM for *PHP*. Table Of Contents ----------------- [](#table-of-contents) - [Installation](#installation) - [Basic Usage](#basic-usage) - [Methods](#methods) - [Models](#models) - [Schema](#schema) - [Entities](#entities) - [Query Methods](#query-methods) - [Relationship Methods](#relationship-methods) - [Behavior Methods](#behavior-methods) - [Validation](#validation) - [Callbacks](#callbacks) - [Queries](#queries) - [Delete](#delete) - [Insert](#insert) - [Replace](#replace) - [Select](#select) - [Update](#update) - [Update Batch](#update-batch) - [Results](#results) - [Relationships](#relationships) - [Belongs To](#belongs-to) - [Has Many](#has-many) - [Has One](#has-one) - [Many To Many](#many-to-many) - [Behavior Registry](#behavior-registry) - [Behaviors](#behaviors) - [Soft Delete](#soft-delete) - [Timestamp](#timestamp) - [RuleSets](#rulesets) - [Rules](#rules) Installation ------------ [](#installation) **Using Composer** ``` composer require fyre/orm ``` In PHP: ``` use Fyre\ORM\ModelRegistry; ``` Basic Usage ----------- [](#basic-usage) - `$container` is a [*Container*](https://github.com/elusivecodes/FyreContainer). ``` $modelRegistry = new ModelRegistry($container); ``` **Autoloading** It is recommended to bind the *ModelRegistry* to the [*Container*](https://github.com/elusivecodes/FyreContainer) as a singleton. ``` $container->singleton(ModelRegistry::class); ``` Any dependencies will be injected automatically when loading from the [*Container*](https://github.com/elusivecodes/FyreContainer). ``` $modelRegistry = $container->use(ModelRegistry::class); ``` Methods ------- [](#methods) **Add Namespace** Add a namespace for loading models. - `$namespace` is a string representing the namespace. ``` $modelRegistry->addNamespace($namespace); ``` **Build** Build a [*Model*](#models). - `$classAlias` is a string representing the model class alias. ``` $model = $modelRegistry->build($classAlias); ``` [*Model*](#models) dependencies will be resolved automatically from the [*Container*](https://github.com/elusivecodes/FyreContainer). **Clear** Clear all namespaces and models. ``` $modelRegistry->clear(); ``` **Create Default Model** Create a default [*Model*](#models). ``` $model = $modelRegistry->createDefaultModel(); ``` [*Model*](#models) dependencies will be resolved automatically from the [*Container*](https://github.com/elusivecodes/FyreContainer). **Get Default Model Class** Get the default model class name. ``` $defaultModelClass = $modelRegistry->getDefaultModelClass(); ``` **Get Namespaces** Get the namespaces. ``` $namespaces = $modelRegistry->getNamespaces(); ``` **Has Namespace** Determine whether a namespace exists. - `$namespace` is a string representing the namespace. ``` $hasNamespace = $modelRegistry->hasNamespace($namespace); ``` **Is Loaded** Determine whether a model is loaded. - `$alias` is a string representing the model alias. ``` $isLoaded = $modelRegistry->isLoaded($alias); ``` **Remove Namespace** Remove a namespace. - `$namespace` is a string representing the namespace. ``` $modelRegistry->removeNamespace($namespace); ``` **Set Default Model Class** Set the default model class name. - `$defaultModelClass` is a string representing the default model class name. ``` $modelRegistry->setDefaultModelClass($defaultModelClass); ``` **Unload** Unload a model. - `$alias` is a string representing the model alias. ``` $modelRegistry->unload($alias); ``` **Use** Load a shared [*Model*](#models) instance. - `$alias` is a string representing the model alias. - `$classAlias` is a string representing the model class alias, and will default to the model alias. ``` $model = $modelRegistry->use($alias, $classAlias); ``` [*Model*](#models) dependencies will be resolved automatically from the [*Container*](https://github.com/elusivecodes/FyreContainer). Models ------ [](#models) Custom models can be created by extending the `\Fyre\ORM\Model` class, suffixing the class name with "*Model*". To allow autoloading an instance of your model, add the the namespace to the *ModelRegistry*. **Delete Query** Create a new [*DeleteQuery*](#delete). - `$options` is an array containing options for the query. - `alias` is a string representing the table alias, and will default to the model alias. ``` $query = $model->deleteQuery($options); ``` **Get Connection** Get the [*Connection*](https://github.com/elusivecodes/FyreDB#connections). - `$type` is a string representing the connection type, and will default to `self::WRITE`. ``` $connection = $model->getConnection($type); ``` Models use [*ConnectionManager*](https://github.com/elusivecodes/FyreDB) for database connections, and you can specify the connection to use by setting the `connectionKeys` property of your models, or using the `setConnection` method. ``` protected array $connectionKeys = [ self::WRITE => 'default', self::READ => 'read_replica' ]; ``` If the `self::READ` key is omitted, it will fallback to the `self::WRITE` connection for database reads. **Insert Query** Create a new [*InsertQuery*](#insert). ``` $query = $model->insertQuery(); ``` **Replace Query** Create a new [*ReplaceQuery*](#replace). ``` $query = $model->replaceQuery(); ``` **Select Query** Create a new [*SelectQuery*](#select). - `$options` is an array containing options for the query. - `alias` is a string representing the table alias, and will default to the model alias. - `connectionType` is a string representing the connection type, and will default to `self::READ`. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. ``` $query = $model->selectQuery($options); ``` **Set Connection** Set the [*Connection*](https://github.com/elusivecodes/FyreDB#connections). - `$connection` is a [*Connection*](https://github.com/elusivecodes/FyreDB#connections). - `$type` is a string representing the connection type, and will default to `self::WRITE`. ``` $model->setConnection($connection, $type); ``` **Subquery** Create a new subquery [*SelectQuery*](#select). - `$options` is an array of named parameters containing options for the query. - `alias` is a string representing the table alias, and will default to the model alias. - `connectionType` is a string representing the connection type, and will default to `self::READ`. ``` $query = $model->subquery(...$options); ``` **Update Query** Create a new [*UpdateQuery*](#update). - `$options` is an array containing options for the query. - `alias` is a string representing the table alias, and will default to the model alias. ``` $query = $model->updateQuery($options); ``` **Update Batch Query** Create a new [*UpdateBatchQuery*](#update-batch). - `$options` is an array containing options for the query. - `alias` is a string representing the table alias, and will default to the model alias. ``` $query = $model->updateBatchQuery($options); ``` ### Schema [](#schema) **Alias Field** Alias a field name. - `$field` is a string representing the field name. - `$alias` is a string representing the alias, and will default to the model alias. ``` $aliasField = $model->aliasField($field, $alias); ``` **Get Alias** Get the model alias. ``` $alias = $model->getAlias(); ``` By default, the alias will be the class alias. **Get Auto Increment Key** Get the table auto increment column. ``` $autoIncrementKey = $model->getAutoIncrementKey(); ``` **Get Class Alias** Get the model class alias. ``` $classAlias = $model->getClassAlias(); ``` By default, the alias will be the class name or the alias used when loading the model with *ModelRegistry*. **Get Display Name** Get the display name. ``` $displayName = $model->getDisplayName(); ``` By default, the display name will be the first column in the schema with the name of either *"name"*, *"title"* or *"label"*, or you can specify a column using the `displayName` property in your models. ``` protected string $displayName = 'display_name'; ``` **Get Primary Key** Get the primary key(s). ``` $primaryKeys = $model->getPrimaryKey(); ``` **Get Route Key** Get the route key. ``` $routeKey = $model->getRouteKey(); ``` **Get Schema** Get the schema [*Table*](https://github.com/elusivecodes/FyreSchema#tables). ``` $table = $model->getSchema(); ``` **Get Table** Get the table name. ``` $table = $model->getTable(); ``` By default, the table name will be the snake case form of the model class alias, or you can specify a table name using the `table` property in your models. ``` protected string $table = 'my_table'; ``` **Set Alias** Set the model alias. - `$alias` is a string representing the model alias. ``` $model->setAlias($alias); ``` **Set Class Alias** Set the model class alias. - `$classAlias` is a string representing the model class alias. ``` $model->setClassAlias($classAlias); ``` **Set Display Name** Set the display name. - `$displayName` is a string representing the display name. ``` $model->setDisplayName($displayName); ``` **Set Table** Set the table name. - `$table` is a string representing the table name. ``` $model->setTable($table); ``` ### Entities [](#entities) Models will use the [*EntityLocator*](https://github.com/elusivecodes/FyreEntity#entity-locator) to find an entity class using the model class alias. You can map a model alias to a specific entity class using the [*EntityLocator*](https://github.com/elusivecodes/FyreEntity#entity-locator). ``` $entityLocator->map($alias, $className); ``` **Load Into** Load contained data into entity. - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$contain` is an array containing the relationships to contain. ``` $model->loadInto($entity, $contain); ``` **New Empty Entity** Build a new empty [*Entity*](https://github.com/elusivecodes/FyreEntity). ``` $entity = $model->newEmptyEntity(); ``` **New Entity** Build a new [*Entity*](https://github.com/elusivecodes/FyreEntity) using data. - `$data` is an array containing the data. - `$options` is an array of named parameters containing entity options. - `associated` is an array containing the relationships to parse, and will default to *null*. - `accessible` is an array containing accessible fields, and will default to *null*. - `guard` is a boolean indicating whether to check whether the field is accessible, and will default to *true*. - `mutate` is a boolean indicating whether to mutate the value, and will default to *true*. - `parse` is a boolean indicating whether to parse user data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `validate` is a boolean indicating whether to validate user data, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity, and will default to *false*. - `new` is a boolean indicating whether to mark the entity as new, and will default to *null*. ``` $entity = $model->newEntity($data, ...$options); ``` **New Entities** Build multiple new entities using user data. - `$data` is an array containing the data. - `$options` is an array of named parameters containing entity options. - `associated` is an array containing the relationships to parse, and will default to *null*. - `accessible` is an array containing accessible fields, and will default to *null*. - `guard` is a boolean indicating whether to check whether the field is accessible, and will default to *true*. - `mutate` is a boolean indicating whether to mutate the value, and will default to *true*. - `parse` is a boolean indicating whether to parse user data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `validate` is a boolean indicating whether to validate user data, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity, and will default to *false*. - `new` is a boolean indicating whether to mark the entity as new, and will default to *null*. ``` $entities = $model->newEntities($data, ...$options); ``` **Patch Entity** Update an Entity using user data. - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$data` is an array containing the data. - `$options` is an array of named parameters containing entity options. - `associated` is an array containing the relationships to parse, and will default to *null*. - `accessible` is an array containing accessible fields, and will default to *null*. - `guard` is a boolean indicating whether to check whether the field is accessible, and will default to *true*. - `mutate` is a boolean indicating whether to mutate the value, and will default to *true*. - `parse` is a boolean indicating whether to parse user data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `validate` is a boolean indicating whether to validate user data, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity, and will default to *false*. - `new` is a boolean indicating whether to mark the entity as new, and will default to *null*. ``` $model->patchEntity($entity, $data, ...$options); ``` **Patch Entities** Update multiple entities using user data. - `$entities` is an array or *Traversable* containing the entities. - `$data` is an array containing the data. - `$options` is an array of named parameters containing entity options. - `associated` is an array containing the relationships to parse, and will default to *null*. - `accessible` is an array containing accessible fields, and will default to *null*. - `guard` is a boolean indicating whether to check whether the field is accessible, and will default to *true*. - `mutate` is a boolean indicating whether to mutate the value, and will default to *true*. - `parse` is a boolean indicating whether to parse user data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `validate` is a boolean indicating whether to validate user data, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity, and will default to *false*. - `new` is a boolean indicating whether to mark the entity as new, and will default to *null*. ``` $model->patchEntities($entities, $data, ...$options); ``` ### Query Methods [](#query-methods) **Delete** Delete an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$options` is an array of named parameters containing delete options. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `cascade` is a boolean indicating whether to cascade deletes, and will default to *true*. ``` $result = $model->delete($entity, ...$options); ``` **Delete All** Delete all rows matching conditions. - `$conditions` is an array or string representing the where conditions. ``` $affectedRows = $model->deleteAll($conditions); ``` This method will not use callbacks or cascade to related data. **Delete Many** Delete multiple entities. - `$entities` is an array or *Traversable* containing the entities. - `$options` is an array of named parameters containing delete options. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `cascade` is a boolean indicating whether to cascade deletes, and will default to *true*. ``` $result = $model->deleteMany($entities, ...$options); ``` **Exists** Determine whether matching rows exist. - `$conditions` is an array or string representing the where conditions. ``` $exists = $model->exists($conditions); ``` **Find** Create a new [*SelectQuery*](#select). - `$data` is an array of named parameters containing the query data. - `connectionType` is a string representing the connection type, and will default to `self::READ`. - `fields` is an array or string representing the fields to select. - `contain` is a string or array containing the relationships to contain. - `join` is an array containing the tables to join. - `conditions` is an array or string representing the where conditions. - `orderBy` is an array or string representing the fields to order by. - `groupBy` is an array or string representing the fields to group by. - `having` is an array or string representing the having conditions. - `limit` is a number indicating the query limit. - `offset` is a number indicating the query offset. - `epilog` is a string representing the epilog for the query. - `autoFields` is a boolean indicating whether to enable auto fields. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. ``` $query = $model->find(...$data); ``` **Get** Retrieve a single entity. - `$primaryValues` is a string, integer or array containing the primary key value(s). - `$data` is an array of named parameters containing the query data. - `connectionType` is a string representing the connection type, and will default to `self::READ`. - `fields` is an array or string representing the fields to select. - `contain` is a string or array containing the relationships to contain. - `join` is an array containing the tables to join. - `epilog` is a string representing the epilog for the query. - `autoFields` is a boolean indicating whether to enable auto fields. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. ``` $entity = $model->get($primaryValues, ...$data); ``` **Resolve Route Binding** Resolve an entity from a route. - `$value` is a string or integer containing the route key value. - `$field` is a string representing the route key. - `$parent` is an [*Entity*](https://github.com/elusivecodes/FyreEntity) representing the parent entity, and will default to *null*. ``` $entity = $model->resolveRouteBinding($value, $field, $parent); ``` **Save** Save an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$options` is an array of named parameters containing save options. - `checkExists` is a boolean indicating whether to check if new entities exist, and will default to *true*. - `checkRules` is a boolean indicating whether to validate the [*RuleSet*](#rulesets), and will default to *true*. - `saveRelated` is a boolean indicating whether to save related data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity after saving, and will default to *true*. ``` $result = $model->save($entity, ...$options); ``` **Save Many** Save multiple entities. - `$entities` is an array or *Traversable* containing the entities. - `$options` is an array of named parameters containing save options. - `checkExists` is a boolean indicating whether to check if new entities exist, and will default to *true*. - `checkRules` is a boolean indicating whether to validate the [*RuleSet*](#rulesets), and will default to *true*. - `saveRelated` is a boolean indicating whether to save related data, and will default to *true*. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `clean` is a boolean indicating whether to clean the entity after saving, and will default to *true*. ``` $result = $model->saveMany($entities, ...$options); ``` **Update All** Update all rows matching conditions. - `$data` is an array of values to update. - `$conditions` is an array or string representing the where conditions. ``` $affectedRows = $model->updateAll($data, $conditions); ``` This method will not use callbacks. ### Relationship Methods [](#relationship-methods) **Add Relationship** Add a [*Relationship*](#relationships). - `$relationship` is a [*Relationship*](#relationships). ``` $model->addRelationship($relationship); ``` **Get Relationship** Get a [*Relationship*](#relationships). - `$name` is a string representing the relationship name. ``` $relationship = $model->getRelationship($name); ``` **Get Relationships** Get all relationships. ``` $relationships = $model->getRelationships(); ``` **Has Relationship** Determine whether a [*Relationship*](#relationships) exists. - `$name` is a string representing the relationship name. ``` $hasRelationship = $model->hasRelationship($name); ``` **Remove Relationship** Remove an existing [*Relationship*](#relationships). - `$name` is a string representing the relationship name. ``` $model->removeRelationship($name); ``` ### Behavior Methods [](#behavior-methods) **Add Behavior** Add a [*Behavior*](#behaviors) to the *Model*. - `$name` is a string representing the behavior name. - `$options` is an array containing behavior options. ``` $model->addBehavior($name, $options); ``` **Get Behavior** Get a loaded [*Behavior*](#behaviors). - `$name` is a string representing the behavior name. ``` $behavior = $model->getBehavior($name); ``` **Has Behavior** Determine whether the *Model* has a [*Behavior*](#behaviors). - `$name` is a string representing the behavior name. ``` $hasBehavior = $model->hasBehavior($name); ``` **Remove Behavior** Remove a [*Behavior*](#behaviors) from the *Model*. - `$name` is a string representing the behavior name. ``` $model->removeBehavior($name); ``` ### Validation [](#validation) **Get Rules** Get the model [*RuleSet*](#rulesets). ``` $rules = $model->getRules(); ``` You can build custom rules by specifying a `buildRules` method in your models. **Get Validator** Get the model [*Validator*](https://github.com/elusivecodes/FyreValidation). ``` $validator = $model->getValidator(); ``` You can build a custom validator by specifying a `buildValidation` method in your models. **Set Rules** Set the model [*RuleSet*](#rulesets). - `$rules` is a [*RuleSet*](#rulesets). ``` $model->setRules($rules); ``` **Set Validator** Set the model [*Validator*](https://github.com/elusivecodes/FyreValidation). - `$validator` is a [*Validator*](https://github.com/elusivecodes/FyreValidation). ``` $model->setValidator($validator); ``` ### Callbacks [](#callbacks) Callbacks can be defined in your models, allowing custom code to run or revert changes at various points during model operations. **After Delete** Execute a callback after entities are deleted. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterDelete(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the delete will not be performed and the transaction will be rolled back. **After Delete Commit** Execute a callback after entities are deleted and transaction is committed. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterDeleteCommit(Event $event, Entity $entity, array $options) {} ``` **After Find** Execute a callback after performing a find query. ``` use Fyre\ORM\Result; use Fyre\Event\Event; public function afterFind(Event $event, Result $result, array $options): Result {} ``` **After Rules** Execute a callback after model rules are processed. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterRules(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the save will not be performed. **After Parse** Execute a callback after parsing user data into an entity. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterParse(Event $event, Entity $entity, array $options) {} ``` **After Save** Execute a callback after entities are saved to the database. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterSave(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the save will not be performed and the transaction will be rolled back. **After Save Commit** Execute a callback after entities are saved to the database and transaction is committed. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function afterSaveCommit(Event $event, Entity $entity, array $options) {} ``` **Before Delete** Execute a callback before entities are deleted. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function beforeDelete(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the delete will not be performed. **Before Find** Execute a callback before performing a find query. ``` use Fyre\Event\Event; use Fyre\ORM\Query; public function beforeFind(Event $event, Query $query, array $options): Query {} ``` **Before Parse** Execute a callback before parsing user data into an entity. ``` use ArrayObject; use Fyre\Event\Event; public function beforeParse(Event $event, ArrayObject $data, array $options) {} ``` **Before Rules** Before rules callback. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function beforeRules(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the save will not be performed. **Before Save** Execute a callback before entities are saved to the database. ``` use Fyre\Entity\Entity; use Fyre\Event\Event; public function beforeSave(Event $event, Entity $entity, array $options) {} ``` If the `$event` is stopped, the save will not be performed and the transaction will be rolled back. **Initialize** Initialize the model. ``` $model->initialize(); ``` This method is called automatically when the model is loaded. You can define this method on your custom models to attach [*relationships*](#relationships) or [*behaviors*](#behaviors). Queries ------- [](#queries) **Get Model** Get the [*Model*](#models). ``` $model = $query->getModel(); ``` ### Delete [](#delete) The `\Fyre\ORM\Queries\DeleteQuery` class extends the [*DeleteQuery*](https://github.com/elusivecodes/FyreDB#delete) class. The table and alias will be automatically set from the *Model*. ``` $model->deleteQuery() ->where($conditions) ->execute(); ``` ### Insert [](#insert) The `\Fyre\ORM\Queries\InsertQuery` class extends the [*InsertQuery*](https://github.com/elusivecodes/FyreDB#insert) class. The table will be automatically set from the *Model*. ``` $model->insertQuery() ->values($values) ->execute(); ``` ### Replace [](#replace) The `\Fyre\ORM\Queries\ReplaceQuery` class extends the [*ReplaceQuery*](https://github.com/elusivecodes/FyreDB#replace) class. The table will be automatically set from the *Model*. ``` $model->replaceQuery() ->values($values) ->execute(); ``` ### Select [](#select) The `\Fyre\ORM\Queries\SelectQuery` class extends the [*SelectQuery*](https://github.com/elusivecodes/FyreDB#select) class, while providing several additional methods and wrappers for relationship and entity mapping. The table and alias will be automatically set from the *Model*, and field names will be automatically aliased. ``` $model->selectQuery() ->select($fields) ->where($conditions) ->execute(); ``` **All** Get the [*Result*](#results). ``` $results = $query->all(); ``` **Clear Result** Clear the buffered result. ``` $query->clearResult(); ``` **Contain** Set the contain relationships. - `$contain` is a string or array containing the relationships to contain. - `$overwrite` is a boolean indicating whether to overwrite existing contains, and will default to *false*. ``` $query->contain($contain, $overwrite); ``` **Count** Get the result count. ``` $count = $query->count(); ``` **Disable Auto Fields** Disable auto fields. ``` $query->disableAutoFields(); ``` **Disable Buffering** Disable result buffering. ``` $query->disableBuffering(); ``` **Enable Auto Fields** Enable auto fields. ``` $query->enableAutoFields(); ``` **Enable Buffering** Enable result buffering. ``` $query->enableBuffering(); ``` **First** Get the first result. ``` $entity = $query->first(); ``` **Get Alias** Get the alias. ``` $alias = $query->getAlias(); ``` **Get Connection Type** Get the connection type. ``` $connectionType = $query->getConnectionType(); ``` **Get Contain** Get the contain array. ``` $contain = $query->getContain(); ``` **Get Matching** Get the matching array. ``` $matching = $query->getMatching(); ``` **Get Result** Get the [*Result*](#results). ``` $result = $query->getResult(); ``` **Inner Join With** INNER JOIN a relationship table. - `$contain` is a string representing the relationships to contain. - `$conditions` is an array containing additional join conditions. ``` $query->innerJoinWith($contain, $conditions); ``` **Left Join With** LEFT JOIN a relationship table. - `$contain` is a string representing the relationships to contain. - `$conditions` is an array containing additional join conditions. ``` $query->leftJoinWith($contain, $conditions); ``` **Matching** INNER JOIN a relationship table and load matching data. - `$contain` is a string representing the relationships to contain. - `$conditions` is an array containing additional join conditions. ``` $query->matching($contain, $conditions); ``` The matching data will be accessible via the `_matchingData` property. **Not Matching** LEFT JOIN a relationship table and exclude matching rows. - `$contain` is a string representing the relationships to contain. - `$conditions` is an array containing additional join conditions. ``` $query->notMatching($contain, $conditions); ``` **To Array** Get the results as an array. ``` $array = $query->toArray(); ``` ### Update [](#update) The `\Fyre\ORM\Queries\UpdateQuery` class extends the [*UpdateQuery*](https://github.com/elusivecodes/FyreDB#update) class. The table will be automatically set from the *Model*. ``` $model->updateQuery() ->set($values) ->where($conditions) ->execute(); ``` **Get Alias** Get the alias. ``` $alias = $query->getAlias(); ``` ### Update Batch [](#update-batch) The `\Fyre\ORM\Queries\UpdateBatchQuery` class extends the [*UpdateBatchQuery*](https://github.com/elusivecodes/FyreDB#update-batch) class. The table and alias will be automatically set from the *Model*, and field names will be automatically aliased. ``` $model->updateBatchQuery() ->set($values, $keys) ->execute(); ``` **Get Alias** Get the alias. ``` $alias = $query->getAlias(); ``` Results ------- [](#results) The `\Fyre\ORM\Result` class wraps the [*ResultSet*](https://github.com/elusivecodes/FyreDB#results) class, and acts as a proxy for the [*Collection*](https://github.com/elusivecodes/FyreCollection) class, providing additional handling for entity mapping and eager loading contained results. Relationships ------------- [](#relationships) Relationships can be accessed directly as a property on the model, using the relationship name. Target model methods and properties can also be accessed directly from the relationship. **Build Joins** Build join data. - `$options` is an array containing the join options, and will default to *\[\]*. ``` $joins = $relationship->buildJoins($options); ``` **Find Related** Find related data for entities. - `$entities` is an array or *Traversable* containing the entities. - `$data` is an array of named parameters containing the query data. ``` $related = $relationship->findRelated($entities, ...$data); ``` **Get Binding Key** Get the binding key. ``` $bindingKey = $relationship->getBindingKey(); ``` **Get Conditions** Get the conditions. ``` $conditions = $relationship->getConditions(); ``` **Get Foreign Key** Get the foreign key. ``` $foreignKey = $relationship->getForeignKey(); ``` **Get Join Type** Get the join type. ``` $joinType = $relationship->getJoinType(); ``` **Get Name** Get the relationship name. ``` $name = $relationship->getName(); ``` **Get Property** Get the relationship property name. ``` $propertyName = $relationship->getProperty(); ``` **Get Source** Get the source [*Model*](#models). ``` $source = $relationship->getSource(); ``` **Get Strategy** Get the select strategy. ``` $strategy = $relationship->getStrategy(); ``` **Get Target** Get the target [*Model*](#models). ``` $target = $relationship->getTarget(); ``` **Has Multiple** Determine whether the relationship has multiple related items. ``` $hasMultiple = $relationship->hasMultiple(); ``` **Is Dependent** Determine whether the target is dependent. ``` $isDependent = $relationship->isDependent(); ``` **Is Owning Side** Determine whether the source is the owning side of the relationship. ``` $isOwningSide = $relationship->isOwningSide(); ``` **Load Related** Load related data for entities. - `$entities` is an array or *Traversable* containing the entities. - `$query` is a [*SelectQuery*](#select) (that produced the entities), and will default to *null*. - `$data` is an array of named parameters containing the query data. ``` $relationship->loadRelated($entities, $query, ...$data); ``` **Save Related** Save related data for an entity. - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$options` is an array of named parameters containing save options. ``` $result = $relationship->saveRelated($entity, ...$options); ``` **Set Binding Key** Set the binding key. - `$bindingKey` is a string representing the binding key. ``` $relationship->setBindingKey($bindingKey); ``` **Set Conditions** Set the conditions. - `$conditions` is an array containing additional conditions. ``` $relationship->setConditions($conditions); ``` **Set Dependent** Set whether the target is dependent. - `$dependent` is a boolean indicating whether to recursively delete related data. ``` $relationship->setDependent($dependent); ``` **Set Foreign Key** Set the foreign key. - `$foreignKey` is a string representing the foreign key key. ``` $relationship->setForeignKey($foreignKey); ``` **Set Join Type** Set the join type. - `$joinType` is a string representing the type of join. ``` $relationship->setJoinType($joinType); ``` **Set Property** Set the property name. - `$propertyName` is a string representing the entity property name. ``` $relationship->setProperty($propertyName); ``` **Set Source** Set the source [*Model*](#models). - `$source` is a [*Model*](#models). ``` $relationship->setSource($source); ``` **Set Strategy** Set the select strategy. - `$strategy` is a string representing the select strategy. ``` $relationship->setStrategy($strategy); ``` **Set Target** Set the target [*Model*](#models). - `$target` is a [*Model*](#models). ``` $relationship->setTarget($target); ``` **Unlink All** Remove related data from entities. - `$entities` is an array or *Traversable* containing the entities. - `$options` is an of named parameters array containing delete options. ``` $result = $relationship->unlinkAll($entities, ...$options); ``` ### Belongs To [](#belongs-to) - `$name` is a string representing the relationship name. - `$data` is an array containing relationship data. - `classAlias` is a string representing the target class alias, and will default to the relationship name. - `propertyName` is a string representing the entity property name, and will default to the snake case form of the singular relationship name. - `foreignKey` is a string representing the foreign key column in the current table, and will default to the snake case singular name of the target alias (suffixed with *"\_id"*). - `bindingKey` is a string representing the matching column in the target table, and will default to the primary key. - `strategy` must be either "*join*" or "*select*", and will default to "*join*". - `conditions` is an array containing additional conditions. - `joinType` is a string representing the type of join, and will default to "*LEFT*". ``` $model->belongsTo($name, $data); ``` ### Has Many [](#has-many) - `$name` is a string representing the relationship name. - `$data` is an array containing relationship data. - `classAlias` is a string representing the target class alias, and will default to the relationship name. - `propertyName` is a string representing the entity property name, and will default to the snake case form of the relationship name. - `foreignKey` is a string representing the foreign key column in the target table, and will default to the snake case singular name of the current alias (suffixed with *"\_id"*). - `bindingKey` is a string representing the matching column in the current table, and will default to the primary key. - `strategy` must be either "*select*" or "*subquery*", and will default to "*select*". - `saveStrategy` must be either "*append*" or "*replace*", and will default to "*append*". - `conditions` is an array containing additional conditions. - `sort` is an array or string representing the fields to order by, and will default to *null*. - `dependent` is a boolean indicating whether to recursively delete related data, and will default to *false*. ``` $model->hasMany($name, $data); ``` **Get Save Strategy** Get the save strategy. ``` $saveStrategy = $relationship->getSaveStrategy(); ``` **Get Sort** Get the sort order. ``` $sort = $relationship->getSort(); ``` **Set Save Strategy** Set the save strategy. - `$saveStrategy` is a string representing the save strategy. ``` $relationship->setSaveStrategy($saveStrategy); ``` **Set Sort** Set the sort order. - `$sort` is an array or string representing the fields to order by. ``` $relationship->setSort($sort); ``` ### Has One [](#has-one) - `$name` is a string representing the relationship name. - `$data` is an array containing relationship data. - `classAlias` is a string representing the target class alias, and will default to the relationship name. - `propertyName` is a string representing the entity property name, and will default to the snake case form of the singular relationship name. - `foreignKey` is a string representing the foreign key column in the target table, and will default to the snake case singular name of the current alias (suffixed with *"\_id"*). - `bindingKey` is a string representing the matching column in the current table, and will default to the primary key. - `strategy` must be either "*join*" or "*select*", and will default to "*join*". - `conditions` is an array containing additional conditions. - `joinType` is a string representing the type of join, and will default to "*LEFT*". - `dependent` is a boolean indicating whether to recursively delete related data, and will default to *false*. ``` $model->hasOne($name, $data); ``` ### Many To Many [](#many-to-many) When loading results, the join table data will be accessible via the `_joinData` property. - `$name` is a string representing the relationship name. - `$data` is an array containing relationship data. - `classAlias` is a string representing the target class alias, and will default to the relationship name. - `through` is a string representing the join alias, and will default to the concatenated form of the current alias and relationship name (sorted alphabetically). - `propertyName` is a string representing the entity property name, and will default to the snake case form of the relationship name. - `foreignKey` is a string representing the foreign key column in the join table, and will default to the snake case singular name of the current alias (suffixed with *"\_id"*). - `targetForeignKey` is a string representing the target foreign key column in the join table, and will default to the snake case singular name of the relationship name (suffixed with *"\_id"*). - `bindingKey` is a string representing the matching column in the current table, and will default to the primary key. - `strategy` must be either "*select*" or "*subquery*", and will default to "*select*". - `saveStrategy` must be either "*append*" or "*replace*", and will default to "*replace*". - `sort` is an array or string representing the fields to order by, and will default to *null*. - `conditions` is an array containing additional conditions. ``` $model->manyToMany($name, $data); ``` **Get Junction** Get the junction [*Model*](#models). ``` $junction = $relationship->getJunction(); ``` **Get Save Strategy** Get the save strategy. ``` $saveStrategy = $relationship->getSaveStrategy(); ``` **Get Sort** Get the sort order. ``` $sort = $relationship->getSort(); ``` **Get Source Relationship** Get the source relationship. ``` $sourceRelationship = $relationship->getSourceRelationship(); ``` **Get Target Foreign Key** Get the target foreign key. ``` $targetForeignKey = $relationship->getTargetForeignKey(); ``` **Get Target Relationship** Get the target relationship. ``` $targetRelationship = $relationship->getTargetRelationship(); ``` **Set Junction** Set the junction [*Model*](#models). - `$junction` is a [*Model*](#models). ``` $relationship->setJunction($junction); ``` **Set Save Strategy** Set the save strategy. - `$saveStrategy` is a string representing the save strategy. ``` $relationship->setSaveStrategy($saveStrategy); ``` **Set Sort** Set the sort order. - `$sort` is an array or string representing the fields to order by. ``` $relationship->setSort($sort); ``` **Set Target Foreign Key** Set the target foreign key. - `$targetForeignKey` is a string representing the target foreign key column in the join table. ``` $relationship->setTargetForeignKey($targetForeignKey); ``` Behavior Registry ----------------- [](#behavior-registry) ``` use Fyre\ORM\BehaviorRegistry; ``` - `$container` is a [*Container*](https://github.com/elusivecodes/FyreContainer). ``` $behaviorRegistry = new BehaviorRegistry($container); ``` **Autoloading** It is recommended to bind the *BehaviorRegistry* to the [*Container*](https://github.com/elusivecodes/FyreContainer) as a singleton. ``` $container->singleton(BehaviorRegistry::class); ``` Any dependencies will be injected automatically when loading from the [*Container*](https://github.com/elusivecodes/FyreContainer). ``` $behaviorRegistry = $container->use(BehaviorRegistry::class); ``` ### Behavior Registry Methods [](#behavior-registry-methods) **Add Namespace** Add a namespace for automatically loading behaviors. - `$namespace` is a string representing the namespace. ``` $behaviorRegistry->addNamespace($namespace); ``` **Build** Build a behavior. - `$name` is a string representing the behavior name. - `$model` is a [*Model*](#models). - `$options` is an array containing the behavior options, and will default to *\[\]*. ``` $behavior = $behaviorRegistry->build($name, $model, $options); ``` **Clear** Clear all namespaces and behaviors. ``` $behaviorRegistry->clear(); ``` **Find** Find a behavior class. - `$name` is a string representing the behavior name. ``` $className = $behaviorRegistry->find($name); ``` **Get Namespaces** Get the namespaces. ``` $namespaces = $behaviorRegistry->getNamespaces(); ``` **Has Namespace** Determine whether a namespace exists. - `$namespace` is a string representing the namespace. ``` $hasNamespace = $behaviorRegistry->hasNamespace($namespace); ``` **Remove Namespace** Remove a namespace. - `$namespace` is a string representing the namespace. ``` $behaviorRegistry->removeNamespace($namespace); ``` Behaviors --------- [](#behaviors) Behaviors must be attached to a [*Model*](#models) using the `addBehavior` method. Behavior methods can then be called directly on the model. Custom behaviors can be created by extending `\Fyre\ORM\Behavior`, suffixing the class name with "*Behavior*", and ensuring the `__construct` method accepts [*Model*](#models) as the argument (and optionally an `$options` array as the second parameter). Behaviors can also include [callbacks](#callbacks) that will be executed during model operations. **Get Config** Get the configuration options. ``` $config = $behavior->getConfig(); ``` **Get Model** Get the [*Model*](#models). ``` $model = $behavior->getModel(); ``` ### Soft Delete [](#soft-delete) - `$options` is an array containing behavior options. - `field` is a string representing the deleted field name, and will default to "*deleted*". ``` $model->addBehavior('SoftDelete', $options); ``` **Find Only Deleted** Find only soft deleted records. - `$data` is an array of named parameters containing the query data. - `connectionType` is a string representing the connection type, and will default to `self::READ`. - `fields` is an array or string representing the fields to select. - `contain` is a string or array containing the relationships to contain. - `join` is an array containing the tables to join. - `conditions` is an array or string representing the where conditions. - `orderBy` is an array or string representing the fields to order by. - `groupBy` is an array or string representing the fields to group by. - `having` is an array or string representing the having conditions. - `limit` is a number indicating the query limit. - `offset` is a number indicating the query offset. - `epilog` is a string representing the epilog for the query. - `autoFields` is a boolean indicating whether to enable auto fields. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. ``` $query = $model->findOnlyDeleted(...$data); ``` **Find With Deleted** Find all records including soft deleted. - `$data` is an array of named parameters containing the query data. - `connectionType` is a string representing the connection type, and will default to `self::READ`. - `fields` is an array or string representing the fields to select. - `contain` is a string or array containing the relationships to contain. - `join` is an array containing the tables to join. - `conditions` is an array or string representing the where conditions. - `orderBy` is an array or string representing the fields to order by. - `groupBy` is an array or string representing the fields to group by. - `having` is an array or string representing the having conditions. - `limit` is a number indicating the query limit. - `offset` is a number indicating the query offset. - `epilog` is a string representing the epilog for the query. - `autoFields` is a boolean indicating whether to enable auto fields. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. ``` $query = $model->findWithDeleted(...$data); ``` **Purge** Delete an [*Entity*](https://github.com/elusivecodes/FyreEntity) (permanently). - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$options` is an array of named parameters containing delete options. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `cascade` is a boolean indicating whether to cascade deletes, and will default to *true*. ``` $result = $model->purge($entity, ...$options); ``` **Purge Many** Delete multiple entities (permanently). - `$entities` is an array or *Traversable* containing the entities. - `$options` is an array of named parameters containing delete options. - `events` is a boolean indicating whether to trigger model/behavior events, and will default to *true*. - `cascade` is a boolean indicating whether to cascade deletes, and will default to *true*. ``` $result = $model->purgeMany($entities, ...$options); ``` **Restore** Restore an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$options` is an array of named parameters containing save options. - `dependents` is a boolean indicating whether to restore dependents, and will default to *true*. ``` $result = $model->restore($entity, ...$options); ``` **Restore Many** Restore multiple entities. - `$entities` is an array or *Traversable* containing the entities. - `$options` is an array of named parameters containing save options. - `dependents` is a boolean indicating whether to restore dependents, and will default to *true*. ``` $result = $model->restoreMany($entities, ...$options); ``` ### Timestamp [](#timestamp) The timestamp behavior provides a simple way to automatically update created/modified timestamps when saving data via models. - `$options` is an array containing behavior options. - `createdField` is a string representing the created field name, and will default to "*created*". - `modifiedField` is a string representing the modified field name, and will default to "*modified*". ``` $model->addBehavior('Timestamp', $options); ``` RuleSets -------- [](#rulesets) **Add** Add a rule. - `$rule` is a *Closure*, that accepts an [*Entity*](https://github.com/elusivecodes/FyreEntity) as the first argument, and should return *false* if the validation failed. ``` $rules->add($rule); ``` The `$rule` should be expressed in the following format: ``` $rule = function(Entity $entity): bool { // validation logic return true; }; ``` The `$rule` will be automatically bound to the [*Model*](#models), and any other arguments will be resolved from the [*Container*](https://github.com/elusivecodes/FyreContainer). **Validate** Validate an [*Entity*](https://github.com/elusivecodes/FyreEntity). - `$entity` is an [*Entity*](https://github.com/elusivecodes/FyreEntity). ``` $rules->validate($entity); ``` ### Rules [](#rules) **Exists In** Create an "exists in" rule. - `$fields` is an array containing the fields. - `$name` is the name of the relationship. - `$options` is an array of named parameters containing the rule options. - `targetFields` is an array containing fields to match in the target table, and will default to the primary key(s). - `callback` is a *Closure*, that accepts the [*SelectQuery*](#select) as an argument. - `allowNullableNulls` is a boolean indicating whether to allow nullable nulls, and will default to *null*. - `message` is a string representing the error message, and will default to the [*Lang*](https://github.com/elusivecodes/FyreLang) value for "*RuleSet.existsIn*". ``` RuleSet::existsIn($fields, $name, ...$options); ``` **Is Clean** Create an "is clean" rule. - `$fields` is an array containing the fields. - `$options` is an array of named parameters containing the rule options. - `message` is a string representing the error message, and will default to the [*Lang*](https://github.com/elusivecodes/FyreLang) value for "*RuleSet.isClean*". ``` RuleSet::isClean($fields, ...$options); ``` **Is Unique** Create an "is unique" rule. - `$fields` is an array containing the fields. - `$options` is an array of named parameters containing the rule options. - `callback` is a *Closure*, that accepts the [*SelectQuery*](#select) as an argument. - `allowMultipleNulls` is a boolean indicating whether to allow multiple nulls, and will default to *true*. - `message` is a string representing the error message, and will default to the [*Lang*](https://github.com/elusivecodes/FyreLang) value for "*RuleSet.isUnique*". ``` RuleSet::isUnique($fields, ...$options); ``` ### Health Score 42 — FairBetter than 89% of packages Maintenance62 Regular maintenance activity Popularity16 Limited adoption so far Community17 Small or concentrated contributor base Maturity64 Established project with proven stability Bus Factor1 Top contributor holds 98.1% 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 ~19 days Recently: every ~32 days Total 69 Last Release 230d ago Major Versions v8.0.2 → v9.02024-11-05 v9.1.0 → v10.02024-11-17 v10.1.0 → v11.02025-02-12 v11.1.3 → v12.02025-09-18 v12.0.2 → v13.02025-11-09 ### Community Maintainers ![](https://www.gravatar.com/avatar/fad81fd5941e3a637c8a5749d05ae3ed9314d5e2fee57f59c3d9ec3b41259c6b?d=identicon)[elusivecodes](/maintainers/elusivecodes) --- Top Contributors [![elusivecodes](https://avatars.githubusercontent.com/u/18050480?v=4)](https://github.com/elusivecodes "elusivecodes (53 commits)")[![pm-michael](https://avatars.githubusercontent.com/u/49225527?v=4)](https://github.com/pm-michael "pm-michael (1 commits)") --- Tags databasemysqlormphp ### Code Quality TestsPHPUnit Code StylePHP CS Fixer ### Embed Badge ![Health badge](/badges/fyre-orm/health.svg) ``` [![Health](https://phpackages.com/badges/fyre-orm/health.svg)](https://phpackages.com/packages/fyre-orm) ``` ### Alternatives [jdorn/sql-formatter a PHP SQL highlighting library 3.9k116.5M113](/packages/jdorn-sql-formatter)[propel/propel1 Propel is an open-source Object-Relational Mapping (ORM) for PHP5. 8351.6M87](/packages/propel-propel1) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)