DatabaseDomain.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms;
 
use InvalidArgumentException;
use Stringable;
 
class DatabaseDomain implements Stringable {
    private $database;
    private $schema;
    private $prefix;
 
    private $equivalentString;
 
    public function __construct( $database, $schema, $prefix ) {
        if ( $database !== null && ( !is_string( $database ) || $database === '' ) ) {
            throw new InvalidArgumentException( 'Database must be null or a non-empty string.' );
        }
        $this->database = $database;
        if ( $schema !== null && ( !is_string( $schema ) || $schema === '' ) ) {
            throw new InvalidArgumentException( 'Schema must be null or a non-empty string.' );
        } elseif ( $database === null && $schema !== null ) {
            throw new InvalidArgumentException( 'Schema must be null if database is null.' );
        }
        $this->schema = $schema;
        if ( !is_string( $prefix ) ) {
            throw new InvalidArgumentException( "Prefix must be a string." );
        }
        $this->prefix = $prefix;
    }
 
    public static function newFromId( $domain ): self {
        if ( $domain instanceof self ) {
            return $domain;
        }
 
        if ( !is_string( $domain ) ) {
            throw new InvalidArgumentException( "Domain must be a string or " . __CLASS__ );
        }
 
        $parts = explode( '-', $domain );
        foreach ( $parts as &$part ) {
            $part = strtr( $part, [ '?h' => '-', '??' => '?' ] );
        }
 
        $schema = null;
        $prefix = '';
 
        if ( count( $parts ) == 1 ) {
            $database = $parts[0];
        } elseif ( count( $parts ) == 2 ) {
            [ $database, $prefix ] = $parts;
        } elseif ( count( $parts ) == 3 ) {
            [ $database, $schema, $prefix ] = $parts;
        } else {
            throw new InvalidArgumentException( "Domain '$domain' has too few or too many parts." );
        }
 
        if ( $database === '' ) {
            $database = null;
        }
 
        if ( $schema === '' ) {
            $schema = null;
        }
 
        $instance = new self( $database, $schema, $prefix );
        $instance->equivalentString = $domain;
 
        return $instance;
    }
 
    public static function newUnspecified() {
        return new self( null, null, '' );
    }
 
    public function equals( $other ) {
        if ( $other instanceof self ) {
            return (
                $this->database === $other->database &&
                $this->schema === $other->schema &&
                $this->prefix === $other->prefix
            );
        }
 
        return ( $this->getId() === $other );
    }
 
    public function isCompatible( $other ) {
        if ( $this->isUnspecified() ) {
            return true; // even the prefix doesn't matter
        }
 
        $other = self::newFromId( $other );
 
        return (
            ( $this->database === $other->database || $this->database === null ) &&
            ( $this->schema === $other->schema || $this->schema === null ) &&
            $this->prefix === $other->prefix
        );
    }
 
    public function isUnspecified() {
        return (
            $this->database === null && $this->schema === null && $this->prefix === ''
        );
    }
 
    public function getDatabase() {
        return $this->database;
    }
 
    public function getSchema() {
        return $this->schema;
    }
 
    public function getTablePrefix() {
        return $this->prefix;
    }
 
    public function getId(): string {
        $this->equivalentString ??= $this->convertToString();
 
        return $this->equivalentString;
    }
 
    private function convertToString(): string {
        $parts = [ (string)$this->database ];
        if ( $this->schema !== null ) {
            $parts[] = $this->schema;
        }
        if ( $this->prefix != '' || $this->schema !== null ) {
            // If there is a schema, then we need the prefix to disambiguate.
            // For engines like Postgres that use schemas, this awkwardness is hopefully
            // avoided since it is easy to have one DB per server (to avoid having many users)
            // and use schema/prefix to have wiki farms. For example, a domain schemes could be
            // wiki-<project>-<language>, e.g. "wiki-fitness-es"/"wiki-sports-fr"/"wiki-news-en".
            $parts[] = $this->prefix;
        }
 
        foreach ( $parts as &$part ) {
            $part = strtr( $part, [ '-' => '?h', '?' => '??' ] );
        }
        return implode( '-', $parts );
    }
 
    public function __toString() {
        return $this->getId();
    }
}