DatabaseFactory.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms;
 
use InvalidArgumentException;
use Psr\Log\NullLogger;
use Throwable;
use Wikimedia\ObjectCache\HashBagOStuff;
use Wikimedia\RequestTimeout\CriticalSectionProvider;
use Wikimedia\Telemetry\NoopTracer;
use Wikimedia\Telemetry\TracerInterface;
 
class DatabaseFactory {
    private $agent;
    private $deprecationLogger;
    private $profiler;
    private $tracer;
    private $csProvider;
    private $cliMode;
    private $debugSql;
 
    public function __construct( array $params = [] ) {
        $this->agent = $params['agent'] ?? '';
        $this->deprecationLogger = $params['deprecationLogger'] ?? static function ( $msg ) {
            trigger_error( $msg, E_USER_DEPRECATED );
        };
        $this->csProvider = $params['criticalSectionProvider'] ?? null;
        $this->profiler = $params['profiler'] ?? null;
        $this->tracer = $params['tracer'] ?? new NoopTracer();
        $this->cliMode = $params['cliMode'] ?? ( PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg' );
        $this->debugSql = $params['debugSql'] ?? false;
    }
 
    public function create( $type, $params = [], $connect = Database::NEW_CONNECTED ) {
        $class = $this->getClass( $type, $params['driver'] ?? null );
 
        if ( class_exists( $class ) && is_subclass_of( $class, IDatabase::class ) ) {
            $params += [
                // Default configuration
                'host' => null,
                'user' => null,
                'password' => null,
                'dbname' => null,
                'schema' => null,
                'tablePrefix' => '',
                'variables' => [],
                'lbInfo' => [],
                'serverName' => null,
                'topologyRole' => null,
                // Objects and callbacks
                'srvCache' => $params['srvCache'] ?? new HashBagOStuff(),
                'trxProfiler' => $params['trxProfiler'] ?? new TransactionProfiler(),
                'logger' => $params['logger'] ?? new NullLogger(),
                'errorLogger' => $params['errorLogger'] ?? static function ( Throwable $e ) {
                    trigger_error( get_class( $e ) . ': ' . $e->getMessage(), E_USER_WARNING );
                },
            ];
 
            $params['flags'] ??= 0;
            if ( $this->debugSql ) {
                $params['flags'] |= DBO_DEBUG;
            }
 
            $overrides = [
                'flags' => $this->initConnectionFlags( $params['flags'] ),
                'cliMode' => $this->cliMode,
                'agent' => $this->agent,
                'profiler' => $this->profiler,
                'deprecationLogger' => $this->deprecationLogger,
                'criticalSectionProvider' => $this->csProvider,
                'tracer' => $this->tracer,
            ];
 
            $conn = new $class( array_merge( $params, $overrides ) );
            if ( $connect === Database::NEW_CONNECTED ) {
                $conn->initConnection();
            }
        } else {
            $conn = null;
        }
 
        return $conn;
    }
 
    public function attributesFromType( $dbType, $driver = null ) {
        static $defaults = [
            Database::ATTR_DB_IS_FILE => false,
            Database::ATTR_DB_LEVEL_LOCKING => false,
            Database::ATTR_SCHEMAS_AS_TABLE_GROUPS => false
        ];
 
        $class = $this->getClass( $dbType, $driver );
        if ( class_exists( $class ) ) {
            return call_user_func( [ $class, 'getAttributes' ] ) + $defaults;
        } else {
            throw new DBUnexpectedError( null, "$dbType is not a supported database type." );
        }
    }
 
    protected function getClass( $dbType, $driver = null ) {
        // For database types with built-in support, the below maps type to IDatabase
        // implementations. For types with multiple driver implementations (PHP extensions),
        // an array can be used, keyed by extension name. In case of an array, the
        // optional 'driver' parameter can be used to force a specific driver. Otherwise,
        // we auto-detect the first available driver. For types without built-in support,
        // a class named "Database<Type>" is used, eg. DatabaseFoo for type 'foo'.
        static $builtinTypes = [
            'mysql' => [ 'mysqli' => DatabaseMySQL::class ],
            'sqlite' => DatabaseSqlite::class,
            'postgres' => DatabasePostgres::class,
        ];
 
        $dbType = strtolower( $dbType );
 
        if ( !isset( $builtinTypes[$dbType] ) ) {
            // Not a built in type, assume standard naming scheme
            return 'Database' . ucfirst( $dbType );
        }
 
        $class = false;
        $possibleDrivers = $builtinTypes[$dbType];
        if ( is_string( $possibleDrivers ) ) {
            $class = $possibleDrivers;
        } elseif ( (string)$driver !== '' ) {
            if ( !isset( $possibleDrivers[$driver] ) ) {
                throw new InvalidArgumentException( __METHOD__ .
                    " type '$dbType' does not support driver '{$driver}'" );
            }
 
            $class = $possibleDrivers[$driver];
        } else {
            foreach ( $possibleDrivers as $posDriver => $possibleClass ) {
                if ( extension_loaded( $posDriver ) ) {
                    $class = $possibleClass;
                    break;
                }
            }
        }
 
        if ( $class === false ) {
            throw new InvalidArgumentException( __METHOD__ .
                " no viable database extension found for type '$dbType'" );
        }
 
        return $class;
    }
 
    private function initConnectionFlags( int $flags ) {
        if ( self::fieldHasBit( $flags, IDatabase::DBO_DEFAULT ) ) {
            // Server is configured to participate in transaction rounds in non-CLI mode
            if ( $this->cliMode ) {
                $flags &= ~IDatabase::DBO_TRX;
            } else {
                $flags |= IDatabase::DBO_TRX;
            }
        }
        return $flags;
    }
 
    private function fieldHasBit( int $flags, int $bit ) {
        return ( ( $flags & $bit ) === $bit );
    }
}