Query parser refactoring

Doctrine.php

@@ -246,6 +246,7 @@ final class Doctrine {
                 case "Sensei":
                 case "Iterator":
                 case "View":
+                case "Query":
                     $a[]  = $path.DIRECTORY_SEPARATOR.$entry;
                 break;
                 default:

Doctrine/Cache/Query/Sqlite.php

@@ -5,7 +5,7 @@ class Doctrine_Cache_Query_Sqlite implements Countable {
      */
     const CACHE_TABLE = 'doctrine_query_cache';
     /**
-     * @var Doctrine_Table $table       the table object this cache container belongs to
+     * @var Doctrine_Session $session       the table object this cache container belongs to
      */
     private $table;
     /**
@@ -21,19 +21,19 @@ class Doctrine_Cache_Query_Sqlite implements Countable {
      * 
      * Doctrine_Table $table
      */
-    public function __construct(Doctrine_Table $table) {
-        $this->table = $table;
-        $dir = $this->table->getSession()->getAttribute(Doctrine::ATTR_CACHE_DIR);
+    public function __construct(Doctrine_Session $session) {
+        $this->session = $session;
+        $dir = $session->getAttribute(Doctrine::ATTR_CACHE_DIR);
 
         if( ! is_dir($dir))
             mkdir($dir, 0777);
 
         $this->path = $dir.DIRECTORY_SEPARATOR;
-        $this->dbh  = $this->table->getSession()->getCacheHandler();
         $this->dbh  = new PDO("sqlite::memory:");
 
+
         try {
-            if($this->table->getAttribute(Doctrine::ATTR_CREATE_TABLES) === true)
+            if($this->session->getAttribute(Doctrine::ATTR_CREATE_TABLES) === true)
             {
                 $columns = array();
                 $columns['query_md5']       = array('string', 32, 'notnull');

Doctrine/Lib.php

@@ -131,7 +131,9 @@ class Doctrine_Lib {
         $l = str_replace("SELECT","<font color='$color'><b>SELECT</b></font><br \>  ",$l);
         $l = str_replace("FROM","<font color='$color'><b>FROM</b></font><br \>",$l);
         $l = str_replace("LEFT JOIN","<br \><font color='$color'><b>LEFT JOIN</b></font>",$l);
-        $l = str_replace("WHERE","<font color='$color'><b>WHERE</b></font>",$l);
+        $l = str_replace("WHERE","<br \><font color='$color'><b>WHERE</b></font>",$l);
+        $l = str_replace("GROUP BY","<br \><font color='$color'><b>GROUP BY</b></font>",$l);
+        $l = str_replace("HAVING","<br \><font color='$color'><b>HAVING</b></font>",$l);
         $l = str_replace("AS","<font color='$color'><b>AS</b></font><br \>  ",$l);
         $l = str_replace("ON","<font color='$color'><b>ON</b></font>",$l);
         $l = str_replace("ORDER BY","<font color='$color'><b>ORDER BY</b></font><br \>",$l);

Doctrine/Query/Condition.php

+<?php
+require_once("Part.php");
+
+abstract class Doctrine_Query_Condition extends Doctrine_Query_Part {
+    /**
+     * DQL CONDITION PARSER
+     * parses the where/having part of the query string
+     *
+     *
+     * @param string $str
+     * @return string
+     */
+    final public function parse($str) {
+
+        $tmp = trim($str);
+        $str = Doctrine_Query::bracketTrim($tmp,"(",")");
+        
+        $brackets = false;
+
+        while($tmp != $str) {
+            $brackets = true;
+            $tmp = $str;
+            $str = Doctrine_Query::bracketTrim($str,"(",")");
+        }
+
+        $parts = Doctrine_Query::bracketExplode($str," && ","(",")");
+        if(count($parts) > 1) {
+            $ret = array();
+            foreach($parts as $part) {
+                $ret[] = $this->parse($part, $type);
+            }
+            $r = implode(" AND ",$ret);
+        } else {
+            $parts = Doctrine_Query::bracketExplode($str," || ","(",")");
+            if(count($parts) > 1) {
+                $ret = array();
+                foreach($parts as $part) {
+                    $ret[] = $this->parse($part);
+                }
+                $r = implode(" OR ",$ret);
+            } else {
+                return $this->load($parts[0]);
+            }
+        }
+        if($brackets)
+            return "(".$r.")";
+        else
+            return $r;
+    }
+}
+?>

Doctrine/Query/From.php

+<?php
+require_once("Part.php");
+
+class Doctrine_Query_From extends Doctrine_Query_Part {
+
+    /**
+     * DQL FROM PARSER
+     * parses the from part of the query string
+
+     * @param string $str
+     * @return void
+     */
+    final public function parse($str) {
+        foreach(Doctrine_Query::bracketExplode(trim($str),",", "(",")") as $reference) {
+            $reference = trim($reference);
+            $a         = explode(".",$reference);
+            $field     = array_pop($a);
+            $table     = $this->query->load($reference);
+        }
+    }
+
+    public function __toString() {
+        return ( ! empty($this->parts))?implode(", ", $this->parts):'';
+    }
+}
+?>

Doctrine/Query/Groupby.php

+<?php 
+require_once("Part.php");
+
+class Doctrine_Query_Groupby extends Doctrine_Query_Part {
+    /**
+     * DQL GROUP BY PARSER
+     * parses the group by part of the query string
+
+     * @param string $str
+     * @return void
+     */
+    final public function parse($str) {
+        $r = array();
+        foreach(explode(",", $str) as $reference) {
+            $reference = trim($reference);
+            $e     = explode(".",$reference);
+            $field = array_pop($e);
+            $ref   = implode(".", $e);
+            $table = $this->query->load($ref);
+            $component = $table->getComponentName();
+            $r[] = $this->query->getTableAlias($ref).".".$field;
+        }
+        return implode(", ", $r);
+    }
+
+    public function __toString() {
+        return ( ! empty($this->parts))?implode(", ", $this->parts):'';
+    }
+}
+?>

Doctrine/Query/Having.php

+<?php
+require_once("Condition.php");
+
+class Doctrine_Query_Having extends Doctrine_Query_Condition {
+    /**
+     * DQL Aggregate Function parser
+     *
+     * @param string $func
+     * @return mixed
+     */
+    private function parseAggregateFunction($func) {
+        $pos = strpos($func,"(");
+
+        if($pos !== false) {
+
+            $funcs  = array();
+
+            $name   = substr($func, 0, $pos);
+            $func   = substr($func, ($pos + 1), -1);
+            $params = Doctrine_Query::bracketExplode($func, ",", "(", ")");
+
+            foreach($params as $k => $param) {
+                $params[$k] = $this->parseAggregateFunction($param);
+            }
+
+            $funcs = $name."(".implode(", ", $params).")";
+
+            return $funcs;
+
+        } else {
+            if( ! is_numeric($func)) {
+                $a = explode(".",$func);
+                $field     = array_pop($a);
+                $reference = implode(".",$a);
+                $table     = $this->query->load($reference, false);
+                $func      = $this->query->getTableAlias($reference).".".$field;
+
+                return $func;
+            } else {
+                return $func;
+            }
+        }
+    }
+    /**
+     * load
+     * returns the parsed query part
+     *
+     * @param string $having
+     * @return string
+     */
+    final public function load($having) {
+        $e = Doctrine_Query::bracketExplode($having," ","(",")");
+
+        $r = array_shift($e);
+        $t = explode("(",$r);
+
+        $count = count($t);
+        $r = $this->parseAggregateFunction($r);
+        $operator  = array_shift($e);
+        $value     = implode(" ",$e);
+        $r .= " ".$operator." ".$value;
+
+        return $r;
+    }
+    /**
+     * __toString
+     *
+     * @return string
+     */
+    public function __toString() {
+        return ( ! empty($this->parts))?implode(" AND ", $this->parts):'';
+    }
+}
+?>

Doctrine/Query/Orderby.php

+<?php
+require_once("Part.php");
+
+class Doctrine_Query_Orderby extends Doctrine_Query_Part {
+    /**
+     * DQL ORDER BY PARSER
+     * parses the order by part of the query string
+     *
+     * @param string $str
+     * @return void
+     */
+    final public function parse($str) {
+        $ret = array();
+
+        foreach(explode(",",trim($str)) as $r) {
+            $r = trim($r);
+            $e = explode(" ",$r);
+            $a = explode(".",$e[0]);
+    
+            if(count($a) > 1) {
+                $field     = array_pop($a);
+                $reference = implode(".",$a);
+                $name      = end($a);
+
+                $this->query->load($reference, false);
+                $alias     = $this->query->getTableAlias($reference);
+                $tname     = $this->query->getTable($alias)->getTableName();
+
+                $r = $tname.".".$field;
+                if(isset($e[1])) 
+                    $r .= " ".$e[1];
+            }
+            $ret[] = $r;
+        }
+        return implode(", ", $ret);
+    }
+    public function __toString() {
+        return ( ! empty($this->parts))?implode(", ", $this->parts):'';
+    }
+}
+?>

Doctrine/Query/Part.php

+<?php
+Doctrine::autoload("Doctrine_Access");
+
+abstract class Doctrine_Query_Part extends Doctrine_Access {
+    
+    protected $query;
+    
+    protected $name;
+    
+    protected $parts = array();
+
+    public function __construct(Doctrine_Query $query) {
+        $this->query = $query;
+
+    }
+    
+    public function getName() {
+        return $this->name;
+    }
+
+    public function getQuery() {
+        return $this->query;
+    }
+    /** 
+     * add
+     * 
+     * @param string $value
+     * @return void
+     */
+    public function add($value) {
+        $method = "parse".$this->name;
+        $this->query->$method($value);
+    }
+
+    public function get($name) { }
+    public function set($name, $value) { }
+}
+
+
+?>

Doctrine/Query/Where.php

+<?php
+require_once("Condition.php");
+
+class Doctrine_Query_Where extends Doctrine_Query_Condition {
+    /**
+     * loadWhere
+     * returns the parsed query part
+     *
+     * @param string $where
+     * @return string
+     */
+    final public function load($where) {
+        $e = explode(" ",$where);
+        $r = array_shift($e);
+        $a = explode(".",$r);
+
+
+        if(count($a) > 1) {
+            $field     = array_pop($a);
+            $operator  = array_shift($e);
+            $value     = implode(" ",$e);
+            $reference = implode(".",$a);
+            $count     = count($a);
+
+            $table     = $this->query->load($reference, false);
+            $where     = $this->query->getTableAlias($reference).".".$field." ".$operator." ".$value;
+        }
+        return $where;
+    }
+
+    public function __toString() {
+        return ( ! empty($this->parts))?implode(" AND ", $this->parts):'';
+    }
+}
+?>

Doctrine/Record.php

@@ -173,7 +173,8 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
                 $this->table->getAttribute(Doctrine::ATTR_LISTENER)->onLoad($this);
             }
 
-            $this->table->getRepository()->add($this);
+            $repository = $this->table->getRepository();
+            $repository->add($this);
         }
     }
     /**

Doctrine/Session.php

@@ -39,11 +39,6 @@ abstract class Doctrine_Session extends Doctrine_Configurable implements Countab
      * @var integer $transaction_level      the nesting level of transactions, used by transaction methods
      */
     private $transaction_level  = 0;
-
-    /**
-     * @var PDO $cacheHandler               cache handler
-     */
-    private $cacheHandler;
     /**
      * @var array $tables                   an array containing all the initialized Doctrine_Table objects
      *                                      keys representing Doctrine_Table component names and values as Doctrine_Table objects
@@ -87,23 +82,8 @@ abstract class Doctrine_Session extends Doctrine_Configurable implements Countab
         $this->dbh->setAttribute(PDO::ATTR_CASE, PDO::CASE_NATURAL);
         $this->dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);   
 
-        switch($this->getAttribute(Doctrine::ATTR_CACHE)):
-            case Doctrine::CACHE_SQLITE:
-                $dir = $this->getAttribute(Doctrine::ATTR_CACHE_DIR).DIRECTORY_SEPARATOR;
-                $dsn = "sqlite:".$dir."data.cache";
-
-                $this->cacheHandler = Doctrine_DB::getConn($dsn);
-                $this->cacheHandler->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-                $this->cacheHandler->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
-            break;
-        endswitch;
-
         $this->getAttribute(Doctrine::ATTR_LISTENER)->onOpen($this);
     }
-
-    public function getCacheHandler() {
-        return $this->cacheHandler;
-    }
     /**
      * returns the state of this session
      *

tests/CacheQuerySqliteTestCase.php

@@ -10,7 +10,7 @@ class Doctrine_Cache_Query_SqliteTestCase extends Doctrine_UnitTestCase {
         if(file_exists($dir.DIRECTORY_SEPARATOR."stats.cache"))
             unlink($dir.DIRECTORY_SEPARATOR."stats.cache");
 
-        $this->cache = new Doctrine_Cache_Query_Sqlite($this->objTable);
+        $this->cache = new Doctrine_Cache_Query_Sqlite($this->session);
         $this->cache->deleteAll();
     }
     public function testStore() {

tests/QueryTestCase.php

@@ -24,6 +24,16 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         parent::prepareTables();
 
     }
+    /**
+    public function testQueryPart() {
+        $this->query->from[] = "User.Phonenumber";
+        $this->query->from[] = "User.Email";
+
+        $users = $this->query->execute();
+
+        $this->assertEqual($users->count(), 8);
+    }
+    */
 
     public function testSelfReferencing() {
         $query = new Doctrine_Query($this->session);
@@ -191,8 +201,6 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $query->having("COUNT(User.Phonenumber.phonenumber) > 2");
         $query->groupby('User.id');
         
-        //print Doctrine_Lib::formatSql($query->getQuery());
-        
         $users = $query->execute();
 
         $this->assertEqual($users->count(), 3);
@@ -220,6 +228,20 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $users[2]->Phonenumber[1];
         $this->assertEqual(++$count, $this->dbh->count());
         $this->assertEqual($users[2]->Phonenumber->count(), 3);
+
+        $this->session->clear();
+        $query->from('User-l.Phonenumber-l');
+        $query->having("COUNT(User.Phonenumber.phonenumber) > 2");
+        $query->groupby('User.id');
+
+        $users = $this->session->query("FROM User-l.Phonenumber-l GROUP BY User.id HAVING COUNT(User.Phonenumber.phonenumber) > 2");
+
+        $this->assertEqual($users->count(), 3);
+        
+        // test that users are in right order
+        $this->assertEqual($users[0]->id, 5);
+        $this->assertEqual($users[1]->id, 8);
+        $this->assertEqual($users[2]->id, 10);
     }
 
     public function testManyToManyFetchingWithColumnAggregationInheritance() {
@@ -257,7 +279,7 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $users = $query->query("FROM User-b WHERE User.Group.name = 'Action Actors'");
 
         $this->assertEqual(trim($query->getQuery()),
-        "SELECT entity.id AS entity__id FROM entity LEFT JOIN groupuser ON entity.id = groupuser.user_id LEFT JOIN entity AS entity2 ON entity2.id = groupuser.group_id WHERE (entity2.name = 'Action Actors') AND (entity.type = 0 AND (entity2.type = 1 OR entity2.type IS NULL))");
+        "SELECT entity.id AS entity__id FROM entity LEFT JOIN groupuser ON entity.id = groupuser.user_id LEFT JOIN entity AS entity2 ON entity2.id = groupuser.group_id WHERE entity2.name = 'Action Actors' AND (entity.type = 0 AND (entity2.type = 1 OR entity2.type IS NULL))");
         $this->assertTrue($users instanceof Doctrine_Collection);
         $this->assertEqual($users->count(),1);
 
@@ -266,7 +288,7 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $users = $query->query("FROM User-b WHERE User.Group.Phonenumber.phonenumber LIKE '123 123'");
 
         $this->assertEqual(trim($query->getQuery()),
-        "SELECT entity.id AS entity__id FROM entity LEFT JOIN groupuser ON entity.id = groupuser.user_id LEFT JOIN entity AS entity2 ON entity2.id = groupuser.group_id LEFT JOIN phonenumber ON entity2.id = phonenumber.entity_id WHERE (phonenumber.phonenumber LIKE '123 123') AND (entity.type = 0 AND (entity2.type = 1 OR entity2.type IS NULL))");
+        "SELECT entity.id AS entity__id FROM entity LEFT JOIN groupuser ON entity.id = groupuser.user_id LEFT JOIN entity AS entity2 ON entity2.id = groupuser.group_id LEFT JOIN phonenumber ON entity2.id = phonenumber.entity_id WHERE phonenumber.phonenumber LIKE '123 123' AND (entity.type = 0 AND (entity2.type = 1 OR entity2.type IS NULL))");
         $this->assertTrue($users instanceof Doctrine_Collection);
         $this->assertEqual($users->count(),1);
 
@@ -975,7 +997,7 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
 
     }
 
-    public function testQuery() {
+    public function testAlbumManager() {
 
         $query = new Doctrine_Query($this->session);
 
@@ -1012,10 +1034,11 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $this->assertEqual(count($user->Album[1]->Song), 4);
 
         $users = $query->query("FROM User WHERE User.Album.name like '%Damage%'");
+    }
 
-
-
+    function testQuery() {
         // DYNAMIC COLLECTION EXPANDING
+        $query = new Doctrine_Query($this->session);
 
         $user = $this->objTable->find(5);
         $user->Group[1]->name = "Tough guys inc.";
@@ -1043,7 +1066,7 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
 
         $users = $query->query("FROM User-b.Phonenumber-l WHERE User.Phonenumber.phonenumber LIKE '%123%'");
         $this->assertEqual(trim($query->getQuery()),
-        "SELECT entity.id AS entity__id, phonenumber.id AS phonenumber__id FROM entity LEFT JOIN phonenumber ON entity.id = phonenumber.entity_id WHERE (phonenumber.phonenumber LIKE '%123%') AND (entity.type = 0)");
+        "SELECT entity.id AS entity__id, phonenumber.id AS phonenumber__id FROM entity LEFT JOIN phonenumber ON entity.id = phonenumber.entity_id WHERE phonenumber.phonenumber LIKE '%123%' AND (entity.type = 0)");
 
         $count = $this->session->getDBH()->count();
 
@@ -1110,17 +1133,17 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         $users = $query->query("FROM Email-b WHERE Email.address LIKE '%@example%'");
 
         $this->assertEqual($query->getQuery(),
-        "SELECT email.id AS email__id FROM email WHERE (email.address LIKE '%@example%')");
+        "SELECT email.id AS email__id FROM email WHERE email.address LIKE '%@example%'");
         $this->assertEqual($users->count(),8);
 
         $users = $query->query("FROM User-b WHERE User.name LIKE '%Jack%'");
-        $this->assertEqual($query->getQuery(), "SELECT entity.id AS entity__id FROM entity WHERE (entity.name LIKE '%Jack%') AND (entity.type = 0)");
+        $this->assertEqual($query->getQuery(), "SELECT entity.id AS entity__id FROM entity WHERE entity.name LIKE '%Jack%' AND (entity.type = 0)");
         $this->assertEqual($users->count(),0);
 
 
         $users = $query->query("FROM User-b WHERE User.Phonenumber.phonenumber LIKE '%123%'");
         $this->assertEqual(trim($query->getQuery()),
-        "SELECT entity.id AS entity__id FROM entity LEFT JOIN phonenumber ON entity.id = phonenumber.entity_id WHERE (phonenumber.phonenumber LIKE '%123%') AND (entity.type = 0)");
+        "SELECT entity.id AS entity__id FROM entity LEFT JOIN phonenumber ON entity.id = phonenumber.entity_id WHERE phonenumber.phonenumber LIKE '%123%' AND (entity.type = 0)");
         $this->assertEqual($users->count(),5);
 
 
@@ -1131,6 +1154,5 @@ class Doctrine_QueryTestCase extends Doctrine_UnitTestCase {
         //$this->assertTrue(isset($values['max']));
 
     }
-
 }
 ?>

