SqlModuleDependencyStore.php

Go to the documentation of this file.

<?php
namespace Wikimedia\DependencyStore;
 
use InvalidArgumentException;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IReadableDatabase;
 
class SqlModuleDependencyStore extends DependencyStore {
    private $lb;
 
    public function __construct( ILoadBalancer $lb ) {
        $this->lb = $lb;
    }
 
    public function retrieveMulti( $type, array $entities ) {
        $dbr = $this->getReplicaDb();
 
        $depsBlobByEntity = $this->fetchDependencyBlobs( $entities, $dbr );
 
        $storedPathsByEntity = [];
        foreach ( $depsBlobByEntity as $entity => $depsBlob ) {
            $storedPathsByEntity[$entity] = json_decode( $depsBlob, true );
        }
 
        $results = [];
        foreach ( $entities as $entity ) {
            $paths = $storedPathsByEntity[$entity] ?? [];
            $results[$entity] = $this->newEntityDependencies( $paths, null );
        }
 
        return $results;
    }
 
    public function storeMulti( $type, array $dataByEntity, $ttl ) {
        // Avoid opening a primary DB connection when it's not needed.
        // ResourceLoader::saveModuleDependenciesInternal calls this method unconditionally
        // with empty values most of the time.
        if ( !$dataByEntity ) {
            return;
        }
 
        $dbw = $this->getPrimaryDb();
        $depsBlobByEntity = $this->fetchDependencyBlobs( array_keys( $dataByEntity ), $dbw );
 
        $rows = [];
        foreach ( $dataByEntity as $entity => $data ) {
            [ $module, $variant ] = $this->getEntityNameComponents( $entity );
            if ( !is_array( $data[self::KEY_PATHS] ) ) {
                throw new InvalidArgumentException( "Invalid entry for '$entity'" );
            }
 
            // Normalize the list by removing duplicates and sortings
            $paths = array_values( array_unique( $data[self::KEY_PATHS] ) );
            sort( $paths, SORT_STRING );
            $blob = json_encode( $paths, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE );
 
            $existingBlob = $depsBlobByEntity[$entity] ?? null;
            if ( $blob !== $existingBlob ) {
                $rows[] = [
                    'md_module' => $module,
                    'md_skin' => $variant,
                    'md_deps' => $blob
                ];
            }
        }
 
        // @TODO: use a single query with VALUES()/aliases support in DB wrapper
        // See https://dev.mysql.com/doc/refman/8.0/en/insert-on-duplicate.html
        foreach ( $rows as $row ) {
            $dbw->newInsertQueryBuilder()
                ->insertInto( 'module_deps' )
                ->row( $row )
                ->onDuplicateKeyUpdate()
                ->uniqueIndexFields( [ 'md_module', 'md_skin' ] )
                ->set( [ 'md_deps' => $row['md_deps'] ] )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    public function remove( $type, $entities ) {
        // Avoid opening a primary DB connection when it's not needed.
        // ResourceLoader::saveModuleDependenciesInternal calls this method unconditionally
        // with empty values most of the time.
        if ( !$entities ) {
            return;
        }
 
        $dbw = $this->getPrimaryDb();
        $disjunctionConds = [];
        foreach ( (array)$entities as $entity ) {
            [ $module, $variant ] = $this->getEntityNameComponents( $entity );
            $disjunctionConds[] = $dbw
                ->expr( 'md_skin', '=', $variant )
                ->and( 'md_module', '=', $module );
        }
 
        if ( $disjunctionConds ) {
            $dbw->newDeleteQueryBuilder()
                ->deleteFrom( 'module_deps' )
                ->where( $dbw->orExpr( $disjunctionConds ) )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    private function fetchDependencyBlobs( array $entities, IReadableDatabase $db ) {
        $modulesByVariant = [];
        foreach ( $entities as $entity ) {
            [ $module, $variant ] = $this->getEntityNameComponents( $entity );
            $modulesByVariant[$variant][] = $module;
        }
 
        $disjunctionConds = [];
        foreach ( $modulesByVariant as $variant => $modules ) {
            $disjunctionConds[] = $db
                ->expr( 'md_skin', '=', $variant )
                ->and( 'md_module', '=', $modules );
        }
 
        $depsBlobByEntity = [];
 
        if ( $disjunctionConds ) {
            $res = $db->newSelectQueryBuilder()
                ->select( [ 'md_module', 'md_skin', 'md_deps' ] )
                ->from( 'module_deps' )
                ->where( $db->orExpr( $disjunctionConds ) )
                ->caller( __METHOD__ )->fetchResultSet();
 
            foreach ( $res as $row ) {
                $entity = "{$row->md_module}|{$row->md_skin}";
                $depsBlobByEntity[$entity] = $row->md_deps;
            }
        }
 
        return $depsBlobByEntity;
    }
 
    private function getReplicaDb() {
        return $this->lb
            ->getConnection( DB_REPLICA, [], false, ( $this->lb )::CONN_TRX_AUTOCOMMIT );
    }
 
    private function getPrimaryDb() {
        return $this->lb
            ->getConnection( DB_PRIMARY, [], false, ( $this->lb )::CONN_TRX_AUTOCOMMIT );
    }
 
    private function getEntityNameComponents( $entity ) {
        $parts = explode( '|', $entity, 2 );
        if ( count( $parts ) !== 2 ) {
            throw new InvalidArgumentException( "Invalid module entity '$entity'" );
        }
 
        return $parts;
    }
}