Merge branch 'master' of kla/php-activerecord

gains eager loading (for real this time)

lib/php-activerecord/lib/Model.php

···
 	}
 
 	/**
+	 * Add a model to the given named ($name) relationship.
+	 *
+	 * @internal This should <strong>only</strong> be used by eager load
+	 * @param Model $model
+	 * @param $name of relationship for this table
+	 * @return void
+	 */
+	public function set_relationship_from_eager_load(Model $model=null, $name)
+	{
+		$table = static::table();
+
+		if (($rel = $table->get_relationship($name)))
+		{
+			if ($rel->is_poly())
+			{
+				// if the related model is null and it is a poly then we should have an empty array
+				if (is_null($model))
+					return $this->__relationships[$name] = array();
+				else
+					return $this->__relationships[$name][] = $model;
+			}
+			else
+				return $this->__relationships[$name] = $model;
+		}
+
+		throw new RelationshipException("Relationship named $name has not been declared for class: {$table->class->getName()}");
+	}
+
+	/**
 	 * Reloads the attributes and relationships of this object from the database.
 	 *
 	 * @return Model
···
 		$this->set_attributes($this->find($pk)->attributes);
 		$this->reset_dirty();
 
+		return $this;
+	}
+
+	public function __clone()
+	{
+		$this->__relationships = array();
+		$this->reset_dirty();
 		return $this;
 	}
 

lib/php-activerecord/lib/Relationship.php

···
 	}
 
 	/**
+	 * What is this relationship's cardinality?
+	 *
+	 * @return bool
+	 */
+	public function is_poly()
+	{
+		return $this->poly_relationship;
+	}
+
+	/**
+	 * Eagerly loads relationships for $models.
+	 *
+	 * This method takes an array of models, collects PK or FK (whichever is needed for relationship), then queries
+	 * the related table by PK/FK and attaches the array of returned relationships to the appropriately named relationship on
+	 * $models.
+	 *
+	 * @param Table $table
+	 * @param $models array of model objects
+	 * @param $attributes array of attributes from $models
+	 * @param $includes array of eager load directives
+	 * @param $query_keys -> key(s) to be queried for on included/related table
+	 * @param $model_values_keys -> key(s)/value(s) to be used in query from model which is including
+	 * @return void
+	 */
+	protected function query_and_attach_related_models_eagerly(Table $table, $models, $attributes, $includes=array(), $query_keys=array(), $model_values_keys=array())
+	{
+		$values = array();
+		$options = array();
+		$query_key = $query_keys[0];
+		$model_values_key = $model_values_keys[0];
+
+		foreach ($attributes as $column => $value)
+			$values[] = $value[$model_values_key];
+
+		$values = array($values);
+		$options['conditions'] = SQLBuilder::create_conditions_from_underscored_string($table->conn,$query_key,$values);
+
+		if (!empty($includes))
+			$options['include'] = $includes;
+
+		$class = $this->class_name;
+
+		$related_models = $class::find('all', $options);
+		$used_models = array();
+
+		foreach ($models as $model)
+		{
+			$matches = 0;
+			$key_to_match = $model->$model_values_key;
+
+			foreach ($related_models as $related)
+			{
+				if ($related->$query_key == $key_to_match)
+				{
+					$hash = spl_object_hash($related);
+
+					if (in_array($hash, $used_models))
+						$model->set_relationship_from_eager_load(clone($related), $this->attribute_name);
+					else
+						$model->set_relationship_from_eager_load($related, $this->attribute_name);
+
+					$used_models[] = $hash;
+					$matches++;
+				}
+			}
+
+			if (0 === $matches)
+				$model->set_relationship_from_eager_load(null, $this->attribute_name);
+		}
+	}
+
+	/**
 	 * Creates a new instance of specified {@link Model} with the attributes pre-loaded.
 	 *
 	 * @param Model $model The model which holds this association
···
 		$attributes = $this->inject_foreign_key_for_new_association($model, $attributes);
 		return parent::create_association($model, $attributes);
 	}
+
+	public function load_eagerly($models=array(), $attributes=array(), $includes, Table $table)
+	{
+		$this->set_keys($table->class->name);
+		$this->query_and_attach_related_models_eagerly($table,$models,$attributes,$includes,$this->foreign_key, $table->pk);
+	}
 };
 
 /**
···
 		$options['conditions'] = $conditions;
 		$class = $this->class_name;
 		return $class::first($options);
+	}
+
+	public function load_eagerly($models=array(), $attributes, $includes, Table $table)
+	{
+		$this->query_and_attach_related_models_eagerly($table,$models,$attributes,$includes, $this->primary_key,$this->foreign_key);
 	}
 };
 ?>

lib/php-activerecord/lib/Table.php

···
 	{
 		$sql = $this->options_to_sql($options);
 		$readonly = (array_key_exists('readonly',$options) && $options['readonly']) ? true : false;
-		return $this->find_by_sql($sql->to_s(),$sql->get_where_values(), $readonly);
+		$eager_load = array_key_exists('include',$options) ? $options['include'] : null;
+
+		return $this->find_by_sql($sql->to_s(),$sql->get_where_values(), $readonly, $eager_load);
 	}
 
-	public function find_by_sql($sql, $values=null, $readonly=false)
+	public function find_by_sql($sql, $values=null, $readonly=false, $includes=null)
 	{
 		$this->last_sql = $sql;
 
-		$list = array();
+		$collect_attrs_for_includes = is_null($includes) ? false : true;
+		$list = $attrs = array();
+
 		$sth = $this->conn->query($sql,$values);
 
 		while (($row = $sth->fetch()))
···
 			if ($readonly)
 				$model->readonly();
 
+			if ($collect_attrs_for_includes)
+				$attrs[] = $model->attributes();
+
 			$list[] = $model;
 		}
+
+		if ($collect_attrs_for_includes)
+			$this->execute_eager_load($list, $attrs, $includes);
+
 		return $list;
 	}
 
+	/**
+	 * Executes an eager load of a given named relationship for this table.
+	 *
+	 * @param $models array found modesl for this table
+	 * @param $attrs array of attrs from $models
+	 * @param $includes array eager load directives
+	 * @return void
+	 */
+	private function execute_eager_load($models=array(), $attrs=array(), $includes=array())
+	{
+		if (!is_array($includes))
+			$includes = array($includes);
+
+		foreach ($includes as $index => $name)
+		{
+			// nested include
+			if (is_array($name))
+			{
+				$nested_includes = count($name) > 1 ? $name : $name[0];
+				$name = $index;
+			}
+			else
+				$nested_includes = array();
+
+			$rel = $this->get_relationship($name, true);
+			$rel->load_eagerly($models, $attrs, $nested_includes, $this);
+		}
+	}
+
 	public function get_column_by_inflected_name($inflected_name)
 	{
 		foreach ($this->columns as $raw_name => $column)
···
 		return $table;
 	}
 