tests/RecordTestCase.php

@@ -6,6 +6,87 @@ class Doctrine_RecordTestCase extends Doctrine_UnitTestCase {
         $this->tables[] = "enumTest";
         parent::prepareTables();
     }
+
+    public function testJoinTableSelfReferencing() {
+        $e = new Entity();
+        $e->name = "Entity test";
+        $this->assertTrue($e->Entity[0] instanceof Entity);
+        $this->assertTrue($e->Entity[1] instanceof Entity);
+
+        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TCLEAN);
+        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TCLEAN);
+        
+        $e->Entity[0]->name = "Friend 1";
+        $e->Entity[1]->name = "Friend 2";
+        
+        $e->Entity[0]->Entity[0]->name = "Friend 1 1";
+        $e->Entity[0]->Entity[1]->name = "Friend 1 2";
+
+        $e->Entity[1]->Entity[0]->name = "Friend 2 1";
+        $e->Entity[1]->Entity[1]->name = "Friend 2 2";
+
+        $this->assertEqual($e->Entity[0]->name, "Friend 1");
+        $this->assertEqual($e->Entity[1]->name, "Friend 2");
+
+        $this->assertEqual($e->Entity[0]->Entity[0]->name, "Friend 1 1");
+        $this->assertEqual($e->Entity[0]->Entity[1]->name, "Friend 1 2");
+
+        $this->assertEqual($e->Entity[1]->Entity[0]->name, "Friend 2 1");
+        $this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2");
+
+
+        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TDIRTY);
+        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TDIRTY);
+
+        $e->save();
+
+        $this->assertTrue($e->Entity[0] instanceof Entity);
+        $this->assertTrue($e->Entity[1] instanceof Entity);
+
+        $this->assertEqual($e->Entity[0]->name, "Friend 1");
+        $this->assertEqual($e->Entity[1]->name, "Friend 2");
+
+        $this->assertEqual($e->Entity[0]->Entity[0]->name, "Friend 1 1");
+        $this->assertEqual($e->Entity[0]->Entity[1]->name, "Friend 1 2");
+
+        $this->assertEqual($e->Entity[1]->Entity[0]->name, "Friend 2 1");
+        $this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2");
+
+        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN);
+        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN);
+
+        $e = $e->getTable()->find($e->getID());
+        
+        $this->assertTrue($e->Entity[0] instanceof Entity);
+        $this->assertTrue($e->Entity[1] instanceof Entity);
+
+        $this->assertEqual($e->Entity[0]->name, "Friend 1");
+        $this->assertEqual($e->Entity[1]->name, "Friend 2");
+
+        $this->assertEqual($e->Entity[0]->Entity[0]->name, "Friend 1 1");
+        $this->assertEqual($e->Entity[0]->Entity[1]->name, "Friend 1 2");
+
+        $this->assertEqual($e->Entity[1]->Entity[0]->name, "Friend 2 1");
+        $this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2");
+
+        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN);
+        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN);
+        
+        $coll = $this->session->query("FROM Entity WHERE Entity.name = 'Friend 1'");
+        $this->assertEqual($coll->count(), 1);
+        $this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_CLEAN);
+        
+        $this->assertEqual($coll[0]->name, "Friend 1");
+        
+        $query = new Doctrine_Query($this->session);
+
+        $query->from("Entity.Entity")->where("Entity.Entity.name = 'Friend 1 1'");
+
+        $coll = $query->execute();
+
+        $this->assertEqual($coll->count(), 1);
+    }
+
     public function testEnumType() {
         $enum = new EnumTest();
         $enum->status = "open";
@@ -44,52 +125,7 @@ class Doctrine_RecordTestCase extends Doctrine_UnitTestCase {
         $this->assertEqual($user->name, 'z');
     }
 
-    public function testJoinTableSelfReferencing() {
-        $e = new Entity();
-        $e->name = "Entity test";
-        $this->assertTrue($e->Entity[0] instanceof Entity);
-        $this->assertTrue($e->Entity[1] instanceof Entity);
-
-        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TCLEAN);
-        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TCLEAN);
-        
-        $e->Entity[0]->name = "Subentity 1";
-        $e->Entity[1]->name = "Subentity 2";
-        
-        $this->assertEqual($e->Entity[0]->name, "Subentity 1");
-        $this->assertEqual($e->Entity[1]->name, "Subentity 2");   
 
