DatabaseDomain.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms;
 
use InvalidArgumentException;
 
class DatabaseDomain {
    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.' );
        } elseif ( $prefix !== '' && substr( $prefix, -1, 1 ) !== '_' ) {
            throw new InvalidArgumentException( 'A non-empty prefix must end with "_".' );
        }
        $this->prefix = $prefix;
    }
 
    public static function newFromId( $domain ) {
        if ( $domain instanceof self ) {
            return $domain;
        }
 
        $parts = array_map( [ __CLASS__, 'decode' ], explode( '-', $domain ) );
 
        $schema = null;
        $prefix = '';
 
        if ( count( $parts ) == 1 ) {
            $database = $parts[0];
        } elseif ( count( $parts ) == 2 ) {
            list( $database, $prefix ) = $parts;
        } elseif ( count( $parts ) == 3 ) {
            list( $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;
        }
 
        return new self( $database, $schema, $prefix );
    }
 
    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() {
        if ( $this->equivalentString === null ) {
            $this->equivalentString = $this->convertToString();
        }
 
        return $this->equivalentString;
    }
 
    private function convertToString() {
        $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;
        }
 
        return implode( '-', array_map( [ __CLASS__, 'encode' ], $parts ) );
    }
 
    private static function encode( $decoded ) {
        $encoded = '';
 
        $length = strlen( $decoded );
        for ( $i = 0; $i < $length; ++$i ) {
            $char = $decoded[$i];
            if ( $char === '-' ) {
                $encoded .= '?h';
            } elseif ( $char === '?' ) {
                $encoded .= '??';
            } else {
                $encoded .= $char;
            }
        }
 
        return $encoded;
    }
 
    private static function decode( $encoded ) {
        $decoded = '';
 
        $length = strlen( $encoded );
        for ( $i = 0; $i < $length; ++$i ) {
            $char = $encoded[$i];
            if ( $char === '?' ) {
                $nextChar = $encoded[$i + 1] ?? null;
                if ( $nextChar === 'h' ) {
                    $decoded .= '-';
                    ++$i;
                } elseif ( $nextChar === '?' ) {
                    $decoded .= '?';
                    ++$i;
                } else {
                    $decoded .= $char;
                }
            } else {
                $decoded .= $char;
            }
        }
 
        return $decoded;
    }
 
    function __toString() {
        return $this->getId();
    }
}