8.5.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.3.x database.inc db_update($table, array $options = [])
8.4.x database.inc db_update($table, array $options = [])
8.6.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.

Parameters

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.

Deprecated

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

\Drupal\Core\Database\Connection::update()

\Drupal\Core\Database\Connection::defaultOptions()

Related topics

1 call to db_update()
LocaleUpdateCronTest::testUpdateCron in core/modules/locale/src/Tests/LocaleUpdateCronTest.php
Tests interface translation update using cron.

File

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

Code

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

Comments

Dinesh18’s picture

$query = \Drupal::database()->update('file_managed');
$query->fields([
'uri' =>$uri,
]);
$query->condition('fid',$fid);
$query->execute();

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.

dahousecat’s picture

I can use the dependency injection example in my own controller, but when my class extends ContentEntityBase (e.g. is a custom entity type) the __construct already has other variables being passed in.
Could you provide an example of how to use dependency injection to access the databaseConnection from within a class that extends ContentEntityBase?