public function dropList()
{
$dao = $this->container->getDao();
DBPool::getByDao($dao)->queryNull(OSQL::delete()->from($this->container->getHelperTable())->where(Expression::eq($this->container->getParentIdField(), $this->container->getParentObject()->getId())));
$dao->uncacheLists();
return $this;
}
private function getSome()
{
for ($i = 1; $i < 3; ++$i) {
$this->assertTrue(TestUser::dao()->getByLogic(Expression::eq('city_id', $i)) == TestUser::dao()->getById($i));
}
$this->assertEquals(count(TestUser::dao()->getPlainList()), count(TestCity::dao()->getPlainList()));
}
/**
* @return SelectQuery
**/
protected function joinHelperTable(SelectQuery $query)
{
$uc = $this->container;
if (!$query->hasJoinedTable($uc->getHelperTable())) {
$query->join($uc->getHelperTable(), Expression::eq(new DBField($uc->getParentTableIdField(), $uc->getDao()->getTable()), new DBField($uc->getChildIdField(), $uc->getHelperTable())));
}
return $query->andWhere(Expression::eq(new DBField($uc->getParentIdField(), $uc->getHelperTable()), new DBValue($uc->getParentObject()->getId())));
}
public function testLazy()
{
foreach (DBTestPool::me()->getPool() as $db) {
DBPool::me()->setDefault($db);
$parent = TestParentObject::create();
$child = TestChildObject::create()->setParent($parent);
$parent->dao()->add($parent);
$child->dao()->add($child);
$this->assertEquals($parent->getId(), Criteria::create(TestChildObject::dao())->setProjection(Projection::property('parent.id', 'parentId'))->add(Expression::eq('id', $child->getId()))->getCustom('parentId'));
}
}
public function testHasNoReturning()
{
$dialect = ImaginaryDialect::me();
$query = OSQL::update('test_table')->set('field1', 1)->where(Expression::eq('field1', 2))->returning('field1');
try {
$query->toDialectString($dialect);
} catch (UnimplementedFeatureException $e) {
return $this;
}
$this->fail();
}
public function testIpRangeProperty()
{
foreach (DBTestPool::me()->getPool() as $db) {
DBPool::me()->setDefault($db);
$akado = TestInternetProvider::create()->setName('Akada')->setRange(IpRange::create(IpAddress::create('192.168.1.1'), IpAddress::create('192.168.1.42')));
TestInternetProvider::dao()->add($akado);
$plainRange = Criteria::create(TestInternetProvider::dao())->addProjection(Projection::property('range'))->add(Expression::eq('name', 'Akada'))->getCustom();
$this->assertEquals($plainRange['range'], '192.168.1.1-192.168.1.42');
TestInternetProvider::dao()->add(TestInternetProvider::create()->setName('DomRu')->setRange(IpRange::create('192.168.2.0/24')));
$list = Criteria::create(TestInternetProvider::dao())->addOrder('id')->getList();
$this->assertEquals(count($list), 2);
}
}
public function testQuery()
{
$query = OSQL::delete()->from('pity_table');
$dialect = PostgresDialect::me();
try {
$query->toDialectString($dialect);
$this->fail();
} catch (WrongArgumentException $e) {
/* pass */
}
$query->where(Expression::eq('count', 2));
$this->assertEquals($query->toDialectString($dialect), 'DELETE FROM "pity_table" WHERE ("count" = \'2\')');
$query->andWhere(Expression::notEq('a', '2'));
$this->assertEquals($query->toDialectString($dialect), 'DELETE FROM "pity_table" WHERE ("count" = \'2\') AND ("a" != \'2\')');
}
public function testSelectJoin()
{
$dialect = $this->getDbByType('PgSQL')->getDialect();
$joinTypeList = array('JOIN ' => 'join', 'LEFT JOIN ' => 'leftJoin', 'RIGHT JOIN ' => 'rightJoin', 'FULL OUTER JOIN ' => 'fullOuterJoin');
$joinExpression = Expression::eq(DBField::create('joinField', 'table1'), DBField::create('joinField', 'table2'));
$baseRawQuery = 'SELECT ' . '"table1"."field1", ' . '"table2"."field2" ' . 'FROM "table1" ';
foreach ($joinTypeList as $sqlJoin => $method) {
$query = $this->getBaseJoinSelect()->{$method}('table2', $joinExpression);
$rawQuery = $baseRawQuery . $sqlJoin . '"table2" ON ("table1"."joinField" = "table2"."joinField")';
$this->assertEquals($rawQuery, $query->toDialectString($dialect));
$query = $this->getBaseJoinSelect()->{$method}('table2', $joinExpression, 'table2');
$rawQuery = $baseRawQuery . $sqlJoin . '"table2" AS "table2" ' . 'ON ("table1"."joinField" = "table2"."joinField")';
$this->assertEquals($rawQuery, $query->toDialectString($dialect));
}
}
public function testQuery()
{
$query = OSQL::delete()->from('pity_table');
$dialect = ImaginaryDialect::me();
try {
$query->toDialectString($dialect);
$this->fail();
} catch (WrongArgumentException $e) {
/* pass */
}
$query->where(Expression::eq(1, 2));
$this->assertEquals($query->toDialectString($dialect), 'DELETE FROM pity_table WHERE (1 = 2)');
$query->andWhere(Expression::notEq('a', 'b'));
$this->assertEquals($query->toDialectString($dialect), 'DELETE FROM pity_table WHERE (1 = 2) AND (a != b)');
}
public function testForgottenDao()
{
$criteria = Criteria::create()->add(Expression::eq('id', 42));
$listCriteria = clone $criteria;
try {
$listCriteria->getList();
$this->fail();
} catch (WrongStateException $e) {
/*it's good*/
}
$customCriteria = clone $criteria;
try {
$customCriteria->addProjection(Projection::property('id'))->getCustomList();
$this->fail();
} catch (WrongStateException $e) {
/*it's good*/
}
}
public function testInnerTransaction()
{
foreach (DBTestPool::me()->getPool() as $connector => $db) {
DBPool::me()->setDefault($db);
$this->getDBCreator()->fillDB();
$moscow = TestCity::dao()->getByLogic(Expression::eq('name', 'Moscow'));
$piter = TestCity::dao()->getByLogic(Expression::eq('name', 'Saint-Peterburg'));
$cityNewer = function (TestCity $city) {
$city->dao()->merge($city->setName('New ' . $city->getName()));
};
$citiesNewer = function ($moscow, $piter) use($cityNewer, $db) {
$cityNewer($moscow);
InnerTransactionWrapper::create()->setDB($db)->setFunction($cityNewer)->run($piter);
};
InnerTransactionWrapper::create()->setDao($moscow->dao())->setFunction($citiesNewer)->run($moscow, $piter);
$this->assertNotNull(TestCity::dao()->getByLogic(Expression::eq('name', 'New Moscow')));
$this->assertNotNull(TestCity::dao()->getByLogic(Expression::eq('name', 'New Saint-Peterburg')));
}
}
/**
* @return OneToManyLinkedFull
**/
public function sync($insert, $update = array(), $delete)
{
$uc = $this->container;
$dao = $uc->getDao();
if ($delete) {
DBPool::getByDao($dao)->queryNull(OSQL::delete()->from($dao->getTable())->where(Expression::eq(new DBField($uc->getParentIdField()), $uc->getParentObject()->getId()))->andWhere(Expression::in($uc->getChildIdField(), ArrayUtils::getIdsArray($delete))));
$dao->uncacheByIds(ArrayUtils::getIdsArray($delete));
}
if ($insert) {
for ($i = 0, $size = count($insert); $i < $size; ++$i) {
$dao->add($insert[$i]);
}
}
if ($update) {
for ($i = 0, $size = count($update); $i < $size; ++$i) {
$dao->save($update[$i]);
}
}
return $this;
}
public function testChainForm()
{
$form = Form::create()->add(Primitive::string('a'))->add(Primitive::string('b'))->add(Primitive::integer('c'))->add(Primitive::integer('d'))->add(Primitive::boolean('e'))->add(Primitive::string('f'))->import(array('a' => 'true', 'c' => 123, 'd' => 123));
$andChain = Expression::chain()->expAnd(Expression::expOr(new FormField('a'), Expression::notNull(new FormField('b'))))->expAnd(Expression::eq(new FormField('c'), new FormField('d')))->expAnd(Expression::isFalse(new FormField('e')));
$this->assertTrue($andChain->toBoolean($form));
$form->importMore(array('e' => 'on'));
$this->assertFalse($andChain->toBoolean($form));
$orChain = Expression::chain()->expOr(Expression::eq(new FormField('a'), new FormField('b')))->expOr(Expression::expOr(new FormField('e'), Expression::gt(new FormField('c'), new FormField('d'))))->expOr(Expression::in(new FormField('f'), array('qwer', 'asdf', 'zxcv')));
$form->import(array());
$this->assertFalse($orChain->toBoolean($form));
$form->import(array('e' => '1'));
$this->assertTrue($orChain->toBoolean($form));
$form->import(array('a' => 'asdf', 'b' => 'qwerq', 'c' => '13', 'd' => '1313', 'f' => 'iukj'));
$this->assertFalse($orChain->toBoolean($form));
$form->import(array('c' => '13', 'd' => '12'));
$this->assertTrue($orChain->toBoolean($form));
$form->import(array('f' => 'asdfwer'));
$this->assertFalse($orChain->toBoolean($form));
$form->import(array('f' => 'qwer'));
$this->assertTrue($orChain->toBoolean($form));
}
public function getById($id, $expires = Cache::EXPIRES_MEDIUM)
{
if ($expires !== Cache::DO_NOT_CACHE && ($object = $this->getCachedById($id))) {
if ($object === Cache::NOT_FOUND) {
throw new CachedObjectNotFoundException("there is no such object for '" . $this->dao->getObjectName() . "' with id=" . $id);
}
return $this->dao->completeObject($object);
} else {
$query = $this->dao->makeSelectHead()->andWhere(Expression::eq(DBField::create($this->dao->getIdName(), $this->dao->getTable()), $id));
if ($expires === Cache::DO_NOT_CACHE) {
$object = $this->fetchObject($query);
} else {
$object = $this->cachedFetchObject($query, $expires, true);
}
if ($object) {
return $object;
} else {
throw new ObjectNotFoundException("there is no such object for '" . $this->dao->getObjectName() . "' with query == " . $query->toDialectString(DBPool::me()->getByDao($this->dao)->getDialect()));
}
}
}
public function testHaving()
{
$query = OQL::select('from TestUser');
$criteria = Criteria::create(TestUser::dao());
$this->assertCriteria($query->addHaving(OQL::having('id > 0')), $criteria->addProjection(Projection::having(Expression::gt('id', 0))));
$this->assertCriteria($query->addHaving(OQL::having('name is not null and (id <> $1 or id != $2)')->bindNext(4)->bindNext(8)), $criteria->addProjection(Projection::having(Expression::expAnd(Expression::notNull('name'), Expression::expOr(Expression::notEq('id', 4), Expression::notEq('id', 8))))));
$this->assertEquals(OQL::having('id + $15')->bind(15, 16)->toProjection(), Projection::having(Expression::add('id', 16)));
$this->assertCriteria(OQL::select('from TestUser')->addHaving(OQL::having('id = $1')->bindNext(23))->bindNext(42), Criteria::create(TestUser::dao())->addProjection(Projection::having(Expression::eq('id', 42))));
}
private function processPath(AbstractProtoClass $proto, $probablyPath, JoinCapableQuery $query, $table, $parentRequired = true, $prefix = null)
{
$path = explode('.', $probablyPath);
try {
$property = $proto->getPropertyByName($path[0]);
} catch (MissingElementException $e) {
// oh, it's a value, not a property
return new DBValue($probablyPath);
}
unset($path[0]);
Assert::isTrue($property->getRelationId() != null && !$property->isGenericType());
Assert::classExists($property->getClassName());
// checking whether we're playing with value object
if (!method_exists($property->getClassName(), 'dao')) {
if (method_exists($property->getClassName(), 'proto') && count($path) > 1) {
return $this->processPath($property->getProto(), implode('.', $path), $query, $table);
} else {
return $this->guessAtom(implode('.', $path), $query, $table, $prefix);
}
} else {
$propertyDao = call_user_func(array($property->getClassName(), 'dao'));
Assert::isNotNull($propertyDao, 'can not find target dao for "' . $property->getName() . '" property at "' . get_class($proto) . '"');
}
$alias = $propertyDao->getJoinName($property->getColumnName(), $prefix);
if ($property->getRelationId() == MetaRelation::ONE_TO_MANY || $property->getRelationId() == MetaRelation::MANY_TO_MANY) {
$remoteName = $property->getClassName();
$selfName = $this->getObjectName();
$self = new $selfName();
$getter = $property->getGetter();
$dao = call_user_func(array($remoteName, 'dao'));
if ($property->getRelationId() == MetaRelation::MANY_TO_MANY) {
$helperTable = $self->{$getter}()->getHelperTable();
$helperAlias = $helperTable;
if (!$query->hasJoinedTable($helperAlias)) {
$logic = Expression::eq(DBField::create($this->getIdName(), $table), DBField::create($self->{$getter}()->getParentIdField(), $helperAlias));
if ($property->isRequired()) {
$query->join($helperTable, $logic, $helperAlias);
} else {
$query->leftJoin($helperTable, $logic, $helperAlias);
}
}
$logic = Expression::eq(DBField::create($propertyDao->getIdName(), $alias), DBField::create($self->{$getter}()->getChildIdField(), $helperAlias));
} else {
$logic = Expression::eq(DBField::create($self->{$getter}()->getParentIdField(), $alias), DBField::create($this->getIdName(), $table));
}
if (!$query->hasJoinedTable($alias)) {
if ($property->isRequired() && $parentRequired) {
$query->join($dao->getTable(), $logic, $alias);
} else {
$query->leftJoin($dao->getTable(), $logic, $alias);
}
}
} else {
// OneToOne, lazy OneToOne
// prevents useless joins
if (isset($path[1]) && count($path) == 1 && $path[1] == $propertyDao->getIdName()) {
return new DBField($property->getColumnName(), $table);
}
if (!$query->hasJoinedTable($alias)) {
$logic = Expression::eq(DBField::create($property->getColumnName(), $table), DBField::create($propertyDao->getIdName(), $alias));
if ($property->isRequired() && $parentRequired) {
$query->join($propertyDao->getTable(), $logic, $alias);
} else {
$query->leftJoin($propertyDao->getTable(), $logic, $alias);
}
}
}
if ($path) {
return $propertyDao->guessAtom(implode('.', $path), $query, $alias, $property->isRequired() && $parentRequired, $propertyDao->getJoinPrefix($property->getColumnName(), $prefix));
}
// ok, we're done
}
private function checkEnumerationReferentialIntegrity(Enumeration $enumeration, $tableName)
{
$updateQueries = null;
$db = DBPool::me()->getLink();
$class = get_class($enumeration);
$ids = array();
$list = $enumeration->getObjectList();
foreach ($list as $enumerationObject) {
$ids[$enumerationObject->getId()] = $enumerationObject->getName();
}
$rows = $db->querySet(OSQL::select()->from($tableName)->multiGet('id', 'name'));
echo "\n";
foreach ($rows as $row) {
if (!isset($ids[$row['id']])) {
echo "Class '{$class}', strange id: {$row['id']} found. \n";
} else {
if ($ids[$row['id']] != $row['name']) {
echo "Class '{$class}',id: {$row['id']} sync names. \n";
$updateQueries .= OSQL::update($tableName)->set('name', $ids[$row['id']])->where(Expression::eq('id', $row['id']))->toDialectString($db->getDialect()) . ";\n";
}
unset($ids[$row['id']]);
}
}
foreach ($ids as $id => $name) {
echo "Class '{$class}', id: {$id} not present in database. \n";
}
echo $updateQueries;
return $this;
}
private function update(IdentifiableOrmEntity $entity)
{
$affected = $this->executeQuery(UpdateQuery::create($this->physicalSchema->getTable())->setValues($this->map->disassemble($entity))->setCondition(EntityQuery::create($this->entity)->where(Expression::eq($this->identifier, $entity->_getId()))->toExpression()));
$entity->setFetched();
return $affected > 0;
}
public function logIn($username, $password)
{
return $this->getByLogic(Expression::expAnd(Expression::eq('username', $username), Expression::eq('password', $password)));
}
public function dropById($id)
{
$result = DBPool::getByDao($this->dao)->queryCount(OSQL::delete()->from($this->dao->getTable())->where(Expression::eq($this->dao->getIdName(), $id)));
$this->dao->uncacheById($id);
return $result;
}
/**
* @param TestCase $test
* @return DBTestCreator
*/
public function fillDB(TestCase $test = null)
{
$moscow = TestCity::create()->setName('Moscow');
$piter = TestCity::create()->setName('Saint-Peterburg');
$mysqler = TestUser::create()->setCity($moscow)->setCredentials(Credentials::create()->setNickname('mysqler')->setPassword(sha1('mysqler')))->setLastLogin(Timestamp::create(time()))->setRegistered(Timestamp::create(time())->modify('-1 day'));
$postgreser = clone $mysqler;
$postgreser->setCredentials(Credentials::create()->setNickName('postgreser')->setPassword(sha1('postgreser')))->setCity($piter)->setUrl(HttpUrl::create()->parse('http://postgresql.org/'));
$piter = TestCity::dao()->add($piter);
$moscow = TestCity::dao()->add($moscow);
if ($test) {
$test->assertEquals($piter->getId(), 1);
$test->assertEquals($moscow->getId(), 2);
}
$postgreser = TestUser::dao()->add($postgreser);
for ($i = 0; $i < 10; $i++) {
$encapsulant = TestEncapsulant::dao()->add(TestEncapsulant::create()->setName($i));
$encapsulant->getCities()->fetch()->setList(array($piter, $moscow))->save();
}
$mysqler = TestUser::dao()->add($mysqler);
if ($test) {
$test->assertEquals($postgreser->getId(), 1);
$test->assertEquals($mysqler->getId(), 2);
}
if ($test) {
// put them in cache now
TestUser::dao()->dropIdentityMap();
TestUser::dao()->getById(1);
TestUser::dao()->getById(2);
if ($test instanceof DBDataTest) {
$test->getListByIdsTest();
}
Cache::me()->clean();
$test->assertTrue($postgreser == TestUser::dao()->getById(1));
$test->assertTrue($mysqler == TestUser::dao()->getById(2));
}
$firstClone = clone $postgreser;
$secondClone = clone $mysqler;
$firstCount = TestUser::dao()->dropById($postgreser->getId());
$secondCount = TestUser::dao()->dropByIds(array($mysqler->getId()));
if ($test) {
$test->assertEquals($firstCount, 1);
$test->assertEquals($secondCount, 1);
try {
TestUser::dao()->getById(1);
$test->fail();
} catch (ObjectNotFoundException $e) {
/* pass */
}
$result = Criteria::create(TestUser::dao())->add(Expression::eq(1, 2))->getResult();
$test->assertEquals($result->getCount(), 0);
$test->assertEquals($result->getList(), array());
}
TestUser::dao()->import($firstClone);
TestUser::dao()->import($secondClone);
if ($test && $test instanceof DBDataTest) {
// cache multi-get
$test->getListByIdsTest();
$test->getListByIdsTest();
}
return $this;
}
private function joinProperties(SelectQuery $query, ProtoDAO $parentDao, $parentTable, $parentRequired, $prefix = null)
{
$proto = call_user_func(array($parentDao->getObjectName(), 'proto'));
foreach ($proto->getPropertyList() as $property) {
if ($property instanceof LightMetaProperty && $property->getRelationId() == MetaRelation::ONE_TO_ONE && !$property->isGenericType() && (!$property->getFetchStrategyId() && $this->getFetchStrategy()->getId() == FetchStrategy::JOIN || $property->getFetchStrategyId() == FetchStrategy::JOIN)) {
if (is_subclass_of($property->getClassName(), 'Enumeration')) {
// field already added by makeSelectHead
continue;
} elseif ($property->isInner()) {
$proto = call_user_func(array($property->getClassName(), 'proto'));
foreach ($proto->getPropertyList() as $innerProperty) {
$query->get(new DBField($innerProperty->getColumnName(), $parentTable));
}
continue;
}
$propertyDao = call_user_func(array($property->getClassName(), 'dao'));
// add's custom dao's injection possibility
if (!$propertyDao instanceof ProtoDAO) {
continue;
}
$tableAlias = $propertyDao->getJoinName($property->getColumnName(), $prefix);
$fields = $propertyDao->getFields();
if (!$query->hasJoinedTable($tableAlias)) {
$logic = Expression::eq(DBField::create($property->getColumnName(), $parentTable), DBField::create($propertyDao->getIdName(), $tableAlias));
if ($property->isRequired() && $parentRequired) {
$query->join($propertyDao->getTable(), $logic, $tableAlias);
} else {
$query->leftJoin($propertyDao->getTable(), $logic, $tableAlias);
}
}
foreach ($fields as $field) {
$query->get(new DBField($field, $tableAlias), $propertyDao->getJoinPrefix($property->getColumnName(), $prefix) . $field);
}
$this->joinProperties($query, $propertyDao, $tableAlias, $property->isRequired() && $parentRequired, $propertyDao->getJoinPrefix($property->getColumnName(), $prefix));
}
}
}
/**
* @return ISqlSelectQuery
*/
private function makeSqlSelectQuery(EntityQuery $query)
{
$query = $query->toSelectQuery();
$joinMethod = SqlJoinMethod::INNER;
$childrenTable = $this->getChildren()->getPhysicalSchema()->getTable();
$proxyTable = $this->mtm->getProxy()->getPhysicalSchema()->getTable();
$condition = Expression::andChain();
$srcSqlFields = $this->getChildren()->getLogicalSchema()->getIdentifier()->getFields();
$dstSqlFields = $this->mtm->getEncapsulantProxyProperty()->getFields();
foreach ($srcSqlFields as $k => $v) {
$condition->add(Expression::eq(new SqlColumn($srcSqlFields[$k], $childrenTable), new SqlColumn($dstSqlFields[$k], $proxyTable)));
}
$query->join(new SqlConditionalJoin(new SelectQuerySource(new SqlIdentifier($proxyTable)), new SqlJoinMethod($joinMethod), $condition));
$columnName = $this->mtm->getContainerProxyProperty()->getField();
$query->andWhere(Expression::eq(new SqlColumn($columnName, $this->mtm->getProxy()->getPhysicalSchema()->getTable()), new SqlValue($this->getParentObject()->_getId())));
return $query;
}
private function checkEnumerationReferentialIntegrity($enumeration, $tableName)
{
Assert::isTrue($enumeration instanceof Enumeration || $enumeration instanceof Enum, 'argument enumeation must be instacne of Enumeration or Enum! gived, "' . gettype($enumeration) . '"');
$updateQueries = null;
$db = DBPool::me()->getLink();
$class = get_class($enumeration);
$ids = array();
if ($enumeration instanceof Enumeration) {
$list = $enumeration->getList();
} elseif ($enumeration instanceof Enum) {
$list = ClassUtils::callStaticMethod($class . '::getList');
}
foreach ($list as $enumerationObject) {
$ids[$enumerationObject->getId()] = $enumerationObject->getName();
}
$rows = $db->querySet(OSQL::select()->from($tableName)->multiGet('id', 'name'));
echo "\n";
foreach ($rows as $row) {
if (!isset($ids[$row['id']])) {
echo "Class '{$class}', strange id: {$row['id']} found. \n";
} else {
if ($ids[$row['id']] != $row['name']) {
echo "Class '{$class}',id: {$row['id']} sync names. \n";
$updateQueries .= OSQL::update($tableName)->set('name', $ids[$row['id']])->where(Expression::eq('id', $row['id']))->toDialectString($db->getDialect()) . ";\n";
}
unset($ids[$row['id']]);
}
}
foreach ($ids as $id => $name) {
echo "Class '{$class}', id: {$id} not present in database. \n";
}
echo $updateQueries;
return $this;
}
/**
* @return void
*/
private function join(OrmProperty $property, AssociationPropertyType $type, EntityQueryBuilder $builder, SelectQuerySource $source)
{
$joinMethod = $type->getAssociationMultiplicity()->is(AssociationMultiplicity::EXACTLY_ONE) ? SqlJoinMethod::INNER : SqlJoinMethod::LEFT;
$condition = Expression::andChain();
$srcSqlFields = $property->getFields();
$dstSqlFields = $builder->entity->getLogicalSchema()->getIdentifier()->getFields();
foreach ($srcSqlFields as $k => $v) {
$condition->add(Expression::eq(new SqlColumn($srcSqlFields[$k], $this->alias), new SqlColumn($dstSqlFields[$k], $builder->alias)));
}
$source->join(new SqlConditionalJoin(new SelectQuerySource(new AliasedSqlValueExpression(new SqlIdentifier($builder->table), $builder->alias)), new SqlJoinMethod($joinMethod), $condition));
}
private function fillQuery(EntityQuery $query)
{
$query->andWhere(Expression::eq($this->referentialProperty, $this->getParentObject()));
}
public function testQuery()
{
$criteria = Criteria::create(TestUser::dao())->setProjection(Projection::property('id'))->add(Expression::isTrue('id'));
$this->assertCriteria('id from TestUser where id is true', $criteria)->assertCriteria('id from TestUser where id is true order by id asc', $criteria->addOrder(OrderBy::create('id')->asc()))->assertCriteria('id from TestUser where id is true order by id asc limit 10 offset 1', $criteria->setLimit(10)->setOffset(1))->assertCriteria('id from TestUser where id is true group by id order by id asc limit 10 offset 1', $criteria->setProjection(Projection::chain()->add(Projection::property('id'))->add(Projection::group('id'))))->assertCriteria('id from TestUser where id is true group by id order by id asc having id = 1 limit 10 offset 1', $criteria->setProjection(Projection::chain()->add(Projection::property('id'))->add(Projection::group('id'))->add(Projection::having(Expression::eq('id', 1)))))->assertCriteria('count(id) as count from TestUser group by id having count = 2', Criteria::create(TestUser::dao())->setProjection(Projection::chain()->add(Projection::count('id', 'count'))->add(Projection::group('id'))->add(Projection::having(Expression::eq('count', 2)))));
}
/**
* @param string $name
* @return TestCity
*/
public static function getCityByName($name)
{
return Criteria::create(TestCity::dao())->add(Expression::eq('name', DBValue::create($name)))->get();
}
