/** * {@inheritdoc} */ public function save($source, $alias, $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED, $pid = NULL) { if ($source[0] !== '/') { throw new \InvalidArgumentException(sprintf('Source path %s has to start with a slash.', $source)); } if ($alias[0] !== '/') { throw new \InvalidArgumentException(sprintf('Alias path %s has to start with a slash.', $alias)); } $fields = array('source' => $source, 'alias' => $alias, 'langcode' => $langcode); // Insert or update the alias. if (empty($pid)) { $query = $this->connection->insert('url_alias')->fields($fields); $pid = $query->execute(); $fields['pid'] = $pid; $operation = 'insert'; } else { // Fetch the current values so that an update hook can identify what // exactly changed. $original = $this->connection->query('SELECT source, alias, langcode FROM {url_alias} WHERE pid = :pid', array(':pid' => $pid))->fetchAssoc(); $fields['pid'] = $pid; $query = $this->connection->update('url_alias')->fields($fields)->condition('pid', $pid); $pid = $query->execute(); $fields['original'] = $original; $operation = 'update'; } if ($pid) { // @todo Switch to using an event for this instead of a hook. $this->moduleHandler->invokeAll('path_' . $operation, array($fields)); Cache::invalidateTags(['route_match']); return $fields; } return FALSE; }
/** * {@inheritdoc} */ public function update(array $batch) { try { $this->connection->update('batch')->fields(array('batch' => serialize($batch)))->condition('bid', $batch['id'])->execute(); } catch (\Exception $e) { $this->catchException($e); } }
/** * {@inheritdoc} */ public function update($entry) { $count = NULL; try { $count = $this->connection->update('dbtng_example')->fields($entry)->condition('pid', $entry['pid'])->execute(); } catch (\Exception $e) { drupal_set_message(t('db_update failed. Message = %message, query= %query', array('%message' => $e->getMessage(), '%query' => $e->query_string)), 'error'); } return $count; }
/** * {@inheritdoc} */ public function updateIndex(NodeInterface $node) { $nid = $node->id(); $count = $this->database->query("SELECT COUNT(cid) FROM {comment_field_data} c INNER JOIN {forum_index} i ON c.entity_id = i.nid WHERE c.entity_id = :nid AND c.field_name = 'comment_forum' AND c.entity_type = 'node' AND c.status = :status AND c.default_langcode = 1", array(':nid' => $nid, ':status' => CommentInterface::PUBLISHED))->fetchField(); if ($count > 0) { // Comments exist. $last_reply = $this->database->queryRange("SELECT cid, name, created, uid FROM {comment_field_data} WHERE entity_id = :nid AND field_name = 'comment_forum' AND entity_type = 'node' AND status = :status AND default_langcode = 1 ORDER BY cid DESC", 0, 1, array(':nid' => $nid, ':status' => CommentInterface::PUBLISHED))->fetchObject(); $this->database->update('forum_index')->fields(array('comment_count' => $count, 'last_comment_timestamp' => $last_reply->created))->condition('nid', $nid)->execute(); } else { // Comments do not exist. // @todo This should be actually filtering on the desired node language $this->database->update('forum_index')->fields(array('comment_count' => 0, 'last_comment_timestamp' => $node->getCreatedTime()))->condition('nid', $nid)->execute(); } }
/** * Decrements count of flagged entities. * * @param \Drupal\flag\Event\FlaggingEvent $event * The flagging Event. */ public function decrementFlagCounts(FlaggingEvent $event) { /* @var \Drupal\flag\FlaggingInterface flag */ $flag = $event->getFlag(); /* @var \Drupal\Core\Entity\EntityInterface $entity */ $entity = $event->getEntity(); $count_result = $this->connection->select('flag_counts') ->fields(NULL, ['flag_id', 'entity_id', 'entity_type', 'count']) ->condition('flag_id', $flag->id()) ->condition('entity_id', $entity->id()) ->condition('entity_type', $entity->getEntityTypeId()) ->execute() ->fetchAll(); if ($count_result[0]->count == '1') { $this->connection->delete('flag_counts') ->condition('flag_id', $flag->id()) ->condition('entity_id', $entity->id()) ->condition('entity_type', $entity->getEntityTypeId()) ->execute(); } else { $this->connection->update('flag_counts') ->expression('count', 'count - 1') ->condition('flag_id', $flag->id()) ->condition('entity_id', $entity->id()) ->condition('entity_type', $entity->getEntityTypeId()) ->execute(); } $this->resetLoadedCounts($entity, $flag); }
/** * Checks whether the string version matches a given version, fix it if not. * * @param \Drupal\locale\StringInterface $string * The string object. * @param string $version * Drupal version to check against. */ protected function checkVersion($string, $version) { if ($string->getId() && $string->getVersion() != $version) { $string->setVersion($version); $this->connection->update('locales_source', $this->options)->condition('lid', $string->getId())->fields(array('version' => $version))->execute(); } }
/** * {@inheritdoc} */ public function update(CommentInterface $comment) { // Allow bulk updates and inserts to temporarily disable the maintenance of // the {comment_entity_statistics} table. if (!$this->state->get('comment.maintain_entity_statistics')) { return; } $query = $this->database->select('comment_field_data', 'c'); $query->addExpression('COUNT(cid)'); $count = $query->condition('c.entity_id', $comment->getCommentedEntityId())->condition('c.entity_type', $comment->getCommentedEntityTypeId())->condition('c.field_name', $comment->getFieldName())->condition('c.status', CommentInterface::PUBLISHED)->condition('default_langcode', 1)->execute()->fetchField(); if ($count > 0) { // Comments exist. $last_reply = $this->database->select('comment_field_data', 'c')->fields('c', array('cid', 'name', 'changed', 'uid'))->condition('c.entity_id', $comment->getCommentedEntityId())->condition('c.entity_type', $comment->getCommentedEntityTypeId())->condition('c.field_name', $comment->getFieldName())->condition('c.status', CommentInterface::PUBLISHED)->condition('default_langcode', 1)->orderBy('c.created', 'DESC')->range(0, 1)->execute()->fetchObject(); // Use merge here because entity could be created before comment field. $this->database->merge('comment_entity_statistics')->fields(array('cid' => $last_reply->cid, 'comment_count' => $count, 'last_comment_timestamp' => $last_reply->changed, 'last_comment_name' => $last_reply->uid ? '' : $last_reply->name, 'last_comment_uid' => $last_reply->uid))->keys(array('entity_id' => $comment->getCommentedEntityId(), 'entity_type' => $comment->getCommentedEntityTypeId(), 'field_name' => $comment->getFieldName()))->execute(); } else { // Comments do not exist. $entity = $comment->getCommentedEntity(); // Get the user ID from the entity if it's set, or default to the // currently logged in user. if ($entity instanceof EntityOwnerInterface) { $last_comment_uid = $entity->getOwnerId(); } if (!isset($last_comment_uid)) { // Default to current user when entity does not implement // EntityOwnerInterface or author is not set. $last_comment_uid = $this->currentUser->id(); } $this->database->update('comment_entity_statistics')->fields(array('cid' => 0, 'comment_count' => 0, 'last_comment_timestamp' => $entity instanceof EntityChangedInterface ? $entity->getChangedTime() : REQUEST_TIME, 'last_comment_name' => '', 'last_comment_uid' => $last_comment_uid))->condition('entity_id', $comment->getCommentedEntityId())->condition('entity_type', $comment->getCommentedEntityTypeId())->condition('field_name', $comment->getFieldName())->execute(); } // Reset the cache of the commented entity so that when the entity is loaded // the next time, the statistics will be loaded again. $this->entityManager->getStorage($comment->getCommentedEntityTypeId())->resetCache(array($comment->getCommentedEntityId())); }
/** * {@inheritdoc} */ public function acquire($name, $timeout = 30.0) { // Insure that the timeout is at least 1 ms. $timeout = max($timeout, 0.001); $expire = microtime(TRUE) + $timeout; if (isset($this->locks[$name])) { // Try to extend the expiration of a lock we already acquired. $success = (bool) $this->database->update('semaphore')->fields(array('expire' => $expire))->condition('name', $name)->condition('value', $this->getLockId())->execute(); if (!$success) { // The lock was broken. unset($this->locks[$name]); } return $success; } else { // Optimistically try to acquire the lock, then retry once if it fails. // The first time through the loop cannot be a retry. $retry = FALSE; // We always want to do this code at least once. do { try { $this->database->insert('semaphore')->fields(array('name' => $name, 'value' => $this->getLockId(), 'expire' => $expire))->execute(); // We track all acquired locks in the global variable. $this->locks[$name] = TRUE; // We never need to try again. $retry = FALSE; } catch (IntegrityConstraintViolationException $e) { // Suppress the error. If this is our first pass through the loop, // then $retry is FALSE. In this case, the insert failed because some // other request acquired the lock but did not release it. We decide // whether to retry by checking lockMayBeAvailable(). This will clear // the offending row from the database table in case it has expired. $retry = $retry ? FALSE : $this->lockMayBeAvailable($name); } catch (\Exception $e) { // Create the semaphore table if it does not exist and retry. if ($this->ensureTableExists()) { // Retry only once. $retry = !$retry; } else { throw $e; } } // We only retry in case the first attempt failed, but we then broke // an expired lock. } while ($retry); } return isset($this->locks[$name]); }
/** * Implements Drupal\Core\Cache\CacheBackendInterface::invalidateAll(). */ public function invalidateAll() { try { $this->connection->update($this->bin)->fields(array('expire' => REQUEST_TIME - 1))->execute(); } catch (\Exception $e) { $this->catchException($e); } }
/** * Tests that exceptions thrown by workers are handled properly. */ public function testExceptions() { // Get the queue to test the normal Exception. $queue = $this->container->get('queue')->get('cron_queue_test_exception'); // Enqueue an item for processing. $queue->createItem(array($this->randomMachineName() => $this->randomMachineName())); // Run cron; the worker for this queue should throw an exception and handle // it. $this->cron->run(); $this->assertEqual(\Drupal::state()->get('cron_queue_test_exception'), 1); // The item should be left in the queue. $this->assertEqual($queue->numberOfItems(), 1, 'Failing item still in the queue after throwing an exception.'); // Expire the queue item manually. system_cron() relies in REQUEST_TIME to // find queue items whose expire field needs to be reset to 0. This is a // Kernel test, so REQUEST_TIME won't change when cron runs. // @see system_cron() // @see \Drupal\Core\Cron::processQueues() $this->connection->update('queue')->condition('name', 'cron_queue_test_exception')->fields(['expire' => REQUEST_TIME - 1])->execute(); $this->cron->run(); $this->assertEqual(\Drupal::state()->get('cron_queue_test_exception'), 2); $this->assertEqual($queue->numberOfItems(), 0, 'Item was processed and removed from the queue.'); // Get the queue to test the specific SuspendQueueException. $queue = $this->container->get('queue')->get('cron_queue_test_broken_queue'); // Enqueue several item for processing. $queue->createItem('process'); $queue->createItem('crash'); $queue->createItem('ignored'); // Run cron; the worker for this queue should process as far as the crashing // item. $this->cron->run(); // Only one item should have been processed. $this->assertEqual($queue->numberOfItems(), 2, 'Failing queue stopped processing at the failing item.'); // Check the items remaining in the queue. The item that throws the // exception gets released by cron, so we can claim it again to check it. $item = $queue->claimItem(); $this->assertEqual($item->data, 'crash', 'Failing item remains in the queue.'); $item = $queue->claimItem(); $this->assertEqual($item->data, 'ignored', 'Item beyond the failing item remains in the queue.'); // Test the requeueing functionality. $queue = $this->container->get('queue')->get('cron_queue_test_requeue_exception'); $queue->createItem([]); $this->cron->run(); $this->assertEqual(\Drupal::state()->get('cron_queue_test_requeue_exception'), 2); $this->assertFalse($queue->numberOfItems()); }
/** * {@inheritdoc} */ public function write(Profile $profile) { $args = ['token' => $profile->getToken(), 'parent' => $profile->getParentToken(), 'data' => base64_encode(serialize($profile->getCollectors())), 'ip' => $profile->getIp(), 'method' => $profile->getMethod(), 'url' => $profile->getUrl(), 'time' => $profile->getTime(), 'created_at' => time()]; try { $query = $this->database->select('webprofiler', 'w')->fields('w', ['token']); $query->condition('token', $profile->getToken()); $count = $query->countQuery()->execute()->fetchAssoc(); if ($count['expression']) { $this->database->update('webprofiler')->fields($args)->condition('token', $profile->getToken())->execute(); } else { $this->database->insert('webprofiler')->fields($args)->execute(); } $status = TRUE; } catch (\Exception $e) { $status = FALSE; } return $status; }
/** * {@inheritdoc} */ public function regenerate($destroy = FALSE, $lifetime = NULL) { global $user; // Nothing to do if we are not allowed to change the session. if (!$this->isEnabled() || $this->isCli()) { return; } // We do not support the optional $destroy and $lifetime parameters as long // as #2238561 remains open. if ($destroy || isset($lifetime)) { throw new \InvalidArgumentException('The optional parameters $destroy and $lifetime of SessionManager::regenerate() are not supported currently'); } $is_https = $this->requestStack->getCurrentRequest()->isSecure(); $cookies = $this->requestStack->getCurrentRequest()->cookies; if ($is_https && $this->isMixedMode()) { $insecure_session_name = $this->getInsecureName(); $params = session_get_cookie_params(); $session_id = Crypt::randomBytesBase64(); // If a session cookie lifetime is set, the session will expire // $params['lifetime'] seconds from the current request. If it is not set, // it will expire when the browser is closed. $expire = $params['lifetime'] ? REQUEST_TIME + $params['lifetime'] : 0; setcookie($insecure_session_name, $session_id, $expire, $params['path'], $params['domain'], FALSE, $params['httponly']); $cookies->set($insecure_session_name, $session_id); } if ($this->isStarted()) { $old_session_id = $this->getId(); } session_id(Crypt::randomBytesBase64()); $this->getMetadataBag()->clearCsrfTokenSeed(); if (isset($old_session_id)) { $params = session_get_cookie_params(); $expire = $params['lifetime'] ? REQUEST_TIME + $params['lifetime'] : 0; setcookie($this->getName(), $this->getId(), $expire, $params['path'], $params['domain'], $params['secure'], $params['httponly']); $fields = array('sid' => Crypt::hashBase64($this->getId())); if ($is_https) { $fields['ssid'] = Crypt::hashBase64($this->getId()); // If the "secure pages" setting is enabled, use the newly-created // insecure session identifier as the regenerated sid. if ($this->isMixedMode()) { $fields['sid'] = Crypt::hashBase64($session_id); } } $this->connection->update('sessions')->fields($fields)->condition($is_https ? 'ssid' : 'sid', Crypt::hashBase64($old_session_id))->execute(); } if (!$this->isStarted()) { // Start the session when it doesn't exist yet. // Preserve the logged in user, as it will be reset to anonymous // by \Drupal\Core\Session\SessionHandler::read(). $account = $user; $this->startNow(); $user = $account; } date_default_timezone_set(drupal_get_user_timezone()); }
/** * {@inheritdoc} */ public function garbageCollection() { try { // Clean up the queue for failed batches. $this->connection->delete(static::TABLE_NAME)->condition('created', REQUEST_TIME - 864000, '<')->condition('name', 'drupal_batch:%', 'LIKE')->execute(); // Reset expired items in the default queue implementation table. If that's // not used, this will simply be a no-op. $this->connection->update(static::TABLE_NAME)->fields(array('expire' => 0))->condition('expire', 0, '<>')->condition('expire', REQUEST_TIME, '<')->execute(); } catch (\Exception $e) { $this->catchException($e); } }
/** * {@inheritdoc} */ public function save($source, $alias, $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED, $pid = NULL) { if ($source[0] !== '/') { throw new \InvalidArgumentException(sprintf('Source path %s has to start with a slash.', $source)); } if ($alias[0] !== '/') { throw new \InvalidArgumentException(sprintf('Alias path %s has to start with a slash.', $alias)); } $fields = array('source' => $source, 'alias' => $alias, 'langcode' => $langcode); // Insert or update the alias. if (empty($pid)) { $try_again = FALSE; try { $query = $this->connection->insert(static::TABLE)->fields($fields); $pid = $query->execute(); } catch (\Exception $e) { // If there was an exception, try to create the table. if (!($try_again = $this->ensureTableExists())) { // If the exception happened for other reason than the missing table, // propagate the exception. throw $e; } } // Now that the table has been created, try again if necessary. if ($try_again) { $query = $this->connection->insert(static::TABLE)->fields($fields); $pid = $query->execute(); } $fields['pid'] = $pid; $operation = 'insert'; } else { // Fetch the current values so that an update hook can identify what // exactly changed. try { $original = $this->connection->query('SELECT source, alias, langcode FROM {url_alias} WHERE pid = :pid', array(':pid' => $pid))->fetchAssoc(); } catch (\Exception $e) { $this->catchException($e); $original = FALSE; } $fields['pid'] = $pid; $query = $this->connection->update(static::TABLE)->fields($fields)->condition('pid', $pid); $pid = $query->execute(); $fields['original'] = $original; $operation = 'update'; } if ($pid) { // @todo Switch to using an event for this instead of a hook. $this->moduleHandler->invokeAll('path_' . $operation, array($fields)); Cache::invalidateTags(['route_match']); return $fields; } return FALSE; }
/** * {@inheritdoc} */ public function save($source, $alias, $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED, $pid = NULL) { $fields = array('source' => $source, 'alias' => $alias, 'langcode' => $langcode); // Insert or update the alias. if (empty($pid)) { $query = $this->connection->insert('url_alias')->fields($fields); $pid = $query->execute(); $fields['pid'] = $pid; $operation = 'insert'; } else { $fields['pid'] = $pid; $query = $this->connection->update('url_alias')->fields($fields)->condition('pid', $pid); $pid = $query->execute(); $operation = 'update'; } if ($pid) { // @todo Switch to using an event for this instead of a hook. $this->moduleHandler->invokeAll('path_' . $operation, array($fields)); return $fields; } return FALSE; }
/** * Implements Drupal\file\FileUsage\FileUsageInterface::delete(). */ public function delete(FileInterface $file, $module, $type = NULL, $id = NULL, $count = 1) { // Delete rows that have a exact or less value to prevent empty rows. $query = $this->connection->delete($this->tableName)->condition('module', $module)->condition('fid', $file->id()); if ($type && $id) { $query->condition('type', $type)->condition('id', $id); } if ($count) { $query->condition('count', $count, '<='); } $result = $query->execute(); // If the row has more than the specified count decrement it by that number. if (!$result && $count > 0) { $query = $this->connection->update($this->tableName)->condition('module', $module)->condition('fid', $file->id()); if ($type && $id) { $query->condition('type', $type)->condition('id', $id); } $query->expression('count', 'count - :count', array(':count' => $count)); $query->execute(); } parent::delete($file, $module, $type, $id, $count); }
/** * Sets has_children for the link's parent if it has visible children. * * @param array $link * The link to get a parent ID from. */ protected function updateParentalStatus(array $link) { // If parent is empty, there is nothing to update. if (!empty($link['parent'])) { // Check if at least one visible child exists in the table. $query = $this->connection->select($this->table, $this->options); $query->addExpression('1'); $query->range(0, 1); $query->condition('menu_name', $link['menu_name'])->condition('parent', $link['parent'])->condition('enabled', 1); $parent_has_children = (bool) $query->execute()->fetchField() ? 1 : 0; $this->connection->update($this->table, $this->options)->fields(array('has_children' => $parent_has_children))->condition('id', $link['parent'])->execute(); } }
/** * {@inheritdoc} */ public function setSubscription(array &$data) { if (isset($data['lease']) && is_numeric($data['lease'])) { $data['expires'] = (int) REQUEST_TIME + $data['lease']; } else { // @todo Change schema to allow NULL values. $data['lease'] = 0; $data['expires'] = 0; } // Updating an existing subscription. if ($this->hasSubscription($data['id'])) { unset($data['created']); $this->connection->update($this->table)->fields($data)->condition('id', $data['id'])->execute(); return FALSE; } else { $data['secret'] = Crypt::randomStringHashed(55); $data['token'] = Crypt::randomStringHashed(55); $data['created'] = REQUEST_TIME; $this->connection->insert($this->table)->fields($data)->execute(); return TRUE; } }
/** * {@inheritdoc} */ public function write($sid, $value) { global $user; // The exception handler is not active at this point, so we need to do it // manually. try { if (!$this->sessionManager->isEnabled()) { // We don't have anything to do if we are not allowed to save the // session. return TRUE; } // Either ssid or sid or both will be added from $key below. $fields = array('uid' => $user->id(), 'hostname' => $this->requestStack->getCurrentRequest()->getClientIP(), 'session' => $value, 'timestamp' => REQUEST_TIME); // Use the session ID as 'sid' and an empty string as 'ssid' by default. // read() does not allow empty strings so that's a safe default. $key = array('sid' => Crypt::hashBase64($sid), 'ssid' => ''); // On HTTPS connections, use the session ID as both 'sid' and 'ssid'. if ($this->requestStack->getCurrentRequest()->isSecure()) { $key['ssid'] = Crypt::hashBase64($sid); $cookies = $this->requestStack->getCurrentRequest()->cookies; // The "secure pages" setting allows a site to simultaneously use both // secure and insecure session cookies. If enabled and both cookies // are presented then use both keys. The session ID from the cookie is // hashed before being stored in the database as a security measure. if ($this->sessionManager->isMixedMode()) { $insecure_session_name = $this->sessionManager->getInsecureName(); if ($cookies->has($insecure_session_name)) { $key['sid'] = Crypt::hashBase64($cookies->get($insecure_session_name)); } } } elseif ($this->sessionManager->isMixedMode()) { unset($key['ssid']); } $this->connection->merge('sessions')->keys($key)->fields($fields)->execute(); // Likewise, do not update access time more than once per 180 seconds. if ($user->isAuthenticated() && REQUEST_TIME - $user->getLastAccessedTime() > Settings::get('session_write_interval', 180)) { $this->connection->update('users')->fields(array('access' => REQUEST_TIME))->condition('uid', $user->id())->execute(); } return TRUE; } catch (\Exception $exception) { require_once DRUPAL_ROOT . '/core/includes/errors.inc'; // If we are displaying errors, then do so with no possibility of a // further uncaught exception being thrown. if (error_displayable()) { print '<h1>Uncaught exception thrown in session handler.</h1>'; print '<p>' . Error::renderExceptionSafe($exception) . '</p><hr />'; } return FALSE; } }
/** * Updates record. * * @param int $id * The ID of the record. * @param array $record * The record to validate. * @param array $defaults * (optional) Default values for the record. * * @return \Drupal\rest\ModifiedResourceResponse * The HTTP response object. */ protected function updateRecord($id, $record, $defaults = []) { // Make sure the record already exists. $this->loadRecord($id); $this->validate($record); $record += $defaults; // Record ID should never be changed. unset($record['id']); $this->dbConnection->update('example_foo')->fields($record)->condition('id', $id)->execute(); $this->logger->notice('Record @id has been updated', ['@id' => $id]); // Return the updated record in the response body. $updated_record = $this->loadRecord($id); return new ModifiedResourceResponse($updated_record, 200); }
/** * {@inheritdoc} */ public function updateMovedChildren($bid, $original, $expressions, $shift) { $query = $this->connection->update('book'); $query->fields(array('bid' => $bid)); foreach ($expressions as $expression) { $query->expression($expression[0], $expression[1], $expression[2]); } $query->expression('depth', 'depth + :depth', array(':depth' => $shift)); $query->condition('bid', $original['bid']); $p = 'p1'; for ($i = 1; !empty($original[$p]); $p = 'p' . ++$i) { $query->condition($p, $original[$p]); } return $query->execute(); }
/** * Updates the has_children flag of the parent of the original node. * * This method is called when a book link is moved or deleted. So we want to * update the has_children flag of the parent node. * * @param array $original * The original link whose parent we want to update. * * @return bool * TRUE if the update was successful (either there was no original parent to * update, or the original parent was updated successfully), FALSE on * failure. */ protected function updateOriginalParent(array $original) { if ($original['pid'] == 0) { // There were no parents of this link. Nothing to update. return TRUE; } // Check if $original had at least one child. $original_number_of_children = $this->connection->select('book', 'b')->condition('bid', $original['bid'])->condition('pid', $original['pid'])->condition('nid', $original['nid'], '<>')->countQuery()->execute()->fetchField(); $parent_has_children = (bool) $original_number_of_children ? 1 : 0; // Update the parent. If the original link did not have children, then the // parent now does not have children. If the original had children, then the // the parent has children now (still). $query = $this->connection->update('book'); $query->fields(array('has_children' => $parent_has_children))->condition('nid', $original['pid']); return $query->execute(); }
/** * {@inheritdoc} */ public function rename($key, $new_key) { $this->connection->update($this->table)->fields(array('name' => $new_key))->condition('collection', $this->collection)->condition('name', $key)->execute(); }
/** * Migrates the current session to a new session id. * * @param string $old_session_id * The old session id. The new session id is $this->getId() unless * $new_insecure_session_id is not empty. */ protected function migrateStoredSession($old_session_id) { $fields = array('sid' => Crypt::hashBase64($this->getId())); $this->connection->update('sessions')->fields($fields)->condition('sid', Crypt::hashBase64($old_session_id))->execute(); }
/** * Fixes anonymous user on MySQL. * * MySQL import might have set the uid of the anonymous user to autoincrement * value. Let's try fixing it. See http://drupal.org/node/204411 */ public function fixAnonymousUid() { $this->database->update('users')->expression('uid', 'uid - uid')->condition('name', '')->condition('pass', '')->condition('status', 0)->execute(); }
/** * {@inheritdoc} */ public function onFieldDefinitionDelete(FieldDefinitionInterface $field_definition) { $table_mapping = $this->getTableMapping(); $storage_definition = $field_definition->getFieldStorageDefinition(); // Mark field data as deleted. if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { $table_name = $table_mapping->getDedicatedDataTableName($storage_definition); $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition); $this->database->update($table_name)->fields(array('deleted' => 1))->condition('bundle', $field_definition->getTargetBundle())->execute(); if ($this->entityType->isRevisionable()) { $this->database->update($revision_name)->fields(array('deleted' => 1))->condition('bundle', $field_definition->getTargetBundle())->execute(); } } }
/** * {@inheritdoc} */ public function releaseItem($item) { $update = $this->connection->update('queue')->fields(array('expire' => 0))->condition('item_id', $item->item_id); return $update->execute(); }
/** * {@inheritdoc} */ public function onBundleRename($bundle, $bundle_new) { // The method runs before the field definitions are updated, so we use the // old bundle name. $field_definitions = $this->entityManager->getFieldDefinitions($this->entityTypeId, $bundle); // We need to handle deleted fields too. For now, this only makes sense for // configurable fields, so we use the specific API. // @todo Use the unified store of deleted field definitions instead in // https://www.drupal.org/node/2282119 $field_definitions += entity_load_multiple_by_properties('field_instance_config', array('entity_type' => $this->entityTypeId, 'bundle' => $bundle, 'deleted' => TRUE, 'include_deleted' => TRUE)); foreach ($field_definitions as $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); if ($this->usesDedicatedTable($storage_definition)) { $is_deleted = $this->storageDefinitionIsDeleted($storage_definition); $table_name = static::_fieldTableName($storage_definition, $is_deleted); $revision_name = static::_fieldRevisionTableName($storage_definition, $is_deleted); $this->database->update($table_name)->fields(array('bundle' => $bundle_new))->condition('bundle', $bundle)->execute(); $this->database->update($revision_name)->fields(array('bundle' => $bundle_new))->condition('bundle', $bundle)->execute(); } } }
/** * {@inheritdoc} */ public function releaseClaim($payment_id, $acquisition_code) { return (bool) $this->database->update('payment_queue', array('return' => Database::RETURN_AFFECTED))->condition('payment_id', $payment_id)->condition('acquisition_code', $acquisition_code)->condition('queue_id', $this->queueId)->fields(array('claimed' => 0))->execute(); }
/** * {@inheritdoc} */ public function updateMails($msids, array $data) { $this->connection->update('simplenews_mail_spool')->condition('msid', (array) $msids, 'IN')->fields(array('status' => $data['status'], 'error' => isset($result['error']) ? (int) $data['error'] : 0, 'timestamp' => REQUEST_TIME))->execute(); }