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;
}
public static function increment(DAOConnected &$object, array $fields, $refreshCurrent = true, $query = null)
{
$objectDao = $object->dao();
if ($query) {
$updateQuery = $query;
} else {
$updateQuery = OSQL::update()->setTable($objectDao->getTable())->where(Expression::eqId('id', $object));
}
$mapping = $objectDao->getProtoClass()->getMapping();
foreach ($mapping as $field => $column) {
if (isset($fields[$field])) {
$updateQuery->set($column, Expression::add($column, $fields[$field]));
}
}
$updateCount = DBPool::getByDao($objectDao)->queryCount($updateQuery);
if ($query) {
$objectDao->uncacheLists();
} else {
$objectDao->uncacheById($object->getId());
}
if ($refreshCurrent && !$query) {
$object = $objectDao->getById($object->getId());
}
return $updateCount;
}
/**
* @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 getListByIds(array $ids)
{
try {
return $this->getListByLogic(Expression::in(new DBField($this->dao->getIdName(), $this->dao->getTable()), $ids));
} catch (ObjectNotFoundException $e) {
return [];
}
}
/**
* @throws WrongArgumentException
* @return LogicalChain
**/
public static function getOpenPoint($left, $right, $point)
{
Assert::isFalse($point === null, 'how can i build logic from emptyness?');
$point = new DBValue($point);
$chain = new LogicalChain();
$chain->expOr(Expression::orBlock(Expression::andBlock(Expression::notNull($left), Expression::notNull($right), Expression::between($point, $left, $right)), Expression::andBlock(Expression::isNull($left), Expression::ltEq($point, $right)), Expression::andBlock(Expression::isNull($right), Expression::ltEq($left, $point)), Expression::andBlock(Expression::isNull($left), Expression::isNull($right))));
return $chain;
}
/**
* @throws WrongArgumentException
* @return SelectQuery
**/
public static function makeFullTextQuery(FullTextDAO $dao, Criteria $criteria, $string)
{
Assert::isString($string, 'only strings accepted today');
$array = self::prepareSearchString($string);
if (!$array) {
throw new ObjectNotFoundException();
}
if (!($field = $dao->getIndexField()) instanceof DBField) {
$field = new DBField($dao->getIndexField(), $dao->getTable());
}
return $criteria->toSelectQuery()->andWhere(Expression::fullTextOr($field, $array))->prependOrderBy(Expression::fullTextRankAnd($field, $array))->desc();
}
public static function down(DAOConnected $object, LogicalObject $exp = null)
{
$getMethod = 'get' . ucfirst(self::$property);
Assert::isTrue(method_exists($object, $getMethod));
$oldPosition = $object->{$getMethod}();
$criteria = Criteria::create($object->dao())->add(Expression::gt(self::$property, $oldPosition))->addOrder(OrderBy::create(self::$property)->asc())->setLimit(1);
if ($exp) {
$criteria->add($exp);
}
if ($lowerObject = $criteria->get()) {
DaoUtils::setNullValue(self::$nullValue);
DaoUtils::swap($lowerObject, $object, self::$property);
}
}
/**
* @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;
}
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([$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([$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
}
/**
* @return UpdateQuery
**/
private function targetizeUpdateQuery(UpdateQuery $query, Identifiable $object)
{
return $query->where(Expression::eqId($this->getIdName(), $object));
}
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;
}
private function loadNextChunk($id)
{
Assert::isNotNull($this->dao);
$this->offset = 0;
$criteria = Criteria::create($this->dao);
if ($this->projection) {
$criteria->setProjection($this->projection);
}
$criteria->addOrder($this->keyProperty)->setLimit($this->chunkSize);
if ($id !== null) {
$criteria->add(Expression::gt($this->keyProperty, $id));
}
// preserving memory bloat
$this->dao->dropIdentityMap();
$this->chunk = $criteria->getList();
return $this->chunk;
}
private function joinProperties(SelectQuery $query, ProtoDAO $parentDao, $parentTable, $parentRequired, $prefix = null)
{
$proto = call_user_func([$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::class) || is_subclass_of($property->getClassName(), Enum::class) || is_subclass_of($property->getClassName(), Registry::class)) {
// field already added by makeSelectHead
continue;
} elseif ($property->isInner()) {
$proto = call_user_func([$property->getClassName(), 'proto']);
foreach ($proto->getPropertyList() as $innerProperty) {
$query->get(new DBField($innerProperty->getColumnName(), $parentTable));
}
continue;
}
$propertyDao = call_user_func([$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));
}
}
}
private function checkEnumerationReferentialIntegrity($enumeration, $tableName)
{
Assert::isTrue($enumeration instanceof Enumeration || $enumeration instanceof Enum || $enumeration instanceof Registry, 'argument enumeation must be instacne of Enumeration or Enum! gived, "' . gettype($enumeration) . '"');
$updateQueries = null;
$db = DBPool::me()->getLink();
$class = get_class($enumeration);
$ids = [];
if ($enumeration instanceof Enumeration) {
$list = $enumeration->getList();
} elseif ($enumeration instanceof Enum) {
$list = ClassUtils::callStaticMethod($class . '::getList');
} elseif ($enumeration instanceof Registry) {
$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 UpdateQuery
**/
private function makeMassUpdateQuery($ids)
{
$uc = $this->container;
return OSQL::update($uc->getDao()->getTable())->set($uc->getParentIdField(), null)->where(Expression::in($uc->getChildIdField(), $ids));
}
/**
* @return SelectQuery
**/
protected function targetize(SelectQuery $query)
{
return $query->andWhere(Expression::eqId(new DBField($this->container->getParentIdField(), $this->container->getDao()->getTable()), $this->container->getParentObject()));
}
public function toSelectQuery()
{
if (!$this->range || !$this->interval) {
throw new WrongStateException('define time range and interval units first');
}
if (!$this->range->getStart() || !$this->range->getEnd()) {
throw new WrongArgumentException('cannot operate with unlimited range');
}
$firstIntervalStart = $this->interval->truncate($this->range->getStart(), !$this->overlapped);
$maxIntervals = $this->interval->countInRange($this->range, $this->overlapped) - 1;
$generator = $this->getSeriesGenerator(0, $maxIntervals);
$result = OSQL::select()->from($generator, self::ITERATOR_ALIAS)->get(Expression::add(DBValue::create($firstIntervalStart->toString())->castTo(DataType::create(DataType::TIMESTAMP)->getName()), Expression::mul(DBValue::create("1 {$this->interval->getName()}")->castTo(DataType::create(DataType::INTERVAL)->getName()), DBField::create(self::ITERATOR_ALIAS))), $this->field);
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;
}
