public function getListByIds(array $ids)
{
try {
return $this->getListByLogic(Expression::in(new DBField($this->dao->getIdName(), $this->dao->getTable()), $ids));
} catch (ObjectNotFoundException $e) {
return [];
}
}
/**
* @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 fetchCollections(array $collections, array $list)
{
Assert::isNotEmptyArray($list);
$ids = ArrayUtils::getIdsArray($list);
$mainId = DBField::create($this->getIdName(), $this->getTable());
foreach ($collections as $path => $info) {
$lazy = $info['lazy'];
$query = OSQL::select()->get($mainId)->from($this->getTable());
$proto = reset($list)->proto();
$this->processPath($proto, $path, $query, $this->getTable());
if ($criteria = $info['criteria']) {
$query = $criteria->setDao($this)->fillSelectQuery($query);
}
$query->andWhere(Expression::in($mainId, $ids));
$propertyPath = $info['propertyPath'];
$property = $propertyPath->getFinalProperty();
$proto = $propertyPath->getFinalProto();
$dao = $propertyPath->getFinalDao();
$selfName = $this->getObjectName();
$self = new $selfName();
$getter = 'get' . ucfirst($property->getName());
Assert::isTrue($property->getRelationId() == MetaRelation::ONE_TO_MANY || $property->getRelationId() == MetaRelation::MANY_TO_MANY);
$table = $dao->getJoinName($property->getColumnName());
$id = $this->getIdName();
$collection = [];
if ($lazy) {
if ($property->getRelationId() == MetaRelation::MANY_TO_MANY) {
$childId = $self->{$getter}()->getChildIdField();
} else {
$childId = $dao->getIdName();
}
$alias = 'cid';
// childId, collectionId, whatever
$field = DBField::create($childId, $self->{$getter}()->getHelperTable());
$query->get($field, $alias);
if (!$property->isRequired()) {
$query->andWhere(Expression::notNull($field));
}
try {
$rows = $dao->getCustomList($query);
foreach ($rows as $row) {
if (!empty($row[$alias])) {
$collection[$row[$id]][] = $row[$alias];
}
}
} catch (ObjectNotFoundException $e) {
/*_*/
}
} else {
$prefix = $table . '_';
foreach ($dao->getFields() as $field) {
$query->get(DBField::create($field, $table), $prefix . $field);
}
if (!$property->isRequired()) {
$query->andWhere(Expression::notNull(DBField::create($dao->getIdName(), $table)));
}
try {
// otherwise we don't know which object
// belongs to which collection
$rows = $dao->getCustomList($query);
foreach ($rows as $row) {
$collection[$row[$id]][] = $dao->makeObject($row, $prefix);
}
} catch (ObjectNotFoundException $e) {
/*_*/
}
}
$suffix = ucfirst($property->getName());
$fillMethod = 'fill' . $suffix;
$getMethod = 'get' . $suffix;
Assert::isTrue(method_exists(reset($list), $fillMethod), 'can not find filler');
Assert::isTrue(method_exists(reset($list), $getMethod), 'can not find getter');
foreach ($list as $object) {
if (!empty($collection[$object->getId()])) {
$object->{$fillMethod}($collection[$object->getId()], $lazy);
} else {
$object->{$getMethod}()->mergeList([]);
}
}
}
return $list;
}
/**
* only unlinking, we don't want to drop original object
* @return DeleteQuery
**/
protected function makeDeleteQuery($delete)
{
$uc = $this->container;
return OSQL::delete()->from($uc->getHelperTable())->where(Expression::eq(new DBField($uc->getParentIdField()), new DBValue($uc->getParentObject()->getId())))->andWhere(Expression::in($uc->getChildIdField(), $delete));
}
/**
* @return UpdateQuery
**/
private function makeMassUpdateQuery($ids)
{
$uc = $this->container;
return OSQL::update($uc->getDao()->getTable())->set($uc->getParentIdField(), null)->where(Expression::in($uc->getChildIdField(), $ids));
}
public function dropByIds(array $ids)
{
$result = DBPool::getByDao($this->dao)->queryCount(OSQL::delete()->from($this->dao->getTable())->where(Expression::in($this->dao->getIdName(), $ids)));
$this->dao->uncacheByIds($ids);
return $result;
}
public function getListByIds(array $ids, $expires = Cache::EXPIRES_MEDIUM)
{
$list = [];
// dupes, if any, will be resolved later @ ArrayUtils::regularizeList
$ids = array_unique($ids);
if ($expires !== Cache::DO_NOT_CACHE) {
$toFetch = [];
$prefixed = [];
foreach ($ids as $id) {
$prefixed[$id] = $this->makeIdKey($id);
}
if ($cachedList = Cache::me()->mark($this->className)->getList($prefixed)) {
$proto = $this->dao->getProtoClass();
$proto->beginPrefetch();
foreach ($cachedList as $cached) {
if ($cached && $cached !== Cache::NOT_FOUND) {
$list[] = $this->dao->completeObject($cached);
unset($prefixed[$cached->getId()]);
}
}
$proto->endPrefetch($list);
}
$toFetch += array_keys($prefixed);
if ($toFetch) {
try {
$list = array_merge($list, $this->getListByLogic(Expression::in(new DBField($this->dao->getIdName(), $this->dao->getTable()), $toFetch), Cache::DO_NOT_CACHE));
} catch (ObjectNotFoundException $e) {
// nothing to fetch
}
}
} elseif (count($ids)) {
try {
$list = $this->getListByLogic(Expression::in(new DBField($this->dao->getIdName(), $this->dao->getTable()), $ids), Cache::DO_NOT_CACHE);
} catch (ObjectNotFoundException $e) {
/*_*/
}
}
return $list;
}
