8.3.x database.inc db_update($table, array $options = [])
8.0.x database.inc db_update($table, array $options = array())
8.1.x database.inc db_update($table, array $options = array())
8.2.x database.inc db_update($table, array $options = array())
8.4.x database.inc db_update($table, array $options = [])
7.x database.inc db_update($table, array $options = array())

Returns a new UpdateQuery object for the active database.


string $table: The table to update.

array $options: An array of options to control how the query operates.

Return value

\Drupal\Core\Database\Query\Update A new Update object for this connection.


as of Drupal 8.0.x, will be removed in Drupal 9.0.0. Instead, get a database connection injected into your service from the container and call update() on it. For example, $injected_database->update($table, $options);

See also



Related topics

48 calls to db_update()
AggregatorCronTest::testCron in core/modules/aggregator/src/Tests/AggregatorCronTest.php
Adds feeds and updates them via cron process.
DatabaseStorageTest::update in core/tests/Drupal/KernelTests/Core/Config/Storage/DatabaseStorageTest.php
DeleteTest::testInUse in core/modules/file/tests/src/Kernel/DeleteTest.php
Tries deleting a file that is in use.
drupal-7.contact.database.php in core/modules/contact/tests/drupal-7.contact.database.php
Database additions for Drupal\contact\Tests\ContactUpgradePathTest.
FileFieldRevisionTest::testRevisions in core/modules/file/src/Tests/FileFieldRevisionTest.php
Tests creating multiple revisions of a node and managing attached files.

... See full list


core/includes/database.inc, line 209
Core systems for the database layer.


function db_update($table, array $options = array()) {
  if (empty($options['target']) || $options['target'] == 'replica') {
    $options['target'] = 'default';
  return Database::getConnection($options['target'])->update($table, $options);


Dinesh18’s picture

$query = \Drupal::database()->update('file_managed');
'uri' =>$uri,

jp.stacey’s picture

The previous comment is OK in module or other procedural code, but in object-oriented code (e.g. a custom block or other plugin, or a custom service) you should always use dependency injection:

use Drupal\Core\Database\Connection;
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class MyObject implements ContainerInjectionInterface {

  /* Dependency injection boilerplate begins. */
  protected $databaseConnection;

  public static function create(ContainerInterface $container) {
    return new static($container->get('database'));

  public function __construct(Connection $databaseConnection) {
    $this->databaseConnection = $databaseConnection;
  /* Boilerplate ends. */

  /* Your custom code. */
  public function someOtherCode(/* ... */) {
    $query = $this->databaseConnection->update(/* ... */);
    /* etc. */

If your class defines a plugin, you need to implement ContainerFactoryPluginInterface instead, which has a little bit more boilerplate but the same principle; example here.