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; }