$database = null;
}
+ if ( $schema === '' ) {
+ $schema = null;
+ }
+
return new self( $database, $schema, $prefix );
}
/**
* @param DatabaseDomain|string $other
- * @return bool
+ * @return bool Whether the domain instances are the same by value
*/
public function equals( $other ) {
- if ( $other instanceof DatabaseDomain ) {
+ if ( $other instanceof self ) {
return (
$this->database === $other->database &&
$this->schema === $other->schema &&
return ( $this->getId() === $other );
}
+ /**
+ * Check whether the domain $other meets the specifications of this domain
+ *
+ * If this instance has a null database specifier, then $other can have any database
+ * specified, including the null, and likewise if the schema specifier is null. This
+ * is not transitive like equals() since a domain that explicitly wants a certain
+ * database or schema cannot be satisfied by one of another (nor null). If the prefix
+ * is empty and the DB and schema are both null, then the entire domain is considered
+ * unspecified, and any prefix of $other is considered compatible.
+ *
+ * @param DatabaseDomain|string $other
+ * @return bool
+ * @since 1.32
+ */
+ public function isCompatible( $other ) {
+ if ( $this->isUnspecified() ) {
+ return true; // even the prefix doesn't matter
+ }
+
+ $other = ( $other instanceof self ) ? $other : self::newFromId( $other );
+
+ return (
+ ( $this->database === $other->database || $this->database === null ) &&
+ ( $this->schema === $other->schema || $this->schema === null ) &&
+ $this->prefix === $other->prefix
+ );
+ }
+
+ /**
+ * @return bool
+ * @since 1.32
+ */
+ public function isUnspecified() {
+ return (
+ $this->database === null && $this->schema === null && $this->prefix === ''
+ );
+ }
+
/**
* @return string|null Database name
*/
if ( $this->schema !== null ) {
$parts[] = $this->schema;
}
- if ( $this->prefix != '' ) {
+ 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;
}
$this->assertSame( null, $domain->getSchema() );
$this->assertSame( '', $domain->getTablePrefix() );
}
+
+ public static function provideIsCompatible() {
+ return [
+ 'Basic' =>
+ [ 'foo', 'foo', null, '', true ],
+ 'db+prefix' =>
+ [ 'foo-bar', 'foo', null, 'bar', true ],
+ 'db+schema+prefix' =>
+ [ 'foo-bar-baz', 'foo', 'bar', 'baz', true ],
+ 'db+dontcare_schema+prefix' =>
+ [ 'foo-bar-baz', 'foo', null, 'baz', false ],
+ '?h -> -' =>
+ [ 'foo?hbar-baz-baa', 'foo-bar', 'baz', 'baa', true ],
+ '?? -> ?' =>
+ [ 'foo??bar-baz-baa', 'foo?bar', 'baz', 'baa', true ],
+ 'Nothing' =>
+ [ '', null, null, '', true ],
+ 'dontcaredb+dontcaredbschema+prefix' =>
+ [ 'mywiki-mediawiki-prefix', null, null, 'prefix', false ],
+ 'dontcaredb+schema+prefix' =>
+ [ 'mywiki-schema-prefix', null, 'schema', 'prefix', false ],
+ 'db+dontcareschema+prefix' =>
+ [ 'mywiki-schema-prefix', 'mywiki', null, 'prefix', false ],
+ 'postgres-db-jobqueue' =>
+ [ 'postgres-mediawiki-', 'postgres', null, '', false ]
+ ];
+ }
+
+ /**
+ * @dataProvider provideIsCompatible
+ * @covers Wikimedia\Rdbms\DatabaseDomain::isCompatible
+ */
+ public function testIsCompatible( $id, $db, $schema, $prefix, $transitive ) {
+ $compareIdObj = DatabaseDomain::newFromId( $id );
+ $this->assertInstanceOf( DatabaseDomain::class, $compareIdObj );
+
+ $fromId = new DatabaseDomain( $db, $schema, $prefix );
+
+ $this->assertTrue( $fromId->isCompatible( $id ), 'constructed equals string' );
+ $this->assertTrue( $fromId->isCompatible( $compareIdObj ), 'fromId equals string' );
+
+ $this->assertEquals( $transitive, $compareIdObj->isCompatible( $fromId ),
+ 'test transitivity of nulls components' );
+ }
+
+ public static function provideIsCompatible2() {
+ return [
+ 'db+schema+prefix' =>
+ [ 'mywiki-schema-prefix', 'thatwiki', 'schema', 'prefix' ],
+ 'dontcaredb+dontcaredbschema+prefix' =>
+ [ 'thatwiki-mediawiki-otherprefix', null, null, 'prefix' ],
+ 'dontcaredb+schema+prefix' =>
+ [ 'mywiki-otherschema-prefix', null, 'schema', 'prefix' ],
+ 'db+dontcareschema+prefix' =>
+ [ 'notmywiki-schema-prefix', 'mywiki', null, 'prefix' ],
+ ];
+ }
+
+ /**
+ * @dataProvider provideIsCompatible2
+ * @covers Wikimedia\Rdbms\DatabaseDomain::isCompatible
+ */
+ public function testIsCompatible2( $id, $db, $schema, $prefix ) {
+ $compareIdObj = DatabaseDomain::newFromId( $id );
+ $this->assertInstanceOf( DatabaseDomain::class, $compareIdObj );
+
+ $fromId = new DatabaseDomain( $db, $schema, $prefix );
+
+ $this->assertFalse( $fromId->isCompatible( $id ), 'constructed equals string' );
+ $this->assertFalse( $fromId->isCompatible( $compareIdObj ), 'fromId equals string' );
+ }
+
+ /**
+ * @covers Wikimedia\Rdbms\DatabaseDomain::isUnspecified
+ */
+ public function testIsUnspecified() {
+ $domain = new DatabaseDomain( null, null, '' );
+ $this->assertTrue( $domain->isUnspecified() );
+ $domain = new DatabaseDomain( 'mywiki', null, '' );
+ $this->assertFalse( $domain->isUnspecified() );
+ $domain = new DatabaseDomain( 'mywiki', null, '' );
+ $this->assertFalse( $domain->isUnspecified() );
+ }
}