-        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TDIRTY);
-        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TDIRTY);
-
-        $e->save();
-
-        $this->assertTrue($e->Entity[0] instanceof Entity);
-        $this->assertTrue($e->Entity[1] instanceof Entity);
-        
-        $this->assertEqual($e->Entity[0]->name, "Subentity 1");
-        $this->assertEqual($e->Entity[1]->name, "Subentity 2");
-
-        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN);
-        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN);
-
-        $e = $e->getTable()->find($e->getID());
-        
-        $this->assertTrue($e->Entity[0] instanceof Entity);
-        $this->assertTrue($e->Entity[1] instanceof Entity);
-
-        $this->assertEqual($e->Entity[0]->name, "Subentity 1");
-        $this->assertEqual($e->Entity[1]->name, "Subentity 2");
-
-        $this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN);
-        $this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN);
-        
-        $coll = $this->session->query("FROM Entity WHERE Entity.name = 'Subentity 1'");
-        $this->assertEqual($coll->count(), 1);
-        $this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_CLEAN);
-        
-        $this->assertEqual($coll[0]->name, "Subentity 1");
-    }
 
     public function testCompositePK() {
         $record = new EntityReference();

tests/run.php

@@ -61,16 +61,18 @@ $test->addTestCase(new Doctrine_QueryTestCase());
 
 print "<pre>";
 $test->run(new HtmlReporter());
+/**
 $cache = Doctrine_Manager::getInstance()->getCurrentSession()->getCacheHandler();
 if(isset($cache)) {
     $a     = $cache->getQueries();
     print "Executed cache queries: ".count($a)."\n";
-    /**
+
     foreach($a as $query) {
         print $query."\n";
     }
-    */
+
 }
+*/
 
 $dbh = Doctrine_Manager::getInstance()->getCurrentSession()->getDBH();
 $a   = $dbh->getQueries();