PHP AuthorPeer::retrieveByPK方法代码示例

 public function testNestedTransactionForceRollBack()
 {
     $con = Propel::getConnection(BookPeer::DATABASE_NAME);
     $driver = $con->getAttribute(PDO::ATTR_DRIVER_NAME);
     // main transaction
     $con->beginTransaction();
     $a = new Author();
     $a->setFirstName('Test');
     $a->setLastName('User');
     $a->save($con);
     $authorId = $a->getId();
     // nested transaction
     $con->beginTransaction();
     $a2 = new Author();
     $a2->setFirstName('Test2');
     $a2->setLastName('User2');
     $a2->save($con);
     $authorId2 = $a2->getId();
     // force rollback
     $con->forceRollback();
     $this->assertEquals(0, $con->getNestedTransactionCount(), 'nested transaction is null after nested transaction forced rollback');
     $this->assertFalse($con->isInTransaction(), 'PropelPDO is not in transaction after nested transaction force rollback');
     AuthorPeer::clearInstancePool();
     $at = AuthorPeer::retrieveByPK($authorId);
     $this->assertNull($at, "Rolled back transaction is not persisted in database");
     $at2 = AuthorPeer::retrieveByPK($authorId2);
     $this->assertNull($at2, "Forced Rolled back nested transaction is not persisted in database");
 }

 public function testObjectInstances()
 {
     $sample = BookPeer::doSelectOne(new Criteria());
     $samplePk = $sample->getPrimaryKey();
     // 1) make sure consecutive calls to retrieveByPK() return the same object.
     $b1 = BookPeer::retrieveByPK($samplePk);
     $b2 = BookPeer::retrieveByPK($samplePk);
     $sampleval = md5(microtime());
     $this->assertTrue($b1 === $b2, "Expected object instances to match for calls with same retrieveByPK() method signature.");
     // 2) make sure that calls to doSelect also return references to the same objects.
     $allbooks = BookPeer::doSelect(new Criteria());
     foreach ($allbooks as $testb) {
         if ($testb->getPrimaryKey() == $b1->getPrimaryKey()) {
             $this->assertTrue($testb === $b1, "Expected same object instance from doSelect() as from retrieveByPK()");
         }
     }
     // 3) test fetching related objects
     $book = BookPeer::retrieveByPK($samplePk);
     $bookauthor = $book->getAuthor();
     $author = AuthorPeer::retrieveByPK($bookauthor->getId());
     $this->assertTrue($bookauthor === $author, "Expected same object instance when calling fk object accessor as retrieveByPK()");
     // 4) test a doSelectJoin()
     $morebooks = BookPeer::doSelectJoinAuthor(new Criteria());
     for ($i = 0, $j = 0; $j < count($morebooks); $i++, $j++) {
         $testb1 = $allbooks[$i];
         $testb2 = $allbooks[$j];
         $this->assertTrue($testb1 === $testb2, "Expected the same objects from consecutive doSelect() calls.");
         // we could probably also test this by just verifying that $book & $testb are the same
         if ($testb1->getPrimaryKey() === $book) {
             $this->assertTrue($book->getAuthor() === $testb1->getAuthor(), "Expected same author object in calls to pkey-matching books.");
         }
     }
     // 5) test creating a new object, saving it, and then retrieving that object (should all be same instance)
     $b = new BookstoreEmployee();
     $b->setName("Testing");
     $b->setJobTitle("Testing");
     $b->save();
     $empId = $b->getId();
     $this->assertSame($b, BookstoreEmployeePeer::retrieveByPK($empId), "Expected newly saved object to be same instance as pooled.");
 }

 public function getAuthor($con = null)
 {
     include_once 'lib/model/om/BaseAuthorPeer.php';
     if ($this->aAuthor === null && $this->author_id !== null) {
         $this->aAuthor = AuthorPeer::retrieveByPK($this->author_id, $con);
     }
     return $this->aAuthor;
 }

 public function testSavingParentSavesRelatedObjectsIncludingNew()
 {
     $author = AuthorPeer::retrieveByPK($this->author->getId());
     // add new object before fetching old books
     $b3 = new Book();
     $author->addBook($b3);
     $c = new Criteria();
     $c->add(BookPeer::ID, $this->books[0]->getId());
     $books = $author->getBooks($c);
     $books[0]->setTitle('Update to a book');
     $author->save();
     $this->assertEquals(3, $author->countBooks());
     $this->assertFalse($b3->isModified());
     $this->assertFalse($books[0]->isModified());
 }

 /**
  * @link       http://propel.phpdb.org/trac/ticket/699
  */
 public function testRollBack_NestedSwallow()
 {
     $con = Propel::getConnection(BookPeer::DATABASE_NAME);
     $driver = $con->getAttribute(PDO::ATTR_DRIVER_NAME);
     if ($driver == "mysql") {
         $this->markTestSkipped();
     }
     $con->beginTransaction();
     try {
         $a = new Author();
         $a->setFirstName('Test');
         $a->setLastName('User');
         $a->save($con);
         $authorId = $a->getId();
         $this->assertTrue($authorId !== null, "Expected valid new author ID");
         $con->beginTransaction();
         try {
             $con->exec('INVALID SQL');
             $this->fail("Expected exception on invalid SQL");
         } catch (Exception $x) {
             $con->rollBack();
             // NO RETHROW
         }
         $a2 = new Author();
         $a2->setFirstName('Test2');
         $a2->setLastName('User2');
         $authorId2 = $a2->save($con);
         $con->commit();
         // this should not do anything!
     } catch (Exception $x) {
         $this->fail("No outside rollback expected.");
     }
     AuthorPeer::clearInstancePool();
     $at = AuthorPeer::retrieveByPK($authorId);
     $this->assertNull($at, "Expected no author result for rolled-back save.");
     $at2 = AuthorPeer::retrieveByPK($authorId2);
     $this->assertNull($at2, "Expected no author2 result for rolled-back save.");
 }

 public function getAuthor($con = null)
 {
     if ($this->aAuthor === null && $this->author_id !== null) {
         $this->aAuthor = AuthorPeer::retrieveByPK($this->author_id, $con);
     }
     return $this->aAuthor;
 }