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;
}
public function add(Identifiable $object)
{
if ($this instanceof SequencelessDAO) {
return $this->import($object);
}
return $this->inject(OSQL::insert(), $object->setId(DBPool::getByDao($this)->obtainSequence($this->getSequence())));
}
public static function eq(Query $query, $prefix = null)
{
if ($prefix === null) {
$trace = debug_backtrace();
$prefix = basename($trace[0]['file']) . ':' . $trace[0]['line'];
}
error_log($prefix . ": " . $query->toDialectString(DBPool::me()->getLink()->getDialect()));
}
/**
* @param DB|GenericDAO $database
* @param IsolationLevel $level
* @param AccessMode $mode
**/
public function __construct($database, IsolationLevel $level = null, AccessMode $mode = null)
{
if ($database instanceof DB) {
$this->db = $database;
} elseif ($database instanceof GenericDAO) {
$this->db = DBPool::getByDao($database);
} else {
throw new WrongStateException('$database must be instance of DB or GenericDAO');
}
$this->beginTransaction($level, $mode);
}
public function __construct(ProtoDAO $dao, SelectQuery $query = null)
{
if ($query) {
Assert::isTrue($query instanceof SelectQuery);
}
$this->dao = $dao;
$this->db = DBPool::getByDao($this->dao);
$this->selectQuery = $query;
$this->openTransaction();
$this->declareCursor();
}
/**
* @throws WrongArgumentException
* @return ManyToManyLinkedLazy
**/
public function sync($insert, $update = array(), $delete)
{
Assert::isTrue($update === array());
$dao = $this->container->getDao();
$db = DBPool::getByDao($dao);
if ($insert) {
for ($i = 0, $size = count($insert); $i < $size; ++$i) {
$db->queryNull($this->makeInsertQuery($insert[$i]));
}
}
if ($delete) {
$db->queryNull($this->makeDeleteQuery($delete));
$dao->uncacheByIds($delete);
}
return $this;
}
/**
* @throws WrongArgumentException
* @return OneToManyLinkedLazy
**/
public function sync($insert, $update = array(), $delete)
{
Assert::isTrue($update === array());
$db = DBPool::getByDao($this->container->getDao());
$uc = $this->container;
$dao = $uc->getDao();
if ($insert) {
$db->queryNull($this->makeMassUpdateQuery($insert));
}
if ($delete) {
// unlink or drop
$uc->isUnlinkable() ? $db->queryNull($this->makeMassUpdateQuery($delete)) : $db->queryNull(OSQL::delete()->from($dao->getTable())->where(Expression::in($uc->getChildIdField(), $delete)));
$dao->uncacheByIds($delete);
}
return $this;
}
/**
* @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;
}
/**
* @return ManyToManyLinkedFull
**/
public function sync($insert, $update = [], $delete)
{
$dao = $this->container->getDao();
$db = DBPool::getByDao($dao);
if ($insert) {
for ($i = 0, $size = count($insert); $i < $size; ++$i) {
$db->queryNull($this->makeInsertQuery($dao->take($insert[$i])->getId()));
}
}
if ($update) {
for ($i = 0, $size = count($update); $i < $size; ++$i) {
$dao->save($update[$i]);
}
}
if ($delete) {
$ids = [];
foreach ($delete as $object) {
$ids[] = $object->getId();
}
$db->queryNull($this->makeDeleteQuery($ids));
$dao->uncacheByIds($ids);
}
return $this;
}
public function toValue(ProtoDAO $dao = null, $array, $prefix = null)
{
$raw = $array[$prefix . $this->columnName];
if ($this->type == 'binary') {
return DBPool::getByDao($dao)->getDialect()->unquoteBinary($raw);
}
if ($this->className == 'HttpUrl') {
return HttpUrl::create()->parse($raw);
}
if ($this->type === 'json' || $this->type === 'jsonb') {
return json_decode($raw, true);
//associative array instead of object
}
if (!$this->identifier && $this->generic && $this->className) {
return call_user_func([$this->className, 'create'], $raw);
} elseif (!$this->identifier && $this->className) {
// BOVM: prevents segfault on >=php-5.2.5
Assert::classExists($this->className);
if (!is_subclass_of($this->className, Enumeration::class) && !is_subclass_of($this->className, Enum::class) && !is_subclass_of($this->className, Registry::class)) {
$remoteDao = call_user_func([$this->className, 'dao']);
$joinPrefix = $remoteDao->getJoinPrefix($this->columnName, $prefix);
$joined = $this->strategyId == FetchStrategy::JOIN || isset($array[$joinPrefix . $remoteDao->getIdName()]);
if ($joined) {
return $remoteDao->makeObject($array, $joinPrefix);
} else {
// will be fetched later
// by AbstractProtoClass::fetchEncapsulants
$object = new $this->className();
$object->setId($raw);
return $object;
}
} else {
return new $this->className($raw);
}
}
// veeeeery "special" handling, by tradition.
// MySQL returns 0/1, others - t/f
if ($this->type == 'boolean') {
return (bool) strtr($raw, ['f' => null]);
}
return $raw;
}
public function toString()
{
return $this->toDialectString($this->dao ? DBPool::getByDao($this->dao)->getDialect() : ImaginaryDialect::me());
}
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;
}
protected function fetchList(SelectQuery $query)
{
$list = [];
if ($rows = DBPool::getByDao($this->dao)->querySet($query)) {
$proto = $this->dao->getProtoClass();
$proto->beginPrefetch();
foreach ($rows as $row) {
$list[] = $this->dao->makeObject($row);
}
$proto->endPrefetch($list);
}
return $list;
}
public function getQueryResult(SelectQuery $query, $expires = Cache::DO_NOT_CACHE)
{
if ($expires !== Cache::DO_NOT_CACHE && ($list = $this->getCachedByQuery($query))) {
return $list;
} else {
$list = $this->fetchList($query);
$count = clone $query;
$count = DBPool::getByDao($this->dao)->queryRow($count->dropFields()->dropOrder()->limit(null, null)->get(SQLFunction::create('COUNT', '*')->setAlias('count')));
return $this->cacheByQuery($query, $list ? QueryResult::create()->setList($list)->setCount($count['count'])->setQuery($query) : QueryResult::create(), $expires);
}
}
protected function doInject(InsertOrUpdateQuery $query, Identifiable $object)
{
$db = DBPool::getByDao($this);
if (!$db->isQueueActive()) {
$preUncacher = is_scalar($object->getId()) ? $this->getUncacherById($object->getId()) : null;
$count = $db->queryCount($query);
$uncacher = $this->getUncacherById($object->getId());
if ($preUncacher) {
$uncacher->merge($uncacher);
}
$uncacher->uncache();
if ($count !== 1) {
throw new WrongStateException($count . ' rows affected: racy or insane inject happened: ' . $query->toDialectString($db->getDialect()));
}
} else {
$preUncacher = is_scalar($object->getId()) ? $this->getUncacherById($object->getId()) : null;
$db->queryNull($query);
$uncacher = $this->getUncacherById($object->getId());
if ($preUncacher) {
$uncacher->merge($uncacher);
}
$uncacher->uncache();
}
// clean out Identifier, if any
$result = $this->addObjectToMap($object->setId($object->getId()));
$this->runTrigger($object, OnAfterSave::class);
return $result;
}