-	public function get_relationship($name)
+	/**
+	 * Retrieve a relationship object for this table. Strict as true will throw an error
+	 * if the relationship name does not exist.
+	 *
+	 * @param $name string name of Relationship
+	 * @param $strict bool
+	 * @throws RelationshipException
+	 * @return Relationship or null
+	 */
+	public function get_relationship($name, $strict=false)
 	{
-		if (isset($this->relationships[$name]))
+		if ($this->has_relationship($name))
 			return $this->relationships[$name];
+
+		if ($strict)
+			throw new RelationshipException("Relationship named $name has not been declared for class: {$this->class->getName()}");
+
+		return null;
+	}
+
+	/**
+	 * Does a given relationship exist?
+	 *
+	 * @param $name string name of Relationship
+	 * @return bool
+	 */
+	public function has_relationship($name)
+	{
+		return array_key_exists($name, $this->relationships);
 	}
 
 	public function insert(&$data)

lib/php-activerecord/test/RelationshipTest.php

···
 	{
 		AuthorWithNonModelRelationship::first()->books;
 	}
+
+	public function test_eager_loading_has_many()
+	{
+		$venues = Venue::find(array(2, 6), array('include' => 'events'));
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Event')->last_sql, 'WHERE `venue_id` IN(?,?)') !== false);
+
+		foreach ($venues[0]->events as $event)
+			$this->assert_equals($event->venue_id, $venues[0]->id);
+
+		$this->assert_equals(2, count($venues[0]->events));
+	}
+
+	public function test_eager_loading_has_many_with_no_related_rows()
+	{
+		$venues = Venue::find(array(7, 8), array('include' => 'events'));
+
+		foreach ($venues as $v)
+			$this->assert_true(empty($v->events));
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Venue')->last_sql, 'WHERE `id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Event')->last_sql, 'WHERE `venue_id` IN(?,?)') !== false);
+	}
+
+	public function test_eager_loading_has_many_array_of_includes()
+	{
+		Author::$has_many = array(array('books'), array('awesome_people'));
+		$authors = Author::find(array(1,2), array('include' => array('books', 'awesome_people')));
+
+		$assocs = array('books', 'awesome_people');
+
+		foreach ($assocs as $assoc)
+		{
+			$this->assert_type('array', $authors[0]->$assoc);
+
+			foreach ($authors[0]->$assoc as $a)
+				$this->assert_equals($authors[0]->author_id,$a->author_id);
+		}
+
+		foreach ($assocs as $assoc)
+		{
+			$this->assert_type('array', $authors[1]->$assoc);
+			$this->assert_true(empty($authors[1]->$assoc));
+		}
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Author')->last_sql, 'WHERE `author_id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Book')->last_sql, 'WHERE `author_id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('AwesomePerson')->last_sql, 'WHERE `author_id` IN(?,?)') !== false);
+	}
+
+	public function test_eager_loading_has_many_nested()
+	{
+		$venues = Venue::find(array(1,2), array('include' => array('events' => array('host'))));
+
+		$this->assert_equals(2, count($venues));
+
+		foreach ($venues as $v)
+		{
+			$this->assert_true(count($v->events) > 0);
+
+			foreach ($v->events as $e)
+			{
+				$this->assert_equals($e->host_id, $e->host->id);
+				$this->assert_equals($v->id, $e->venue_id);
+			}
+		}
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Venue')->last_sql, 'WHERE `id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Event')->last_sql, 'WHERE `venue_id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Host')->last_sql, 'WHERE `id` IN(?,?,?)') !== false);
+	}
+
+	public function test_eager_loading_belongs_to()
+	{
+		$events = Event::find(array(1,2,3,5,7), array('include' => 'venue'));
+
+		foreach ($events as $event)
+			$this->assert_equals($event->venue_id, $event->venue->id);
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Venue')->last_sql, 'WHERE `id` IN(?,?,?,?,?)') !== false);
+	}
+
+	public function test_eager_loading_belongs_to_array_of_includes()
+	{
+		$events = Event::find(array(1,2,3,5,7), array('include' => array('venue', 'host')));
+
+		foreach ($events as $event)
+		{
+			$this->assert_equals($event->venue_id, $event->venue->id);
+			$this->assert_equals($event->host_id, $event->host->id);
+		}
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Event')->last_sql, 'WHERE `id` IN(?,?,?,?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Host')->last_sql, 'WHERE `id` IN(?,?,?,?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Venue')->last_sql, 'WHERE `id` IN(?,?,?,?,?)') !== false);
+	}
+
+	public function test_eager_loading_belongs_to_nested()
+	{
+		Author::$has_many = array(array('awesome_people'));
+
+		$books = Book::find(array(1,2), array('include' => array('author' => array('awesome_people'))));
+
+		$assocs = array('author', 'awesome_people');
+
+		foreach ($books as $book)
+		{
+			$this->assert_equals($book->author_id,$book->author->author_id);
+			$this->assert_equals($book->author->author_id,$book->author->awesome_people[0]->author_id);
+		}
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Book')->last_sql, 'WHERE `book_id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Author')->last_sql, 'WHERE `author_id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('AwesomePerson')->last_sql, 'WHERE `author_id` IN(?,?)') !== false);
+	}
+
+	public function test_eager_loading_belongs_to_with_no_related_rows()
+	{
+		$e1 = Event::create(array('venue_id' => 200, 'host_id' => 200, 'title' => 'blah','type' => 'Music'));
+		$e2 = Event::create(array('venue_id' => 200, 'host_id' => 200, 'title' => 'blah2','type' => 'Music'));
+
+		$events = Event::find(array($e1->id, $e2->id), array('include' => 'venue'));
+
+		foreach ($events as $e)
+			$this->assert_null($e->venue);
+
+		$this->assert_true(strpos(ActiveRecord\Table::load('Event')->last_sql, 'WHERE `id` IN(?,?)') !== false);
+		$this->assert_true(strpos(ActiveRecord\Table::load('Venue')->last_sql, 'WHERE `id` IN(?,?)') !== false);
+	}
+
+	public function test_eager_loading_clones_related_objects()
+	{
+		$events = Event::find(array(2,3), array('include' => array('venue')));
+
+		$venue = $events[0]->venue;
+		$venue->name = "new name";
+
+		$this->assert_equals($venue->id, $events[1]->venue->id);
+		$this->assert_not_equals($venue->name, $events[1]->venue->name);
+		$this->assert_not_equals(spl_object_hash($venue), spl_object_hash($events[1]->venue));
+	}
+
+	public function test_eager_loading_clones_nested_related_objects()
+	{
+		$venues = Venue::find(array(1,2,6,9), array('include' => array('events' => array('host'))));
+
+		$unchanged_host = $venues[2]->events[0]->host;
+		$changed_host = $venues[3]->events[0]->host;
+		$changed_host->name = "changed";
+
+		$this->assert_equals($changed_host->id, $unchanged_host->id);
+		$this->assert_not_equals($changed_host->name, $unchanged_host->name);
+		$this->assert_not_equals(spl_object_hash($changed_host), spl_object_hash($unchanged_host));
+	}
 };
 ?>

lib/php-activerecord/test/fixtures/awesome_people.csv

···
 id,author_id
-1,1
+1,1
+2,2
+3,3

lib/php-activerecord/test/fixtures/books.csv

···
 book_id,author_id,secondary_author_id,name,special
-1,1,2,"Ancient Art of Main Tanking",0
+1,1,2,"Ancient Art of Main Tanking",0
+2,2,2,"Another Book",0

lib/php-activerecord/test/models/Author.php

···
 {
 	static $pk = 'author_id';
 	static $has_one = array(array('awesome_person', 'foreign_key' => 'author_id', 'primary_key' => 'author_id'));
+	static $has_many;
 	static $belongs_to = array();
 	static $setters = array('password');