analogueorm / analogue

src/Commands/Store.php

Indentation +225 added lines, -225 removed lines

@@ -14,240 +14,240 @@
  */
 class Store extends Command
 {
-    /**
-     * Persist the entity in the database
-     *
-     * @throws \InvalidArgumentException
-     * @return false|mixed
-     */
-    public function execute()
-    {
-        $entity = $this->aggregate->getEntityObject();
-
-        $mapper = $this->aggregate->getMapper();
-
-        if ($mapper->fireEvent('storing', $entity) === false) {
-            return false;
-        }
-
-        $this->preStoreProcess();
-
-        /**
-         * We will test the entity for existence
-         * and run a creation if it doesn't exists
-         */
-        if (!$this->aggregate->exists()) {
-            if ($mapper->fireEvent('creating', $entity) === false) {
-                return false;
-            }
-
-            $this->insert();
-
-            $mapper->fireEvent('created', $entity, false);
-        }
+	/**
+	 * Persist the entity in the database
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return false|mixed
+	 */
+	public function execute()
+	{
+		$entity = $this->aggregate->getEntityObject();
+
+		$mapper = $this->aggregate->getMapper();
+
+		if ($mapper->fireEvent('storing', $entity) === false) {
+			return false;
+		}
+
+		$this->preStoreProcess();
+
+		/**
+		 * We will test the entity for existence
+		 * and run a creation if it doesn't exists
+		 */
+		if (!$this->aggregate->exists()) {
+			if ($mapper->fireEvent('creating', $entity) === false) {
+				return false;
+			}
+
+			$this->insert();
+
+			$mapper->fireEvent('created', $entity, false);
+		}
         
-        /**
-         * We'll only run an update if the entity
-         * is actually dirty
-         */
-        if ($this->aggregate->isDirty()) {
-            if ($mapper->fireEvent('updating', $entity) === false) {
-                return false;
-            }
-            $this->update();
-
-            $mapper->fireEvent('updated', $entity, false);
-        }
-
-        $this->postStoreProcess();
-
-        $mapper->fireEvent('stored', $entity, false);
-
-        return $entity;
-    }
-
-    /**
-     * Run all operations that have to occur before actually
-     * storing the entity
-     *
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function preStoreProcess()
-    {
-        // Create any related object that doesn't exist in the database.
-        $localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
-
-        $this->createRelatedEntities($localRelationships);
-
-        // Now we can sync the related collections
-        $this->aggregate->syncRelationships($localRelationships);
-    }
-
-    /**
-     * Check for existence and create non-existing related entities
-     *
-     * @param  array
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function createRelatedEntities($relations)
-    {
-        $entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
-
-        foreach ($entitiesToCreate as $aggregate) {
-            $this->createStoreCommand($aggregate)->execute();
-        }
-    }
-
-    /**
-     * Create a new store command
-     *
-     * @param  Aggregate $aggregate
-     * @return Store
-     */
-    protected function createStoreCommand(Aggregate $aggregate)
-    {
-        // We gotta retrieve the corresponding query adapter to use.
-        $mapper = $aggregate->getMapper();
-
-        return new Store($aggregate, $mapper->newQueryBuilder());
-    }
-
-    /**
-     * Run all operations that have to occur after the entity
-     * is stored.
-     *
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function postStoreProcess()
-    {
-        $aggregate = $this->aggregate;
-
-        // Create any related object that doesn't exist in the database.
-        $foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
-        $this->createRelatedEntities($foreignRelationships);
-
-        // Update any pivot tables that has been modified.
-        $aggregate->updatePivotRecords();
-
-        // Update any dirty relationship. This include relationships that already exists, have
-        // dirty attributes / newly created related entities / dirty related entities.
-        $dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
-
-        foreach ($dirtyRelatedAggregates as $related) {
-            $this->createStoreCommand($related)->execute();
-        }
-
-        // Now we can sync the related collections
-        if ($this->aggregate->exists()) {
-            $this->aggregate->syncRelationships($foreignRelationships);
-        }
+		/**
+		 * We'll only run an update if the entity
+		 * is actually dirty
+		 */
+		if ($this->aggregate->isDirty()) {
+			if ($mapper->fireEvent('updating', $entity) === false) {
+				return false;
+			}
+			$this->update();
+
+			$mapper->fireEvent('updated', $entity, false);
+		}
+
+		$this->postStoreProcess();
+
+		$mapper->fireEvent('stored', $entity, false);
+
+		return $entity;
+	}
+
+	/**
+	 * Run all operations that have to occur before actually
+	 * storing the entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function preStoreProcess()
+	{
+		// Create any related object that doesn't exist in the database.
+		$localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
+
+		$this->createRelatedEntities($localRelationships);
+
+		// Now we can sync the related collections
+		$this->aggregate->syncRelationships($localRelationships);
+	}
+
+	/**
+	 * Check for existence and create non-existing related entities
+	 *
+	 * @param  array
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function createRelatedEntities($relations)
+	{
+		$entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
+
+		foreach ($entitiesToCreate as $aggregate) {
+			$this->createStoreCommand($aggregate)->execute();
+		}
+	}
+
+	/**
+	 * Create a new store command
+	 *
+	 * @param  Aggregate $aggregate
+	 * @return Store
+	 */
+	protected function createStoreCommand(Aggregate $aggregate)
+	{
+		// We gotta retrieve the corresponding query adapter to use.
+		$mapper = $aggregate->getMapper();
+
+		return new Store($aggregate, $mapper->newQueryBuilder());
+	}
+
+	/**
+	 * Run all operations that have to occur after the entity
+	 * is stored.
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function postStoreProcess()
+	{
+		$aggregate = $this->aggregate;
+
+		// Create any related object that doesn't exist in the database.
+		$foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
+		$this->createRelatedEntities($foreignRelationships);
+
+		// Update any pivot tables that has been modified.
+		$aggregate->updatePivotRecords();
+
+		// Update any dirty relationship. This include relationships that already exists, have
+		// dirty attributes / newly created related entities / dirty related entities.
+		$dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
+
+		foreach ($dirtyRelatedAggregates as $related) {
+			$this->createStoreCommand($related)->execute();
+		}
+
+		// Now we can sync the related collections
+		if ($this->aggregate->exists()) {
+			$this->aggregate->syncRelationships($foreignRelationships);
+		}
         
-        // TODO be move it to the wrapper class
-        // so it's the same code for the entity builder
-        $aggregate->setProxies();
-
-        // Update Entity Cache
-        $aggregate->getMapper()->getEntityCache()->refresh($aggregate);
-    }
-
-    /**
-     * Update Related Entities which attributes have
-     * been modified.
-     *
-     * @return void
-     */
-    protected function updateDirtyRelated()
-    {
-        $relations = $this->entityMap->getRelationships();
-        $attributes = $this->getAttributes();
-
-        foreach ($relations as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                continue;
-            }
-
-            $value = $attributes[$relation];
-
-            if ($value == null) {
-                continue;
-            }
-
-            if ($value instanceof EntityProxy) {
-                continue;
-            }
-
-            if ($value instanceof CollectionProxy && $value->isLoaded()) {
-                $value = $value->getUnderlyingCollection();
-            }
-            if ($value instanceof CollectionProxy && !$value->isLoaded()) {
-                foreach ($value->getAddedItems() as $entity) {
-                    $this->updateEntityIfDirty($entity);
-                }
-                continue;
-            }
-
-            if ($value instanceof EntityCollection) {
-                foreach ($value as $entity) {
-                    if (!$this->createEntityIfNotExists($entity)) {
-                        $this->updateEntityIfDirty($entity);
-                    }
-                }
-                continue;
-            }
-            if ($value instanceof Mappable) {
-                $this->updateEntityIfDirty($value);
-                continue;
-            }
-        }
-    }
-
-    /**
-     * Execute an insert statement on the database
-     *
-     * @return void
-     */
-    protected function insert()
-    {
-        $aggregate = $this->aggregate;
-
-        $attributes = $aggregate->getRawAttributes();
+		// TODO be move it to the wrapper class
+		// so it's the same code for the entity builder
+		$aggregate->setProxies();
+
+		// Update Entity Cache
+		$aggregate->getMapper()->getEntityCache()->refresh($aggregate);
+	}
+
+	/**
+	 * Update Related Entities which attributes have
+	 * been modified.
+	 *
+	 * @return void
+	 */
+	protected function updateDirtyRelated()
+	{
+		$relations = $this->entityMap->getRelationships();
+		$attributes = $this->getAttributes();
+
+		foreach ($relations as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				continue;
+			}
+
+			$value = $attributes[$relation];
+
+			if ($value == null) {
+				continue;
+			}
+
+			if ($value instanceof EntityProxy) {
+				continue;
+			}
+
+			if ($value instanceof CollectionProxy && $value->isLoaded()) {
+				$value = $value->getUnderlyingCollection();
+			}
+			if ($value instanceof CollectionProxy && !$value->isLoaded()) {
+				foreach ($value->getAddedItems() as $entity) {
+					$this->updateEntityIfDirty($entity);
+				}
+				continue;
+			}
+
+			if ($value instanceof EntityCollection) {
+				foreach ($value as $entity) {
+					if (!$this->createEntityIfNotExists($entity)) {
+						$this->updateEntityIfDirty($entity);
+					}
+				}
+				continue;
+			}
+			if ($value instanceof Mappable) {
+				$this->updateEntityIfDirty($value);
+				continue;
+			}
+		}
+	}
+
+	/**
+	 * Execute an insert statement on the database
+	 *
+	 * @return void
+	 */
+	protected function insert()
+	{
+		$aggregate = $this->aggregate;
+
+		$attributes = $aggregate->getRawAttributes();
         
-        $keyName = $aggregate->getEntityMap()->getKeyName();
+		$keyName = $aggregate->getEntityMap()->getKeyName();
 
-        // Check if the primary key is defined in the attributes
-        if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
-            $this->query->insert($attributes);
-        } else {
-            $sequence = $aggregate->getEntityMap()->getSequence();
+		// Check if the primary key is defined in the attributes
+		if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
+			$this->query->insert($attributes);
+		} else {
+			$sequence = $aggregate->getEntityMap()->getSequence();
 
-            $id = $this->query->insertGetId($attributes, $sequence);
+			$id = $this->query->insertGetId($attributes, $sequence);
 
-            $aggregate->setEntityAttribute($keyName, $id);
-        }
-    }
+			$aggregate->setEntityAttribute($keyName, $id);
+		}
+	}
 
-    /**
-     * Run an update statement on the entity
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function update()
-    {
-        $query = $this->query;
+	/**
+	 * Run an update statement on the entity
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function update()
+	{
+		$query = $this->query;
 
-        $keyName = $this->aggregate->getEntityKey();
+		$keyName = $this->aggregate->getEntityKey();
 
-        $query = $query->where($keyName, '=', $this->aggregate->getEntityId());
+		$query = $query->where($keyName, '=', $this->aggregate->getEntityId());
 
-        $dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
+		$dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
 
-        if (count($dirtyAttributes) > 0) {
-            $query->update($dirtyAttributes);
-        }
-    }
+		if (count($dirtyAttributes) > 0) {
+			$query->update($dirtyAttributes);
+		}
+	}
 }

src/Relationships/BelongsToMany.php

Indentation +928 added lines, -928 removed lines

@@ -12,937 +12,937 @@
 
 class BelongsToMany extends Relationship
 {
-    /**
-     * The intermediate table for the relation.
-     *
-     * @var string
-     */
-    protected $table;
-
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The associated key of the relation.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The "name" of the relationship.
-     *
-     * @var string
-     */
-    protected $relationName;
-
-    /**
-     * The pivot table columns to retrieve.
-     *
-     * @var array
-     */
-    protected $pivotColumns = [];
-
-    /**
-     * This relationship has pivot attributes
-     *
-     * @var boolean
-     */
-    protected static $hasPivot = true;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper   $mapper
-     * @param Mappable $parent
-     * @param string   $table
-     * @param string   $foreignKey
-     * @param string   $otherKey
-     * @param string   $relationName
-     */
-    public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relationName = null)
-    {
-        $this->table = $table;
-        $this->otherKey = $otherKey;
-        $this->foreignKey = $foreignKey;
-        $this->relationName = $relationName;
-
-        parent::__construct($mapper, $parent);
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function attachTo($related)
-    {
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function detachFrom($related)
-    {
-        $ids = $this->getIdsFromHashes([$related]);
-
-        $this->detach($ids);
-    }
-
-    /**
-     * @param $related
-     */
-    public function detachMany($related)
-    {
-        $ids = $this->getIdsFromHashes($related);
-
-        $this->detach($ids);
-    }
-
-    /**
-     * @param array $hashes
-     * @return array
-     */
-    protected function getIdsFromHashes(array $hashes)
-    {
-        $ids = [];
-
-        foreach ($hashes as $hash) {
-            $split = explode('.', $hash);
-            $ids[] = $split[1];
-        }
-        return $ids;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param $relation
-     *
-     * @return EntityCollection
-     */
-    public function getResults($relation)
-    {
-        $results = $this->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Set a where clause for a pivot table column.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @param  string $boolean
-     * @return self
-     */
-    public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        return $this->where($this->table . '.' . $column, $operator, $value, $boolean);
-    }
-
-    /**
-     * Set an or where clause for a pivot table column.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @return self
-     */
-    public function orWherePivot($column, $operator = null, $value = null)
-    {
-        return $this->wherePivot($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotColumns;
-    }
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param  array $columns
-     * @return mixed
-     */
-    public function first($columns = ['*'])
-    {
-        $results = $this->take(1)->get($columns);
-
-        return count($results) > 0 ? $results->first() : null;
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param  array $columns
-     *
-     * @throws EntityNotFoundException
-     *
-     * @return Mappable|self
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw new EntityNotFoundException;
-    }
-
-    /**
-     * Execute the query as a "select" statement.
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function get($columns = ['*'])
-    {
-        // First we'll add the proper select columns onto the query so it is run with
-        // the proper columns. Then, we will get the results and hydrate out pivot
-        // models with the result of those columns as a separate model relation.
-        $columns = $this->query->getQuery()->columns ? [] : $columns;
-
-        $select = $this->getSelectColumns($columns);
-
-        $entities = $this->query->addSelect($select)->getEntities();
-
-        $this->hydratePivotRelation($entities);
-
-        // If we actually found models we will also eager load any relationships that
-        // have been specified as needing to be eager loaded. This will solve the
-        // n + 1 query problem for the developer and also increase performance.
-        if (count($entities) > 0) {
-            $entities = $this->query->eagerLoadRelations($entities);
-        }
-
-        return $this->relatedMap->newCollection($entities);
-    }
-
-    /**
-     * Hydrate the pivot table relationship on the models.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    protected function hydratePivotRelation(array $entities)
-    {
-        // To hydrate the pivot relationship, we will just gather the pivot attributes
-        // and create a new Pivot model, which is basically a dynamic model that we
-        // will set the attributes, table, and connections on so it they be used.
-
-        foreach ($entities as $entity) {
-            $entityWrapper = $this->factory->make($entity);
-
-            $pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
-
-            $entityWrapper->setEntityAttribute('pivot', $pivot);
-        }
-    }
-
-    /**
-     * Get the pivot attributes from a model.
-     *
-     * @param  $entity
-     * @return array
-     */
-    protected function cleanPivotAttributes(InternallyMappable $entity)
-    {
-        $values = [];
-
-        $attributes = $entity->getEntityAttributes();
-
-        foreach ($attributes as $key => $value) {
-            // To get the pivots attributes we will just take any of the attributes which
-            // begin with "pivot_" and add those to this arrays, as well as unsetting
-            // them from the parent's models since they exist in a different table.
-            if (strpos($key, 'pivot_') === 0) {
-                $values[substr($key, 6)] = $value;
-
-                unset($attributes[$key]);
-            }
-        }
-
-        // Rehydrate Entity with cleaned array.
-        $entity->setEntityAttributes($attributes);
-
-        return $values;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        $this->setJoin();
-
-        if (static::$constraints) {
-            $this->setWhere();
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        if ($parent->getQuery()->from == $query->getQuery()->from) {
-            return $this->getRelationCountQueryForSelfJoin($query, $parent);
-        }
-
-        $this->setJoin($query);
-
-        return parent::getRelationCountQuery($query, $parent);
-    }
-
-    /**
-     * Add the constraints for a relationship count query on the same table.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
-
-        $query->from($this->table . ' as ' . $tablePrefix . $hash = $this->getRelationCountHash());
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($hash . '.' . $this->foreignKey, '=', new Expression($key));
-    }
-
-    /**
-     * Get a relationship join table hash.
-     *
-     * @return string
-     */
-    public function getRelationCountHash()
-    {
-        return 'self_' . md5(microtime(true));
-    }
-
-    /**
-     * Set the select clause for the relation query.
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    protected function getSelectColumns(array $columns = ['*'])
-    {
-        if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable() . '.*'];
-        }
-
-        return array_merge($columns, $this->getAliasedPivotColumns());
-    }
-
-    /**
-     * Get the pivot columns for the relation.
-     *
-     * @return array
-     */
-    protected function getAliasedPivotColumns()
-    {
-        $defaults = [$this->foreignKey, $this->otherKey];
-
-        // We need to alias all of the pivot columns with the "pivot_" prefix so we
-        // can easily extract them out of the models and put them into the pivot
-        // relationships when they are retrieved and hydrated into the models.
-        $columns = [];
-
-        foreach (array_merge($defaults, $this->pivotColumns) as $column) {
-            $columns[] = $this->table . '.' . $column . ' as pivot_' . $column;
-        }
-
-        return array_unique($columns);
-    }
-
-    /**
-     * Set the join clause for the relation query.
-     *
-     * @param  \Analogue\ORM\Query|null
-     * @return $this
-     */
-    protected function setJoin($query = null)
-    {
-        $query = $query ?: $this->query;
-
-        // We need to join to the intermediate table on the related model's primary
-        // key column with the intermediate table's foreign key for the related
-        // model instance. Then we can set the "where" for the parent models.
-        $baseTable = $this->relatedMap->getTable();
-
-        $key = $baseTable . '.' . $this->relatedMap->getKeyName();
-
-        $query->join($this->table, $key, '=', $this->getOtherKey());
-
-        return $this;
-    }
-
-    /**
-     * Set the where clause for the relation query.
-     *
-     * @return $this
-     */
-    protected function setWhere()
-    {
-        $foreign = $this->getForeignKey();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        $this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
-
-        return $this;
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $this->query->whereIn($this->getForeignKey(), $this->getKeys($entities));
-    }
-
-    /**
-     * Initialize the relation on a set of eneities.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            $entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        $dictionary = $this->buildDictionary($results);
-
-        $keyName = $this->relatedMap->getKeyName();
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        // Once we have an array dictionary of child objects we can easily match the
-        // children back to their parent using the dictionary and the keys on the
-        // the parent models. Then we will return the hydrated models back out.
-        foreach ($entities as $entity) {
-            $wrapper = $this->factory->make($entity);
-
-            if (isset($dictionary[$key = $wrapper->getEntityAttribute($keyName)])) {
-                $collection = $this->relatedMap->newCollection($dictionary[$key]);
-
-                $wrapper->setEntityAttribute($relation, $collection);
-
-                $cache->cacheLoadedRelationResult($entity, $relation, $collection, $this);
-            }
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Build model dictionary keyed by the relation's foreign key.
-     *
-     * @param  EntityCollection $results
-     * @return array
-     */
-    protected function buildDictionary(EntityCollection $results)
-    {
-        $foreign = $this->foreignKey;
-
-        // First we will build a dictionary of child models keyed by the foreign key
-        // of the relation so that we will easily and quickly match them to their
-        // parents without having a possibly slow inner loops for every models.
-        $dictionary = [];
-
-        foreach ($results as $entity) {
-            $wrapper = $this->factory->make($entity);
-
-            $dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * Get all of the IDs for the related models.
-     *
-     * @return array
-     */
-    public function getRelatedIds()
-    {
-        $fullKey = $this->relatedMap->getQualifiedKeyName();
-
-        return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
-    }
-
-    /**
-     * Update Pivot
-     *
-     * @param  \Analogue\ORM\Entity $entity
-     * @return void
-     */
-    public function updatePivot($entity)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        $this->updateExistingPivot(
-            $entity->getEntityAttribute($keyName),
-            $entity->getEntityAttribute('pivot')->getEntityAttributes()
-        );
-    }
-
-    /**
-     * Update Multiple pivot
-     *
-     * @param  $relatedEntities
-     * @return void
-     */
-    public function updatePivots($relatedEntities)
-    {
-        foreach ($relatedEntities as $entity) {
-            $this->updatePivot($entity);
-        }
-    }
-
-    /**
-     * Create Pivot Records
-     *
-     * @param \Analogue\ORM\Entity[] $relatedEntities
-     * @return void
-     */
-    public function createPivots($relatedEntities)
-    {
-        $keys = [];
-        $attributes = [];
-
-        $keyName = $this->relatedMap->getKeyName();
-
-        foreach ($relatedEntities as $entity) {
-            $keys[] = $entity->getEntityAttribute($keyName);
-        }
-
-        $records = $this->createAttachRecords($keys, $attributes);
-
-        $this->query->getQuery()->from($this->table)->insert($records);
-    }
-
-    /**
-     * Update an existing pivot record on the table.
-     *
-     * @param  mixed $id
-     * @param  array $attributes
-     * @throws \InvalidArgumentException
-     * @return integer
-     */
-    public function updateExistingPivot($id, array $attributes)
-    {
-        if (in_array($this->updatedAt(), $this->pivotColumns)) {
-            $attributes = $this->setTimestampsOnAttach($attributes, true);
-        }
-
-        return $this->newPivotStatementForId($id)->update($attributes);
-    }
-
-    /**
-     * Attach a model to the parent.
-     *
-     * @param  mixed $id
-     * @param  array $attributes
-     * @return void
-     */
-    public function attach($id, array $attributes = [])
-    {
-        $query = $this->newPivotStatement();
-
-        $query->insert($this->createAttachRecords((array) $id, $attributes));
-    }
-
-    /**
-     * @param  array $entities
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function sync(array $entities)
-    {
-        $this->detachExcept($entities);
-    }
-
-    /**
-     * Detach related entities that are not in $id
-     *
-     * @param  array $entities
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function detachExcept(array $entities = [])
-    {
-        tdd($this->relationName);
-        $query = $this->newPivotQuery();
-
-        if (count($entities) > 0) {
-            $keys = $this->getKeys($entities);
-
-            $query->whereNotIn($this->otherKey, $keys);
-        }
-        $parentKey = $this->parentMap->getKeyName();
-
-        $query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
+	/**
+	 * The intermediate table for the relation.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The associated key of the relation.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The "name" of the relationship.
+	 *
+	 * @var string
+	 */
+	protected $relationName;
+
+	/**
+	 * The pivot table columns to retrieve.
+	 *
+	 * @var array
+	 */
+	protected $pivotColumns = [];
+
+	/**
+	 * This relationship has pivot attributes
+	 *
+	 * @var boolean
+	 */
+	protected static $hasPivot = true;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper   $mapper
+	 * @param Mappable $parent
+	 * @param string   $table
+	 * @param string   $foreignKey
+	 * @param string   $otherKey
+	 * @param string   $relationName
+	 */
+	public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relationName = null)
+	{
+		$this->table = $table;
+		$this->otherKey = $otherKey;
+		$this->foreignKey = $foreignKey;
+		$this->relationName = $relationName;
+
+		parent::__construct($mapper, $parent);
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function attachTo($related)
+	{
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function detachFrom($related)
+	{
+		$ids = $this->getIdsFromHashes([$related]);
+
+		$this->detach($ids);
+	}
+
+	/**
+	 * @param $related
+	 */
+	public function detachMany($related)
+	{
+		$ids = $this->getIdsFromHashes($related);
+
+		$this->detach($ids);
+	}
+
+	/**
+	 * @param array $hashes
+	 * @return array
+	 */
+	protected function getIdsFromHashes(array $hashes)
+	{
+		$ids = [];
+
+		foreach ($hashes as $hash) {
+			$split = explode('.', $hash);
+			$ids[] = $split[1];
+		}
+		return $ids;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param $relation
+	 *
+	 * @return EntityCollection
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Set a where clause for a pivot table column.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @param  string $boolean
+	 * @return self
+	 */
+	public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		return $this->where($this->table . '.' . $column, $operator, $value, $boolean);
+	}
+
+	/**
+	 * Set an or where clause for a pivot table column.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @return self
+	 */
+	public function orWherePivot($column, $operator = null, $value = null)
+	{
+		return $this->wherePivot($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotColumns;
+	}
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param  array $columns
+	 * @return mixed
+	 */
+	public function first($columns = ['*'])
+	{
+		$results = $this->take(1)->get($columns);
+
+		return count($results) > 0 ? $results->first() : null;
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param  array $columns
+	 *
+	 * @throws EntityNotFoundException
+	 *
+	 * @return Mappable|self
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw new EntityNotFoundException;
+	}
+
+	/**
+	 * Execute the query as a "select" statement.
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function get($columns = ['*'])
+	{
+		// First we'll add the proper select columns onto the query so it is run with
+		// the proper columns. Then, we will get the results and hydrate out pivot
+		// models with the result of those columns as a separate model relation.
+		$columns = $this->query->getQuery()->columns ? [] : $columns;
+
+		$select = $this->getSelectColumns($columns);
+
+		$entities = $this->query->addSelect($select)->getEntities();
+
+		$this->hydratePivotRelation($entities);
+
+		// If we actually found models we will also eager load any relationships that
+		// have been specified as needing to be eager loaded. This will solve the
+		// n + 1 query problem for the developer and also increase performance.
+		if (count($entities) > 0) {
+			$entities = $this->query->eagerLoadRelations($entities);
+		}
+
+		return $this->relatedMap->newCollection($entities);
+	}
+
+	/**
+	 * Hydrate the pivot table relationship on the models.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	protected function hydratePivotRelation(array $entities)
+	{
+		// To hydrate the pivot relationship, we will just gather the pivot attributes
+		// and create a new Pivot model, which is basically a dynamic model that we
+		// will set the attributes, table, and connections on so it they be used.
+
+		foreach ($entities as $entity) {
+			$entityWrapper = $this->factory->make($entity);
+
+			$pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
+
+			$entityWrapper->setEntityAttribute('pivot', $pivot);
+		}
+	}
+
+	/**
+	 * Get the pivot attributes from a model.
+	 *
+	 * @param  $entity
+	 * @return array
+	 */
+	protected function cleanPivotAttributes(InternallyMappable $entity)
+	{
+		$values = [];
+
+		$attributes = $entity->getEntityAttributes();
+
+		foreach ($attributes as $key => $value) {
+			// To get the pivots attributes we will just take any of the attributes which
+			// begin with "pivot_" and add those to this arrays, as well as unsetting
+			// them from the parent's models since they exist in a different table.
+			if (strpos($key, 'pivot_') === 0) {
+				$values[substr($key, 6)] = $value;
+
+				unset($attributes[$key]);
+			}
+		}
+
+		// Rehydrate Entity with cleaned array.
+		$entity->setEntityAttributes($attributes);
+
+		return $values;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		$this->setJoin();
+
+		if (static::$constraints) {
+			$this->setWhere();
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		if ($parent->getQuery()->from == $query->getQuery()->from) {
+			return $this->getRelationCountQueryForSelfJoin($query, $parent);
+		}
+
+		$this->setJoin($query);
+
+		return parent::getRelationCountQuery($query, $parent);
+	}
+
+	/**
+	 * Add the constraints for a relationship count query on the same table.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
+
+		$query->from($this->table . ' as ' . $tablePrefix . $hash = $this->getRelationCountHash());
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($hash . '.' . $this->foreignKey, '=', new Expression($key));
+	}
+
+	/**
+	 * Get a relationship join table hash.
+	 *
+	 * @return string
+	 */
+	public function getRelationCountHash()
+	{
+		return 'self_' . md5(microtime(true));
+	}
+
+	/**
+	 * Set the select clause for the relation query.
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	protected function getSelectColumns(array $columns = ['*'])
+	{
+		if ($columns == ['*']) {
+			$columns = [$this->relatedMap->getTable() . '.*'];
+		}
+
+		return array_merge($columns, $this->getAliasedPivotColumns());
+	}
+
+	/**
+	 * Get the pivot columns for the relation.
+	 *
+	 * @return array
+	 */
+	protected function getAliasedPivotColumns()
+	{
+		$defaults = [$this->foreignKey, $this->otherKey];
+
+		// We need to alias all of the pivot columns with the "pivot_" prefix so we
+		// can easily extract them out of the models and put them into the pivot
+		// relationships when they are retrieved and hydrated into the models.
+		$columns = [];
+
+		foreach (array_merge($defaults, $this->pivotColumns) as $column) {
+			$columns[] = $this->table . '.' . $column . ' as pivot_' . $column;
+		}
+
+		return array_unique($columns);
+	}
+
+	/**
+	 * Set the join clause for the relation query.
+	 *
+	 * @param  \Analogue\ORM\Query|null
+	 * @return $this
+	 */
+	protected function setJoin($query = null)
+	{
+		$query = $query ?: $this->query;
+
+		// We need to join to the intermediate table on the related model's primary
+		// key column with the intermediate table's foreign key for the related
+		// model instance. Then we can set the "where" for the parent models.
+		$baseTable = $this->relatedMap->getTable();
+
+		$key = $baseTable . '.' . $this->relatedMap->getKeyName();
+
+		$query->join($this->table, $key, '=', $this->getOtherKey());
+
+		return $this;
+	}
+
+	/**
+	 * Set the where clause for the relation query.
+	 *
+	 * @return $this
+	 */
+	protected function setWhere()
+	{
+		$foreign = $this->getForeignKey();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		$this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
+
+		return $this;
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$this->query->whereIn($this->getForeignKey(), $this->getKeys($entities));
+	}
+
+	/**
+	 * Initialize the relation on a set of eneities.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			$entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		$dictionary = $this->buildDictionary($results);
+
+		$keyName = $this->relatedMap->getKeyName();
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		// Once we have an array dictionary of child objects we can easily match the
+		// children back to their parent using the dictionary and the keys on the
+		// the parent models. Then we will return the hydrated models back out.
+		foreach ($entities as $entity) {
+			$wrapper = $this->factory->make($entity);
+
+			if (isset($dictionary[$key = $wrapper->getEntityAttribute($keyName)])) {
+				$collection = $this->relatedMap->newCollection($dictionary[$key]);
+
+				$wrapper->setEntityAttribute($relation, $collection);
+
+				$cache->cacheLoadedRelationResult($entity, $relation, $collection, $this);
+			}
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Build model dictionary keyed by the relation's foreign key.
+	 *
+	 * @param  EntityCollection $results
+	 * @return array
+	 */
+	protected function buildDictionary(EntityCollection $results)
+	{
+		$foreign = $this->foreignKey;
+
+		// First we will build a dictionary of child models keyed by the foreign key
+		// of the relation so that we will easily and quickly match them to their
+		// parents without having a possibly slow inner loops for every models.
+		$dictionary = [];
+
+		foreach ($results as $entity) {
+			$wrapper = $this->factory->make($entity);
+
+			$dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * Get all of the IDs for the related models.
+	 *
+	 * @return array
+	 */
+	public function getRelatedIds()
+	{
+		$fullKey = $this->relatedMap->getQualifiedKeyName();
+
+		return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
+	}
+
+	/**
+	 * Update Pivot
+	 *
+	 * @param  \Analogue\ORM\Entity $entity
+	 * @return void
+	 */
+	public function updatePivot($entity)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		$this->updateExistingPivot(
+			$entity->getEntityAttribute($keyName),
+			$entity->getEntityAttribute('pivot')->getEntityAttributes()
+		);
+	}
+
+	/**
+	 * Update Multiple pivot
+	 *
+	 * @param  $relatedEntities
+	 * @return void
+	 */
+	public function updatePivots($relatedEntities)
+	{
+		foreach ($relatedEntities as $entity) {
+			$this->updatePivot($entity);
+		}
+	}
+
+	/**
+	 * Create Pivot Records
+	 *
+	 * @param \Analogue\ORM\Entity[] $relatedEntities
+	 * @return void
+	 */
+	public function createPivots($relatedEntities)
+	{
+		$keys = [];
+		$attributes = [];
+
+		$keyName = $this->relatedMap->getKeyName();
+
+		foreach ($relatedEntities as $entity) {
+			$keys[] = $entity->getEntityAttribute($keyName);
+		}
+
+		$records = $this->createAttachRecords($keys, $attributes);
+
+		$this->query->getQuery()->from($this->table)->insert($records);
+	}
+
+	/**
+	 * Update an existing pivot record on the table.
+	 *
+	 * @param  mixed $id
+	 * @param  array $attributes
+	 * @throws \InvalidArgumentException
+	 * @return integer
+	 */
+	public function updateExistingPivot($id, array $attributes)
+	{
+		if (in_array($this->updatedAt(), $this->pivotColumns)) {
+			$attributes = $this->setTimestampsOnAttach($attributes, true);
+		}
+
+		return $this->newPivotStatementForId($id)->update($attributes);
+	}
+
+	/**
+	 * Attach a model to the parent.
+	 *
+	 * @param  mixed $id
+	 * @param  array $attributes
+	 * @return void
+	 */
+	public function attach($id, array $attributes = [])
+	{
+		$query = $this->newPivotStatement();
+
+		$query->insert($this->createAttachRecords((array) $id, $attributes));
+	}
+
+	/**
+	 * @param  array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function sync(array $entities)
+	{
+		$this->detachExcept($entities);
+	}
+
+	/**
+	 * Detach related entities that are not in $id
+	 *
+	 * @param  array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function detachExcept(array $entities = [])
+	{
+		tdd($this->relationName);
+		$query = $this->newPivotQuery();
+
+		if (count($entities) > 0) {
+			$keys = $this->getKeys($entities);
+
+			$query->whereNotIn($this->otherKey, $keys);
+		}
+		$parentKey = $this->parentMap->getKeyName();
+
+		$query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
         
-        $query->delete();
-
-        $query = $this->newPivotQuery();
-    }
-
-
-    /**
-     * Create an array of records to insert into the pivot table.
-     *
-     * @param  array $ids
-     * @param  array $attributes
-     * @return array
-     */
-    protected function createAttachRecords($ids, array $attributes)
-    {
-        $records = [];
-
-        $timed = in_array($this->createdAt(), $this->pivotColumns);
-
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        foreach ($ids as $key => $value) {
-            $records[] = $this->attacher($key, $value, $attributes, $timed);
-        }
+		$query->delete();
+
+		$query = $this->newPivotQuery();
+	}
+
+
+	/**
+	 * Create an array of records to insert into the pivot table.
+	 *
+	 * @param  array $ids
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function createAttachRecords($ids, array $attributes)
+	{
+		$records = [];
+
+		$timed = in_array($this->createdAt(), $this->pivotColumns);
+
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		foreach ($ids as $key => $value) {
+			$records[] = $this->attacher($key, $value, $attributes, $timed);
+		}
         
-        return $records;
-    }
-
-    /**
-     * Create a full attachment record payload.
-     *
-     * @param  int   $key
-     * @param  mixed $value
-     * @param  array $attributes
-     * @param  bool  $timed
-     * @return array
-     */
-    protected function attacher($key, $value, $attributes, $timed)
-    {
-        list($id, $extra) = $this->getAttachId($key, $value, $attributes);
+		return $records;
+	}
+
+	/**
+	 * Create a full attachment record payload.
+	 *
+	 * @param  int   $key
+	 * @param  mixed $value
+	 * @param  array $attributes
+	 * @param  bool  $timed
+	 * @return array
+	 */
+	protected function attacher($key, $value, $attributes, $timed)
+	{
+		list($id, $extra) = $this->getAttachId($key, $value, $attributes);
         
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        $record = $this->createAttachRecord($id, $timed);
-
-        return array_merge($record, $extra);
-    }
-
-    /**
-     * Get the attach record ID and extra attributes.
-     *
-     * @param  int   $key
-     * @param  mixed $value
-     * @param  array $attributes
-     * @return array
-     */
-    protected function getAttachId($key, $value, array $attributes)
-    {
-        if (is_array($value)) {
-            return [$key, array_merge($value, $attributes)];
-        }
-
-        return [$value, $attributes];
-    }
-
-    /**
-     * Create a new pivot attachment record.
-     *
-     * @param  int  $id
-     * @param  bool $timed
-     * @return array
-     */
-    protected function createAttachRecord($id, $timed)
-    {
-        $parentKey = $this->parentMap->getKeyName();
-
-        $record = [];
-
-        $record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
-
-        $record[$this->otherKey] = $id;
-
-        // If the record needs to have creation and update timestamps, we will make
-        // them by calling the parent model's "freshTimestamp" method which will
-        // provide us with a fresh timestamp in this model's preferred format.
-        if ($timed) {
-            $record = $this->setTimestampsOnAttach($record);
-        }
-
-        return $record;
-    }
-
-    /**
-     * Set the creation and update timestamps on an attach record.
-     *
-     * @param  array $record
-     * @param  bool  $exists
-     * @return array
-     */
-    protected function setTimestampsOnAttach(array $record, $exists = false)
-    {
-        $fresh = $this->freshTimestamp();
-
-        if (!$exists) {
-            $record[$this->createdAt()] = $fresh;
-        }
-
-        $record[$this->updatedAt()] = $fresh;
-
-        return $record;
-    }
-
-    /**
-     * @param EntityCollection $entities
-     * @return array
-     */
-    protected function getModelKeysFromCollection(EntityCollection $entities)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        return array_map(function ($m) use ($keyName) {
-            return $m->$keyName;
-        }, $entities);
-    }
-
-    /**
-     * Detach models from the relationship.
-     *
-     * @param  int|array $ids
-     * @throws \InvalidArgumentException
-     * @return int
-     */
-    public function detach($ids = [])
-    {
-        if ($ids instanceof EntityCollection) {
-            $ids = (array) $ids->modelKeys();
-        }
-
-        $query = $this->newPivotQuery();
-
-        // If associated IDs were passed to the method we will only delete those
-        // associations, otherwise all of the association ties will be broken.
-        // We'll return the numbers of affected rows when we do the deletes.
-        $ids = (array) $ids;
-
-        if (count($ids) > 0) {
-            $query->whereIn($this->otherKey, (array) $ids);
-        }
-
-        // Once we have all of the conditions set on the statement, we are ready
-        // to run the delete on the pivot table. Then, if the touch parameter
-        // is true, we will go ahead and touch all related models to sync.
-        return $query->delete();
-    }
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		$record = $this->createAttachRecord($id, $timed);
+
+		return array_merge($record, $extra);
+	}
+
+	/**
+	 * Get the attach record ID and extra attributes.
+	 *
+	 * @param  int   $key
+	 * @param  mixed $value
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function getAttachId($key, $value, array $attributes)
+	{
+		if (is_array($value)) {
+			return [$key, array_merge($value, $attributes)];
+		}
+
+		return [$value, $attributes];
+	}
+
+	/**
+	 * Create a new pivot attachment record.
+	 *
+	 * @param  int  $id
+	 * @param  bool $timed
+	 * @return array
+	 */
+	protected function createAttachRecord($id, $timed)
+	{
+		$parentKey = $this->parentMap->getKeyName();
+
+		$record = [];
+
+		$record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
+
+		$record[$this->otherKey] = $id;
+
+		// If the record needs to have creation and update timestamps, we will make
+		// them by calling the parent model's "freshTimestamp" method which will
+		// provide us with a fresh timestamp in this model's preferred format.
+		if ($timed) {
+			$record = $this->setTimestampsOnAttach($record);
+		}
+
+		return $record;
+	}
+
+	/**
+	 * Set the creation and update timestamps on an attach record.
+	 *
+	 * @param  array $record
+	 * @param  bool  $exists
+	 * @return array
+	 */
+	protected function setTimestampsOnAttach(array $record, $exists = false)
+	{
+		$fresh = $this->freshTimestamp();
+
+		if (!$exists) {
+			$record[$this->createdAt()] = $fresh;
+		}
+
+		$record[$this->updatedAt()] = $fresh;
+
+		return $record;
+	}
+
+	/**
+	 * @param EntityCollection $entities
+	 * @return array
+	 */
+	protected function getModelKeysFromCollection(EntityCollection $entities)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		return array_map(function ($m) use ($keyName) {
+			return $m->$keyName;
+		}, $entities);
+	}
+
+	/**
+	 * Detach models from the relationship.
+	 *
+	 * @param  int|array $ids
+	 * @throws \InvalidArgumentException
+	 * @return int
+	 */
+	public function detach($ids = [])
+	{
+		if ($ids instanceof EntityCollection) {
+			$ids = (array) $ids->modelKeys();
+		}
+
+		$query = $this->newPivotQuery();
+
+		// If associated IDs were passed to the method we will only delete those
+		// associations, otherwise all of the association ties will be broken.
+		// We'll return the numbers of affected rows when we do the deletes.
+		$ids = (array) $ids;
+
+		if (count($ids) > 0) {
+			$query->whereIn($this->otherKey, (array) $ids);
+		}
+
+		// Once we have all of the conditions set on the statement, we are ready
+		// to run the delete on the pivot table. Then, if the touch parameter
+		// is true, we will go ahead and touch all related models to sync.
+		return $query->delete();
+	}
     
-    /**
-     * Create a new query builder for the pivot table.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    protected function newPivotQuery()
-    {
-        $query = $this->newPivotStatement();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
-    }
-
-    /**
-     * Get a new plain query builder for the pivot table.
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatement()
-    {
-        return $this->query->getQuery()->newQuery()->from($this->table);
-    }
-
-    /**
-     * Get a new pivot statement for a given "other" ID.
-     *
-     * @param  mixed $id
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatementForId($id)
-    {
-        $pivot = $this->newPivotStatement();
-
-        $parentKeyName = $this->parentMap->getKeyName();
-
-        $key = $this->parent->getEntityAttribute($parentKeyName);
-
-        return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
-    }
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param  array $attributes
-     * @param  bool  $exists
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newPivot(array $attributes = [], $exists = false)
-    {
-        $pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
+	/**
+	 * Create a new query builder for the pivot table.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function newPivotQuery()
+	{
+		$query = $this->newPivotStatement();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
+	}
+
+	/**
+	 * Get a new plain query builder for the pivot table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatement()
+	{
+		return $this->query->getQuery()->newQuery()->from($this->table);
+	}
+
+	/**
+	 * Get a new pivot statement for a given "other" ID.
+	 *
+	 * @param  mixed $id
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatementForId($id)
+	{
+		$pivot = $this->newPivotStatement();
+
+		$parentKeyName = $this->parentMap->getKeyName();
+
+		$key = $this->parent->getEntityAttribute($parentKeyName);
+
+		return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
+	}
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param  array $attributes
+	 * @param  bool  $exists
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newPivot(array $attributes = [], $exists = false)
+	{
+		$pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
         
-        return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
-    }
-
-    /**
-     * Create a new existing pivot model instance.
-     *
-     * @param  array $attributes
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newExistingPivot(array $attributes = [])
-    {
-        return $this->newPivot($attributes, true);
-    }
-
-    /**
-     * Set the columns on the pivot table to retrieve.
-     *
-     * @param  array $columns
-     * @return $this
-     */
-    public function withPivot($columns)
-    {
-        $columns = is_array($columns) ? $columns : func_get_args();
-
-        $this->pivotColumns = array_merge($this->pivotColumns, $columns);
-
-        return $this;
-    }
-
-    /**
-     * Specify that the pivot table has creation and update timestamps.
-     *
-     * @param  mixed $createdAt
-     * @param  mixed $updatedAt
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    public function withTimestamps($createdAt = null, $updatedAt = null)
-    {
-        return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
-    }
-
-    /**
-     * Get the key for comparing against the parent key in "has" query.
-     *
-     * @return string
-     */
-    public function getHasCompareKey()
-    {
-        return $this->getForeignKey();
-    }
-
-    /**
-     * Get the fully qualified foreign key for the relation.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->table . '.' . $this->foreignKey;
-    }
-
-    /**
-     * Get the fully qualified "other key" for the relation.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->table . '.' . $this->otherKey;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parentMap->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the intermediate table for the relationship.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->table;
-    }
-
-    /**
-     * Get the relationship name for the relationship.
-     *
-     * @return string
-     */
-    public function getRelationName()
-    {
-        return $this->relationName;
-    }
+		return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
+	}
+
+	/**
+	 * Create a new existing pivot model instance.
+	 *
+	 * @param  array $attributes
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newExistingPivot(array $attributes = [])
+	{
+		return $this->newPivot($attributes, true);
+	}
+
+	/**
+	 * Set the columns on the pivot table to retrieve.
+	 *
+	 * @param  array $columns
+	 * @return $this
+	 */
+	public function withPivot($columns)
+	{
+		$columns = is_array($columns) ? $columns : func_get_args();
+
+		$this->pivotColumns = array_merge($this->pivotColumns, $columns);
+
+		return $this;
+	}
+
+	/**
+	 * Specify that the pivot table has creation and update timestamps.
+	 *
+	 * @param  mixed $createdAt
+	 * @param  mixed $updatedAt
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	public function withTimestamps($createdAt = null, $updatedAt = null)
+	{
+		return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
+	}
+
+	/**
+	 * Get the key for comparing against the parent key in "has" query.
+	 *
+	 * @return string
+	 */
+	public function getHasCompareKey()
+	{
+		return $this->getForeignKey();
+	}
+
+	/**
+	 * Get the fully qualified foreign key for the relation.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->table . '.' . $this->foreignKey;
+	}
+
+	/**
+	 * Get the fully qualified "other key" for the relation.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->table . '.' . $this->otherKey;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parentMap->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the intermediate table for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->table;
+	}
+
+	/**
+	 * Get the relationship name for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getRelationName()
+	{
+		return $this->relationName;
+	}
 }

src/System/Aggregate.php

Indentation +992 added lines, -992 removed lines

@@ -15,1016 +15,1016 @@
  */
 class Aggregate implements InternallyMappable
 {
-    /**
-     * The Root Entity
-     *
-     * @var \Analogue\ORM\System\Wrappers\Wrapper
-     */
-    protected $wrappedEntity;
-
-    /**
-     * Parent Root Aggregate
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $parent;
-
-    /**
-     * Parent's relationship method
-     *
-     * @var string
-     */
-    protected $parentRelationship;
-
-    /**
-     * Root Entity
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $root;
-
-    /**
-     * An associative array containing entity's
-     * relationships converted to Aggregates
-     *
-     * @var array
-     */
-    protected $relationships = [];
-
-    /**
-     * Relationship that need post-command synchronization
-     *
-     * @var array
-     */
-    protected $needSync = [];
-
-    /**
-     * Mapper
-     *
-     * @var \Analogue\ORM\System\Mapper;
-     */
-    protected $mapper;
-
-    /**
-     * Entity Map
-     *
-     * @var \Analogue\ORM\EntityMap;
-     */
-    protected $entityMap;
-
-    /**
-     * Create a new Aggregated Entity instance
-     *
-     * @param mixed          $entity
-     * @param Aggregate|null $parent
-     * @param string         $parentRelationship
-     * @param Aggregate|null $root
-     * @throws MappingException
-     */
-    public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
-    {
-        $factory = new Factory;
+	/**
+	 * The Root Entity
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Wrapper
+	 */
+	protected $wrappedEntity;
+
+	/**
+	 * Parent Root Aggregate
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $parent;
+
+	/**
+	 * Parent's relationship method
+	 *
+	 * @var string
+	 */
+	protected $parentRelationship;
+
+	/**
+	 * Root Entity
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $root;
+
+	/**
+	 * An associative array containing entity's
+	 * relationships converted to Aggregates
+	 *
+	 * @var array
+	 */
+	protected $relationships = [];
+
+	/**
+	 * Relationship that need post-command synchronization
+	 *
+	 * @var array
+	 */
+	protected $needSync = [];
+
+	/**
+	 * Mapper
+	 *
+	 * @var \Analogue\ORM\System\Mapper;
+	 */
+	protected $mapper;
+
+	/**
+	 * Entity Map
+	 *
+	 * @var \Analogue\ORM\EntityMap;
+	 */
+	protected $entityMap;
+
+	/**
+	 * Create a new Aggregated Entity instance
+	 *
+	 * @param mixed          $entity
+	 * @param Aggregate|null $parent
+	 * @param string         $parentRelationship
+	 * @param Aggregate|null $root
+	 * @throws MappingException
+	 */
+	public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
+	{
+		$factory = new Factory;
         
-        $this->wrappedEntity = $factory->make($entity);
+		$this->wrappedEntity = $factory->make($entity);
 
-        $this->parent = $parent;
+		$this->parent = $parent;
 
-        $this->parentRelationship = $parentRelationship;
+		$this->parentRelationship = $parentRelationship;
 
-        $this->root = $root;
+		$this->root = $root;
 
-        $this->mapper = Manager::getMapper($entity);
+		$this->mapper = Manager::getMapper($entity);
 
-        $this->entityMap = $this->mapper->getEntityMap();
+		$this->entityMap = $this->mapper->getEntityMap();
              
-        $this->parseRelationships();
-    }
-
-    /**
-     * Parse Every relationships defined on the entity
-     *
-     * @throws MappingException
-     * @return void
-     */
-    protected function parseRelationships()
-    {
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $this->parseSingleRelationship($relation);
-        }
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $this->parseManyRelationship($relation);
-        }
-    }
-
-    /**
-     * Parse for values common to single & many relations
-     *
-     * @param  string $relation
-     * @throws MappingException
-     * @return mixed|boolean
-     */
-    protected function parseForCommonValues($relation)
-    {
-        if (!$this->hasAttribute($relation)) {
-            // If no attribute exists for this relationships
-            // we'll make it a simple empty array. This will
-            // save us from constantly checking for the attributes
-            // actual existence.
-            $this->relationships[$relation] = [];
-            return false;
-        }
-
-        $value = $this->getRelationshipValue($relation);
-
-        if (is_null($value)) {
-            $this->relationships[$relation] = [];
-
-            // If the relationship's content is the null value
-            // and the Entity's exist in DB, we'll interpret this
-            // as the need to detach all related Entities,
-            // therefore a sync operation is needed.
-            $this->needSync[] = $relation;
-            return false;
-        }
-
-        return $value;
-    }
-
-    /**
-     * Parse a 'single' relationship
-     *
-     * @param  string $relation
-     * @throws MappingException
-     * @return boolean
-     */
-    protected function parseSingleRelationship($relation)
-    {
-        if (!$value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
+		$this->parseRelationships();
+	}
+
+	/**
+	 * Parse Every relationships defined on the entity
+	 *
+	 * @throws MappingException
+	 * @return void
+	 */
+	protected function parseRelationships()
+	{
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$this->parseSingleRelationship($relation);
+		}
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$this->parseManyRelationship($relation);
+		}
+	}
+
+	/**
+	 * Parse for values common to single & many relations
+	 *
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return mixed|boolean
+	 */
+	protected function parseForCommonValues($relation)
+	{
+		if (!$this->hasAttribute($relation)) {
+			// If no attribute exists for this relationships
+			// we'll make it a simple empty array. This will
+			// save us from constantly checking for the attributes
+			// actual existence.
+			$this->relationships[$relation] = [];
+			return false;
+		}
+
+		$value = $this->getRelationshipValue($relation);
+
+		if (is_null($value)) {
+			$this->relationships[$relation] = [];
+
+			// If the relationship's content is the null value
+			// and the Entity's exist in DB, we'll interpret this
+			// as the need to detach all related Entities,
+			// therefore a sync operation is needed.
+			$this->needSync[] = $relation;
+			return false;
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Parse a 'single' relationship
+	 *
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return boolean
+	 */
+	protected function parseSingleRelationship($relation)
+	{
+		if (!$value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
         
-        if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
-            throw new MappingException("Entity's attribute $relation should not be array, or collection");
-        }
-
-        if ($value instanceof EntityProxy && !$value->isLoaded()) {
-            $this->relationships[$relation] = [];
-            return true;
-        }
-
-        // If the attribute is a loaded proxy, swap it for its
-        // loaded entity.
-        if ($value instanceof EntityProxy && $value->isLoaded()) {
-            $value = $value->getUnderlyingObject();
-        }
-
-        if ($this->isParentOrRoot($value)) {
-            $this->relationships[$relation] = [];
-            return true;
-        }
-
-        // At this point, we can assume the attribute is an Entity instance
-        // so we'll treat it as such.
-        $subAggregate = $this->createSubAggregate($value, $relation);
+		if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
+			throw new MappingException("Entity's attribute $relation should not be array, or collection");
+		}
+
+		if ($value instanceof EntityProxy && !$value->isLoaded()) {
+			$this->relationships[$relation] = [];
+			return true;
+		}
+
+		// If the attribute is a loaded proxy, swap it for its
+		// loaded entity.
+		if ($value instanceof EntityProxy && $value->isLoaded()) {
+			$value = $value->getUnderlyingObject();
+		}
+
+		if ($this->isParentOrRoot($value)) {
+			$this->relationships[$relation] = [];
+			return true;
+		}
+
+		// At this point, we can assume the attribute is an Entity instance
+		// so we'll treat it as such.
+		$subAggregate = $this->createSubAggregate($value, $relation);
          
-        // Even if it's a single entity, we'll store it as an array
-        // just for consistency with other relationships
-        $this->relationships[$relation] = [$subAggregate];
-
-        // We always need to check a loaded relation is in sync
-        // with its local key
-        $this->needSync[] = $relation;
-
-        return true;
-    }
-
-    /**
-     * Check if value isn't parent or root in the aggregate
-     *
-     * @param  mixed
-     * @return boolean|null
-     */
-    protected function isParentOrRoot($value)
-    {
-        if (!is_null($this->root)) {
-            $rootClass = get_class($this->root->getEntityObject());
-            if ($rootClass == get_class($value)) {
-                return true;
-            }
-        }
-
-        if (!is_null($this->parent)) {
-            $parentClass = get_class($this->parent->getEntityObject());
-            if ($parentClass == get_class($value)) {
-                return true;
-            }
-        }
-    }
-
-    /**
-     * Parse a 'many' relationship
-     *
-     * @param  string $relation
-     * @throws MappingException
-     * @return boolean
-     */
-    protected function parseManyRelationship($relation)
-    {
-        if (!$value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
+		// Even if it's a single entity, we'll store it as an array
+		// just for consistency with other relationships
+		$this->relationships[$relation] = [$subAggregate];
+
+		// We always need to check a loaded relation is in sync
+		// with its local key
+		$this->needSync[] = $relation;
+
+		return true;
+	}
+
+	/**
+	 * Check if value isn't parent or root in the aggregate
+	 *
+	 * @param  mixed
+	 * @return boolean|null
+	 */
+	protected function isParentOrRoot($value)
+	{
+		if (!is_null($this->root)) {
+			$rootClass = get_class($this->root->getEntityObject());
+			if ($rootClass == get_class($value)) {
+				return true;
+			}
+		}
+
+		if (!is_null($this->parent)) {
+			$parentClass = get_class($this->parent->getEntityObject());
+			if ($parentClass == get_class($value)) {
+				return true;
+			}
+		}
+	}
+
+	/**
+	 * Parse a 'many' relationship
+	 *
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return boolean
+	 */
+	protected function parseManyRelationship($relation)
+	{
+		if (!$value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
         
-        if (is_array($value) || $value instanceof Collection) {
-            $this->needSync[] = $relation;
-        }
-
-        // If the relation is a proxy, we test is the relation
-        // has been lazy loaded, otherwise we'll just treat
-        // the subset of newly added items.
-        if ($value instanceof CollectionProxy && $value->isLoaded()) {
-            $this->needSync[] = $relation;
-            $value = $value->getUnderlyingCollection();
-        }
-
-        if ($value instanceof CollectionProxy && !$value->isLoaded()) {
-            $value = $value->getAddedItems();
-        }
-
-        // At this point $value should be either an array or an instance
-        // of a collection class.
-        if (!is_array($value) && !$value instanceof Collection) {
-            throw new MappingException("'$relation' attribute should be array() or Collection");
-        }
-
-        $this->relationships[$relation] = $this->createSubAggregates($value, $relation);
+		if (is_array($value) || $value instanceof Collection) {
+			$this->needSync[] = $relation;
+		}
+
+		// If the relation is a proxy, we test is the relation
+		// has been lazy loaded, otherwise we'll just treat
+		// the subset of newly added items.
+		if ($value instanceof CollectionProxy && $value->isLoaded()) {
+			$this->needSync[] = $relation;
+			$value = $value->getUnderlyingCollection();
+		}
+
+		if ($value instanceof CollectionProxy && !$value->isLoaded()) {
+			$value = $value->getAddedItems();
+		}
+
+		// At this point $value should be either an array or an instance
+		// of a collection class.
+		if (!is_array($value) && !$value instanceof Collection) {
+			throw new MappingException("'$relation' attribute should be array() or Collection");
+		}
+
+		$this->relationships[$relation] = $this->createSubAggregates($value, $relation);
         
-        return true;
-    }
-
-    /**
-     * Return Entity's relationship attribute
-     *
-     * @param  string $relation
-     * @throws MappingException
-     * @return mixed
-     */
-    protected function getRelationshipValue($relation)
-    {
-        $value = $this->getEntityAttribute($relation);
-        //if($relation == "role") tdd($this->wrappedEntity->getEntityAttributes());
-        if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
-            throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
-        }
-
-        return $value;
-    }
-
-    /**
-     * Create a child, aggregated entity
-     *
-     * @param  mixed $entities
-     * @param string $relation
-     * @return array
-     */
-    protected function createSubAggregates($entities, $relation)
-    {
-        $aggregates = [];
-
-        foreach ($entities as $entity) {
-            $aggregates[] = $this->createSubAggregate($entity, $relation);
-        }
-
-        return $aggregates;
-    }
-
-    /**
-     * Create a related subAggregate
-     *
-     * @param  mixed $entity
-     * @param  string $relation
-     * @throws MappingException
-     * @return self
-     */
-    protected function createSubAggregate($entity, $relation)
-    {
-        // If root isn't defined, then this is the Aggregate Root
-        if (is_null($this->root)) {
-            $root = $this;
-        } else {
-            $root = $this->root;
-        }
-
-        return new self($entity, $this, $relation, $root);
-    }
-
-    /**
-     * Get the Entity's primary key attribute
-     *
-     * @return string|integer
-     */
-    public function getEntityId()
-    {
-        return $this->wrappedEntity->getEntityAttribute($this->entityMap->getKeyName());
-    }
-
-    /**
-     * Get the name of the primary key
-     *
-     * @return string
-     */
-    public function getEntityKey()
-    {
-        return $this->entityMap->getKeyName();
-    }
-
-    /**
-     * Return the entity map for the current entity
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Return the Entity's hash $class.$id
-     *
-     * @return string
-     */
-    public function getEntityHash()
-    {
-        return $this->getEntityClass() . '.' . $this->getEntityId();
-    }
-
-    /**
-     * Get wrapped entity class
-     *
-     * @return string
-     */
-    public function getEntityClass()
-    {
-        return $this->entityMap->getClass();
-    }
-
-    /**
-     * Return the Mapper's entity cache
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getEntityCache()
-    {
-        return $this->mapper->getEntityCache();
-    }
-
-    /**
-     * Get a relationship as an aggregated entities' array
-     *
-     * @param  string $name
-     * @return array
-     */
-    public function getRelationship($name)
-    {
-        if (array_key_exists($name, $this->relationships)) {
-            return $this->relationships[$name];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * [TO IMPLEMENT]
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get Non existing related entities from several relationships
-     *
-     * @param  array $relationships
-     * @return array
-     */
-    public function getNonExistingRelated(array $relationships)
-    {
-        $nonExisting = [];
-
-        foreach ($relationships as $relation) {
-            if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
-                $nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Get non-existing related entities from a single relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getNonExistingFromRelation($relation)
-    {
-        $nonExisting = [];
-
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if (!$aggregate->exists()) {
-                $nonExisting[] = $aggregate;
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Synchronize relationships if needed
-     */
-    public function syncRelationships(array $relationships)
-    {
-        if ($this->exists()) {
-            foreach ($relationships as $relation) {
-                if (in_array($relation, $this->needSync)) {
-                    $this->synchronize($relation);
-                }
-            }
-        }
-    }
-
-    /**
-     * Synchronize a relationship attribute
-     *
-     * @param $relation
-     */
-    protected function synchronize($relation)
-    {
-        $actualContent = $this->relationships[$relation];
-
-        $this->entityMap->$relation($this->getEntityObject())->sync($actualContent);
-    }
-
-    /**
-     * Returns an array of Missing related Entities for the
-     * given $relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    public function getMissingEntities($relation)
-    {
-        $cachedRelations = $this->getCachedAttribute($relation);
-
-        if (!is_null($cachedRelations)) {
-            $missing = [];
-
-            foreach ($cachedRelations as $hash) {
-                if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
-                    $missing[] = $hash;
-                }
-            }
-
-            return $missing;
-        } else {
-            return [];
-        }
-    }
+		return true;
+	}
+
+	/**
+	 * Return Entity's relationship attribute
+	 *
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	protected function getRelationshipValue($relation)
+	{
+		$value = $this->getEntityAttribute($relation);
+		//if($relation == "role") tdd($this->wrappedEntity->getEntityAttributes());
+		if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
+			throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Create a child, aggregated entity
+	 *
+	 * @param  mixed $entities
+	 * @param string $relation
+	 * @return array
+	 */
+	protected function createSubAggregates($entities, $relation)
+	{
+		$aggregates = [];
+
+		foreach ($entities as $entity) {
+			$aggregates[] = $this->createSubAggregate($entity, $relation);
+		}
+
+		return $aggregates;
+	}
+
+	/**
+	 * Create a related subAggregate
+	 *
+	 * @param  mixed $entity
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return self
+	 */
+	protected function createSubAggregate($entity, $relation)
+	{
+		// If root isn't defined, then this is the Aggregate Root
+		if (is_null($this->root)) {
+			$root = $this;
+		} else {
+			$root = $this->root;
+		}
+
+		return new self($entity, $this, $relation, $root);
+	}
+
+	/**
+	 * Get the Entity's primary key attribute
+	 *
+	 * @return string|integer
+	 */
+	public function getEntityId()
+	{
+		return $this->wrappedEntity->getEntityAttribute($this->entityMap->getKeyName());
+	}
+
+	/**
+	 * Get the name of the primary key
+	 *
+	 * @return string
+	 */
+	public function getEntityKey()
+	{
+		return $this->entityMap->getKeyName();
+	}
+
+	/**
+	 * Return the entity map for the current entity
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Return the Entity's hash $class.$id
+	 *
+	 * @return string
+	 */
+	public function getEntityHash()
+	{
+		return $this->getEntityClass() . '.' . $this->getEntityId();
+	}
+
+	/**
+	 * Get wrapped entity class
+	 *
+	 * @return string
+	 */
+	public function getEntityClass()
+	{
+		return $this->entityMap->getClass();
+	}
+
+	/**
+	 * Return the Mapper's entity cache
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getEntityCache()
+	{
+		return $this->mapper->getEntityCache();
+	}
+
+	/**
+	 * Get a relationship as an aggregated entities' array
+	 *
+	 * @param  string $name
+	 * @return array
+	 */
+	public function getRelationship($name)
+	{
+		if (array_key_exists($name, $this->relationships)) {
+			return $this->relationships[$name];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * [TO IMPLEMENT]
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get Non existing related entities from several relationships
+	 *
+	 * @param  array $relationships
+	 * @return array
+	 */
+	public function getNonExistingRelated(array $relationships)
+	{
+		$nonExisting = [];
+
+		foreach ($relationships as $relation) {
+			if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
+				$nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Get non-existing related entities from a single relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getNonExistingFromRelation($relation)
+	{
+		$nonExisting = [];
+
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if (!$aggregate->exists()) {
+				$nonExisting[] = $aggregate;
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Synchronize relationships if needed
+	 */
+	public function syncRelationships(array $relationships)
+	{
+		if ($this->exists()) {
+			foreach ($relationships as $relation) {
+				if (in_array($relation, $this->needSync)) {
+					$this->synchronize($relation);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Synchronize a relationship attribute
+	 *
+	 * @param $relation
+	 */
+	protected function synchronize($relation)
+	{
+		$actualContent = $this->relationships[$relation];
+
+		$this->entityMap->$relation($this->getEntityObject())->sync($actualContent);
+	}
+
+	/**
+	 * Returns an array of Missing related Entities for the
+	 * given $relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function getMissingEntities($relation)
+	{
+		$cachedRelations = $this->getCachedAttribute($relation);
+
+		if (!is_null($cachedRelations)) {
+			$missing = [];
+
+			foreach ($cachedRelations as $hash) {
+				if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
+					$missing[] = $hash;
+				}
+			}
+
+			return $missing;
+		} else {
+			return [];
+		}
+	}
        
-    /**
-     * Get Relationships who have dirty attributes / dirty relationships
-     *
-     * @return array
-     */
-    public function getDirtyRelationships()
-    {
-        $dirtyAggregates = [];
-
-        foreach ($this->relationships as $relation) {
-            foreach ($relation as $aggregate) {
-                if (!$aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
-                    $dirtyAggregates[] = $aggregate;
-                }
-            }
-        }
-
-        return $dirtyAggregates;
-    }
+	/**
+	 * Get Relationships who have dirty attributes / dirty relationships
+	 *
+	 * @return array
+	 */
+	public function getDirtyRelationships()
+	{
+		$dirtyAggregates = [];
+
+		foreach ($this->relationships as $relation) {
+			foreach ($relation as $aggregate) {
+				if (!$aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
+					$dirtyAggregates[] = $aggregate;
+				}
+			}
+		}
+
+		return $dirtyAggregates;
+	}
     
-    /**
-     * Compare the object's raw attributes with the record in cache
-     *
-     * @return boolean
-     */
-    public function isDirty()
-    {
-        if (count($this->getDirtyRawAttributes()) > 0) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Get Raw Entity's attributes, as they are represented
-     * in the database, including value objects & foreign keys
-     *
-     * @return array
-     */
-    public function getRawAttributes()
-    {
-        $attributes = $this->wrappedEntity->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            unset($attributes[$relation]);
-        }
-
-        $attributes = $this->flattenEmbeddables($attributes);
-
-        $foreignKeys = $this->getForeignKeyAttributes();
-
-        return $attributes + $foreignKeys;
-    }
-
-    /**
-     * Convert Value Objects to raw db attributes
-     *
-     * @param  array $attributes
-     * @return array
-     */
-    protected function flattenEmbeddables($attributes)
-    {
-        $embeddables = $this->entityMap->getEmbeddables();
+	/**
+	 * Compare the object's raw attributes with the record in cache
+	 *
+	 * @return boolean
+	 */
+	public function isDirty()
+	{
+		if (count($this->getDirtyRawAttributes()) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get Raw Entity's attributes, as they are represented
+	 * in the database, including value objects & foreign keys
+	 *
+	 * @return array
+	 */
+	public function getRawAttributes()
+	{
+		$attributes = $this->wrappedEntity->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			unset($attributes[$relation]);
+		}
+
+		$attributes = $this->flattenEmbeddables($attributes);
+
+		$foreignKeys = $this->getForeignKeyAttributes();
+
+		return $attributes + $foreignKeys;
+	}
+
+	/**
+	 * Convert Value Objects to raw db attributes
+	 *
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function flattenEmbeddables($attributes)
+	{
+		$embeddables = $this->entityMap->getEmbeddables();
         
-        foreach ($embeddables as $localKey => $embed) {
-            // Retrieve the value object from the entity's attributes
-            $valueObject = $attributes[$localKey];
+		foreach ($embeddables as $localKey => $embed) {
+			// Retrieve the value object from the entity's attributes
+			$valueObject = $attributes[$localKey];
 
-            // Unset the corresponding key
-            unset($attributes[$localKey]);
+			// Unset the corresponding key
+			unset($attributes[$localKey]);
 
-            // TODO Make wrapper object compatible with value objects
-            $valueObjectAttributes = $valueObject->getEntityAttributes();
+			// TODO Make wrapper object compatible with value objects
+			$valueObjectAttributes = $valueObject->getEntityAttributes();
 
-            // Now (if setup in the entity map) we prefix the value object's
-            // attributes with the snake_case name of the embedded class.
-            $prefix = snake_case(class_basename($embed));
+			// Now (if setup in the entity map) we prefix the value object's
+			// attributes with the snake_case name of the embedded class.
+			$prefix = snake_case(class_basename($embed));
 
-            foreach ($valueObjectAttributes as $key=>$value) {
-                $valueObjectAttributes[$prefix . '_' . $key] = $value;
-                unset($valueObjectAttributes[$key]);
-            }
+			foreach ($valueObjectAttributes as $key=>$value) {
+				$valueObjectAttributes[$prefix . '_' . $key] = $value;
+				unset($valueObjectAttributes[$key]);
+			}
 
-            $attributes = array_merge($attributes, $valueObjectAttributes);
-        }
+			$attributes = array_merge($attributes, $valueObjectAttributes);
+		}
         
-        return $attributes;
-    }
-
-    /**
-     * Return's entity raw attributes in the state they were at last
-     * query.
-     *
-     * @param  array|null $columns
-     * @return array
-     */
-    protected function getCachedRawAttributes(array $columns = null)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (is_null($columns)) {
-            return $cachedAttributes;
-        } else {
-            return array_only($cachedAttributes, $columns);
-        }
-    }
-
-    /**
-     * Return a single attribute from the cache
-     * @param  string $key
-     * @return mixed
-     */
-    protected function getCachedAttribute($key)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (!array_key_exists($key, $cachedAttributes)) {
-            return null;
-        } else {
-            return $cachedAttributes[$key];
-        }
-    }
-
-    /**
-     * Convert related Entity's attributes to foreign keys
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributes()
-    {
-        $foreignKeys = [];
-
-        foreach ($this->entityMap->getLocalRelationships() as $relation) {
-            // check if relationship has been parsed, meaning it has an actual object
-            // in the entity's attributes
-            if ($this->isActualRelationships($relation)) {
-                $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
-            }
-        }
-
-        if (!is_null($this->parent)) {
-            $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromParent();
-        }
-
-        return $foreignKeys;
-    }
-
-    /**
-     * Return an associative array containing the key-value pair(s) from
-     * the related entity.
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromRelation($relation)
-    {
-        $localRelations = $this->entityMap->getLocalRelationships();
-
-        if (in_array($relation, $localRelations)) {
-            // Call Relationship's method
-            $relationship = $this->entityMap->$relation($this->getEntityObject());
-
-            $relatedAggregate = $this->relationships[$relation][0];
-
-            return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Get foreign key attribute(s) from a parent entity in this
-     * aggregate context
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromParent()
-    {
-        $parentMap = $this->parent->getEntityMap();
-
-        $parentForeignRelations = $parentMap->getForeignRelationships();
-        $parentPivotRelations = $parentMap->getPivotRelationships();
-
-        $parentRelation = $this->parentRelationship;
-
-        if (in_array($parentRelation, $parentForeignRelations)
-            && !in_array($parentRelation, $parentPivotRelations)
-        ) {
-            $parentObject = $this->parent->getEntityObject();
-
-            // Call Relationship's method on parent map
-            $relationship = $parentMap->$parentRelation($parentObject);
-
-            return $relationship->getForeignKeyValuePair();
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Update Pivot records on loaded relationships, by comparing the
-     * values from the Entity Cache to the actual relationship inside
-     * the aggregated entity.
-     *
-     * @return void
-     */
-    public function updatePivotRecords()
-    {
-        $pivots = $this->entityMap->getPivotRelationships();
-
-        foreach ($pivots as $pivot) {
-            if (array_key_exists($pivot, $this->relationships)) {
-                $this->updatePivotRelation($pivot);
-            }
-        }
-    }
-
-    /**
-     * Update Single pivot relationship
-     *
-     * @param  string $relation
-     * @return void
-     */
-    protected function updatePivotRelation($relation)
-    {
-        $hashes = $this->getEntityHashesFromRelation($relation);
-
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        if (array_key_exists($relation, $cachedAttributes)) {
-            // Compare the two array of hashes to find out existing
-            // pivot records, and the ones to be created.
-            $new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
-            $existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
-        } else {
-            $existing = [];
-            $new = $hashes;
-        }
-
-        if (count($new) > 0) {
-            $pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
-
-            $this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
-        }
-
-        if (count($existing) > 0) {
-            foreach ($existing as $pivotHash) {
-                $this->updatePivotIfDirty($pivotHash, $relation);
-            }
-        }
-    }
-
-    /**
-     * Compare existing pivot record in cache and update it
-     * if the pivot attributes are dirty
-     *
-     * @param  string $pivotHash
-     * @param  string $relation
-     * @return void
-     */
-    protected function updatePivotIfDirty($pivotHash, $relation)
-    {
-        $aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
-
-        if ($aggregate->hasAttribute('pivot')) {
-            $pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
-
-            $cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
-
-            $actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
-
-            $dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
-
-            if (count($dirty) > 0) {
-                $id = $aggregate->getEntityId();
-
-                $this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
-            }
-        }
-    }
-
-    /**
-     * Compare two attributes array and return dirty attributes
-     *
-     * @param  array $actual
-     * @param  array $cached
-     * @return array
-     */
-    protected function getDirtyAttributes(array $actual, array $cached)
-    {
-        $dirty = [];
-
-        foreach ($actual as $key => $value) {
-            if (!$this->originalIsNumericallyEquivalent($value, $cached[$key])) {
-                $dirty[$key] = $actual[$key];
-            }
-        }
-
-        return $dirty;
-    }
-
-    /**
-     *
-     * @param  string $pivotHash
-     * @param  string $relation
-     * @return array
-     */
-    protected function getPivotAttributesFromCache($pivotHash, $relation)
-    {
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        $cachedRelations = $cachedAttributes[$relation];
-
-        foreach ($cachedRelations as $cachedRelation) {
-            if ($cachedRelation == $pivotHash) {
-                return $cachedRelation->getPivotAttributes();
-            }
-        }
-    }
-
-    /**
-     * Returns an array of related Aggregates from its entity hashes
-     *
-     * @param  array  $hashes
-     * @param  string $relation
-     * @return array
-     */
-    protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
-    {
-        $related = [];
-
-        foreach ($hashes as $hash) {
-            $aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
-
-            if (!is_null($aggregate)) {
-                $related[] = $aggregate;
-            }
-        }
-
-        return $related;
-    }
-
-    /**
-     * Get related aggregate from its hash
-     *
-     * @param  string $hash
-     * @param  string $relation
-     * @return \Analogue\ORM\System\Aggregate|null
-     */
-    protected function getRelatedAggregateFromHash($hash, $relation)
-    {
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if ($aggregate->getEntityHash() == $hash) {
-                return $aggregate;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Return an array of Entity Hashes from a specific relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getEntityHashesFromRelation($relation)
-    {
-        return array_map(function ($aggregate) {
-            return $aggregate->getEntityHash();
-        }, $this->relationships[$relation]);
-    }
-
-    /**
-     * Check the existence of an actual relationship
-     *
-     * @param  string $relation
-     * @return boolean
-     */
-    protected function isActualRelationships($relation)
-    {
-        return array_key_exists($relation, $this->relationships)
-            && count($this->relationships[$relation]) > 0;
-    }
-
-    /**
-     * Return cache instance for the current entity type
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getCache()
-    {
-        return $this->mapper->getEntityCache();
-    }
-
-    /**
-     * Get Only Raw Entiy's attributes which have been modified
-     * since last query
-     *
-     * @return array
-     */
-    public function getDirtyRawAttributes()
-    {
-        $attributes = $this->getRawAttributes();
-        $cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
-
-        $dirty = [];
-
-        foreach ($attributes as $key => $value) {
-            if ($this->isRelation($key) || $key == 'pivot') {
-                continue;
-            }
-
-            if (!array_key_exists($key, $cachedAttributes) && !$value instanceof Pivot) {
-                $dirty[$key] = $value;
-            } elseif ($value !== $cachedAttributes[$key] &&
-                !$this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
-                $dirty[$key] = $value;
-            }
-        }
-
-        return $dirty;
-    }
-
-    /**
-     * @param $key
-     * @return bool
-     */
-    protected function isRelation($key)
-    {
-        return in_array($key, $this->entityMap->getRelationships());
-    }
-
-    /**
-     * Determine if the new and old values for a given key are numerically equivalent.
-     *
-     * @param $current
-     * @param $original
-     * @return boolean
-     */
-    protected function originalIsNumericallyEquivalent($current, $original)
-    {
-        return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
-    }
-
-    /**
-     * Get the underlying entity object
-     *
-     * @return mixed
-     */
-    public function getEntityObject()
-    {
-        return $this->wrappedEntity->getObject();
-    }
-
-    /**
-     * Return the Mapper instance for the current Entity Type
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * Check that the entity already exists in the database, by checking
-     * if it has an EntityCache record
-     *
-     * @return boolean
-     */
-    public function exists()
-    {
-        return $this->getCache()->has($this->getEntityId());
-    }
-
-    /**
-     * Set the object attribute raw values (hydration)
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->wrappedEntity->setEntityAttributes($attributes);
-    }
-
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        return $this->wrappedEntity->getEntityAttributes();
-    }
-
-    /**
-     * Set the raw entity attributes
-     * @param string $key
-     * @param string $value
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->wrappedEntity->setEntityAttribute($key, $value);
-    }
-
-    /**
-     * Return the entity's attribute
-     * @param  string $key
-     * @return mixed
-     */
-    public function getEntityAttribute($key)
-    {
-        return $this->wrappedEntity->getEntityAttribute($key);
-    }
-
-    /**
-     * Does the attribute exists on the entity
-     *
-     * @param  string  $key
-     * @return boolean
-     */
-    public function hasAttribute($key)
-    {
-        return $this->wrappedEntity->hasAttribute($key);
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity
-     */
-    public function setProxies()
-    {
-        $this->wrappedEntity->setProxies();
-    }
+		return $attributes;
+	}
+
+	/**
+	 * Return's entity raw attributes in the state they were at last
+	 * query.
+	 *
+	 * @param  array|null $columns
+	 * @return array
+	 */
+	protected function getCachedRawAttributes(array $columns = null)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (is_null($columns)) {
+			return $cachedAttributes;
+		} else {
+			return array_only($cachedAttributes, $columns);
+		}
+	}
+
+	/**
+	 * Return a single attribute from the cache
+	 * @param  string $key
+	 * @return mixed
+	 */
+	protected function getCachedAttribute($key)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (!array_key_exists($key, $cachedAttributes)) {
+			return null;
+		} else {
+			return $cachedAttributes[$key];
+		}
+	}
+
+	/**
+	 * Convert related Entity's attributes to foreign keys
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributes()
+	{
+		$foreignKeys = [];
+
+		foreach ($this->entityMap->getLocalRelationships() as $relation) {
+			// check if relationship has been parsed, meaning it has an actual object
+			// in the entity's attributes
+			if ($this->isActualRelationships($relation)) {
+				$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
+			}
+		}
+
+		if (!is_null($this->parent)) {
+			$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromParent();
+		}
+
+		return $foreignKeys;
+	}
+
+	/**
+	 * Return an associative array containing the key-value pair(s) from
+	 * the related entity.
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromRelation($relation)
+	{
+		$localRelations = $this->entityMap->getLocalRelationships();
+
+		if (in_array($relation, $localRelations)) {
+			// Call Relationship's method
+			$relationship = $this->entityMap->$relation($this->getEntityObject());
+
+			$relatedAggregate = $this->relationships[$relation][0];
+
+			return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Get foreign key attribute(s) from a parent entity in this
+	 * aggregate context
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromParent()
+	{
+		$parentMap = $this->parent->getEntityMap();
+
+		$parentForeignRelations = $parentMap->getForeignRelationships();
+		$parentPivotRelations = $parentMap->getPivotRelationships();
+
+		$parentRelation = $this->parentRelationship;
+
+		if (in_array($parentRelation, $parentForeignRelations)
+			&& !in_array($parentRelation, $parentPivotRelations)
+		) {
+			$parentObject = $this->parent->getEntityObject();
+
+			// Call Relationship's method on parent map
+			$relationship = $parentMap->$parentRelation($parentObject);
+
+			return $relationship->getForeignKeyValuePair();
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Update Pivot records on loaded relationships, by comparing the
+	 * values from the Entity Cache to the actual relationship inside
+	 * the aggregated entity.
+	 *
+	 * @return void
+	 */
+	public function updatePivotRecords()
+	{
+		$pivots = $this->entityMap->getPivotRelationships();
+
+		foreach ($pivots as $pivot) {
+			if (array_key_exists($pivot, $this->relationships)) {
+				$this->updatePivotRelation($pivot);
+			}
+		}
+	}
+
+	/**
+	 * Update Single pivot relationship
+	 *
+	 * @param  string $relation
+	 * @return void
+	 */
+	protected function updatePivotRelation($relation)
+	{
+		$hashes = $this->getEntityHashesFromRelation($relation);
+
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		if (array_key_exists($relation, $cachedAttributes)) {
+			// Compare the two array of hashes to find out existing
+			// pivot records, and the ones to be created.
+			$new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
+			$existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
+		} else {
+			$existing = [];
+			$new = $hashes;
+		}
+
+		if (count($new) > 0) {
+			$pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
+
+			$this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
+		}
+
+		if (count($existing) > 0) {
+			foreach ($existing as $pivotHash) {
+				$this->updatePivotIfDirty($pivotHash, $relation);
+			}
+		}
+	}
+
+	/**
+	 * Compare existing pivot record in cache and update it
+	 * if the pivot attributes are dirty
+	 *
+	 * @param  string $pivotHash
+	 * @param  string $relation
+	 * @return void
+	 */
+	protected function updatePivotIfDirty($pivotHash, $relation)
+	{
+		$aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
+
+		if ($aggregate->hasAttribute('pivot')) {
+			$pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
+
+			$cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
+
+			$actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
+
+			$dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
+
+			if (count($dirty) > 0) {
+				$id = $aggregate->getEntityId();
+
+				$this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
+			}
+		}
+	}
+
+	/**
+	 * Compare two attributes array and return dirty attributes
+	 *
+	 * @param  array $actual
+	 * @param  array $cached
+	 * @return array
+	 */
+	protected function getDirtyAttributes(array $actual, array $cached)
+	{
+		$dirty = [];
+
+		foreach ($actual as $key => $value) {
+			if (!$this->originalIsNumericallyEquivalent($value, $cached[$key])) {
+				$dirty[$key] = $actual[$key];
+			}
+		}
+
+		return $dirty;
+	}
+
+	/**
+	 *
+	 * @param  string $pivotHash
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getPivotAttributesFromCache($pivotHash, $relation)
+	{
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		$cachedRelations = $cachedAttributes[$relation];
+
+		foreach ($cachedRelations as $cachedRelation) {
+			if ($cachedRelation == $pivotHash) {
+				return $cachedRelation->getPivotAttributes();
+			}
+		}
+	}
+
+	/**
+	 * Returns an array of related Aggregates from its entity hashes
+	 *
+	 * @param  array  $hashes
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
+	{
+		$related = [];
+
+		foreach ($hashes as $hash) {
+			$aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
+
+			if (!is_null($aggregate)) {
+				$related[] = $aggregate;
+			}
+		}
+
+		return $related;
+	}
+
+	/**
+	 * Get related aggregate from its hash
+	 *
+	 * @param  string $hash
+	 * @param  string $relation
+	 * @return \Analogue\ORM\System\Aggregate|null
+	 */
+	protected function getRelatedAggregateFromHash($hash, $relation)
+	{
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if ($aggregate->getEntityHash() == $hash) {
+				return $aggregate;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Return an array of Entity Hashes from a specific relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getEntityHashesFromRelation($relation)
+	{
+		return array_map(function ($aggregate) {
+			return $aggregate->getEntityHash();
+		}, $this->relationships[$relation]);
+	}
+
+	/**
+	 * Check the existence of an actual relationship
+	 *
+	 * @param  string $relation
+	 * @return boolean
+	 */
+	protected function isActualRelationships($relation)
+	{
+		return array_key_exists($relation, $this->relationships)
+			&& count($this->relationships[$relation]) > 0;
+	}
+
+	/**
+	 * Return cache instance for the current entity type
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getCache()
+	{
+		return $this->mapper->getEntityCache();
+	}
+
+	/**
+	 * Get Only Raw Entiy's attributes which have been modified
+	 * since last query
+	 *
+	 * @return array
+	 */
+	public function getDirtyRawAttributes()
+	{
+		$attributes = $this->getRawAttributes();
+		$cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
+
+		$dirty = [];
+
+		foreach ($attributes as $key => $value) {
+			if ($this->isRelation($key) || $key == 'pivot') {
+				continue;
+			}
+
+			if (!array_key_exists($key, $cachedAttributes) && !$value instanceof Pivot) {
+				$dirty[$key] = $value;
+			} elseif ($value !== $cachedAttributes[$key] &&
+				!$this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
+				$dirty[$key] = $value;
+			}
+		}
+
+		return $dirty;
+	}
+
+	/**
+	 * @param $key
+	 * @return bool
+	 */
+	protected function isRelation($key)
+	{
+		return in_array($key, $this->entityMap->getRelationships());
+	}
+
+	/**
+	 * Determine if the new and old values for a given key are numerically equivalent.
+	 *
+	 * @param $current
+	 * @param $original
+	 * @return boolean
+	 */
+	protected function originalIsNumericallyEquivalent($current, $original)
+	{
+		return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
+	}
+
+	/**
+	 * Get the underlying entity object
+	 *
+	 * @return mixed
+	 */
+	public function getEntityObject()
+	{
+		return $this->wrappedEntity->getObject();
+	}
+
+	/**
+	 * Return the Mapper instance for the current Entity Type
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return $this->mapper;
+	}
+
+	/**
+	 * Check that the entity already exists in the database, by checking
+	 * if it has an EntityCache record
+	 *
+	 * @return boolean
+	 */
+	public function exists()
+	{
+		return $this->getCache()->has($this->getEntityId());
+	}
+
+	/**
+	 * Set the object attribute raw values (hydration)
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->wrappedEntity->setEntityAttributes($attributes);
+	}
+
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		return $this->wrappedEntity->getEntityAttributes();
+	}
+
+	/**
+	 * Set the raw entity attributes
+	 * @param string $key
+	 * @param string $value
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->wrappedEntity->setEntityAttribute($key, $value);
+	}
+
+	/**
+	 * Return the entity's attribute
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function getEntityAttribute($key)
+	{
+		return $this->wrappedEntity->getEntityAttribute($key);
+	}
+
+	/**
+	 * Does the attribute exists on the entity
+	 *
+	 * @param  string  $key
+	 * @return boolean
+	 */
+	public function hasAttribute($key)
+	{
+		return $this->wrappedEntity->hasAttribute($key);
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity
+	 */
+	public function setProxies()
+	{
+		$this->wrappedEntity->setProxies();
+	}
 }