241 lines
5.1 KiB
PHP
241 lines
5.1 KiB
PHP
<?php declare(strict_types=1);
|
|
/**
|
|
* Query
|
|
*
|
|
* SQL Query Builder / Database Abstraction Layer
|
|
*
|
|
* PHP version 7.4
|
|
*
|
|
* @package Query
|
|
* @author Timothy J. Warren <tim@timshomepage.net>
|
|
* @copyright 2012 - 2020 Timothy J. Warren
|
|
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
|
* @link https://git.timshomepage.net/aviat/Query
|
|
* @version 3.0.0
|
|
*/
|
|
namespace Query;
|
|
|
|
use DomainException;
|
|
use stdClass;
|
|
|
|
/**
|
|
* Connection manager class to manage connections for the
|
|
* Query method
|
|
*/
|
|
final class ConnectionManager {
|
|
|
|
/**
|
|
* Map of named database connections
|
|
* @var array
|
|
*/
|
|
private array $connections = [];
|
|
|
|
/**
|
|
* Class instance variable
|
|
* @var ConnectionManager|null
|
|
*/
|
|
private static ?ConnectionManager $instance = NULL;
|
|
|
|
/**
|
|
* Private constructor to prevent multiple instances
|
|
* @codeCoverageIgnore
|
|
*/
|
|
private function __construct()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Private clone method to prevent cloning
|
|
*
|
|
* @throws DomainException
|
|
* @return void
|
|
*/
|
|
public function __clone()
|
|
{
|
|
throw new DomainException("Can't clone singleton");
|
|
}
|
|
|
|
/**
|
|
* Prevent serialization of this object
|
|
*
|
|
* @throws DomainException
|
|
*/
|
|
public function __sleep()
|
|
{
|
|
throw new DomainException('No serializing of singleton');
|
|
}
|
|
|
|
/**
|
|
* Make sure serialize/deserialize doesn't work
|
|
*
|
|
* @throws DomainException
|
|
* @return void
|
|
*/
|
|
public function __wakeup(): void
|
|
{
|
|
throw new DomainException("Can't unserialize singleton");
|
|
}
|
|
|
|
/**
|
|
* Return a connection manager instance
|
|
*
|
|
* @staticvar null $instance
|
|
* @return ConnectionManager
|
|
*/
|
|
public static function getInstance(): ConnectionManager
|
|
{
|
|
if (self::$instance === NULL)
|
|
{
|
|
self::$instance = new self();
|
|
}
|
|
|
|
return self::$instance;
|
|
}
|
|
|
|
/**
|
|
* Returns the connection specified by the name given
|
|
*
|
|
* @param string|array|object $name
|
|
* @return QueryBuilderInterface
|
|
* @throws Exception\NonExistentConnectionException
|
|
*/
|
|
public function getConnection($name = ''): QueryBuilderInterface
|
|
{
|
|
// If the parameter is a string, use it as an array index
|
|
if (is_scalar($name) && isset($this->connections[$name]))
|
|
{
|
|
return $this->connections[$name];
|
|
}
|
|
|
|
if (empty($name) && ! empty($this->connections)) // Otherwise, return the last one
|
|
{
|
|
return end($this->connections);
|
|
}
|
|
|
|
// You should actually connect before trying to get a connection...
|
|
throw new Exception\NonExistentConnectionException('The specified connection does not exist');
|
|
}
|
|
|
|
/**
|
|
* Parse the passed parameters and return a connection
|
|
*
|
|
* @param array|object $params
|
|
* @throws Exception\BadDBDriverException
|
|
* @return QueryBuilderInterface
|
|
*/
|
|
public function connect($params): QueryBuilderInterface
|
|
{
|
|
[$dsn, $dbType, $params, $options] = $this->parseParams($params);
|
|
|
|
$dbType = ucfirst($dbType);
|
|
$driver = "\\Query\\Drivers\\{$dbType}\\Driver";
|
|
|
|
// Create the database connection
|
|
$db = ! empty($params->user)
|
|
? new $driver($dsn, $params->user, $params->pass, $options)
|
|
: new $driver($dsn, '', '', $options);
|
|
|
|
// Set the table prefix, if it exists
|
|
if (isset($params->prefix))
|
|
{
|
|
$db->setTablePrefix($params->prefix);
|
|
}
|
|
|
|
// Create Query Builder object
|
|
$conn = new QueryBuilder($db, new QueryParser($db));
|
|
|
|
|
|
// Save it for later
|
|
if (isset($params->alias))
|
|
{
|
|
$this->connections[$params->alias] = $conn;
|
|
}
|
|
else
|
|
{
|
|
$this->connections[] = $conn;
|
|
}
|
|
|
|
return $conn;
|
|
}
|
|
|
|
/**
|
|
* Parses params into a dsn and option array
|
|
*
|
|
* @param array|object $rawParams
|
|
* @return array
|
|
* @throws Exception\BadDBDriverException
|
|
*/
|
|
public function parseParams($rawParams): array
|
|
{
|
|
$params = (object) $rawParams;
|
|
$params->type = strtolower($params->type);
|
|
$dbType = ($params->type === 'postgresql') ? 'pgsql' : $params->type;
|
|
$dbType = ucfirst($dbType);
|
|
|
|
// Make sure the class exists
|
|
if ( ! class_exists("\\Query\\Drivers\\{$dbType}\\Driver"))
|
|
{
|
|
throw new Exception\BadDBDriverException('Database driver does not exist, or is not supported');
|
|
}
|
|
|
|
// Set additional PDO options
|
|
$options = [];
|
|
|
|
if (isset($params->options))
|
|
{
|
|
$options = (array) $params->options;
|
|
}
|
|
|
|
// Create the dsn for the database to connect to
|
|
if(strtolower($dbType) === 'sqlite')
|
|
{
|
|
$dsn = $params->file;
|
|
}
|
|
else
|
|
{
|
|
$dsn = $this->createDsn($dbType, $params);
|
|
}
|
|
|
|
|
|
return [$dsn, $dbType, $params, $options];
|
|
}
|
|
|
|
/**
|
|
* Create the dsn from the db type and params
|
|
*
|
|
* @codeCoverageIgnore
|
|
* @param string $dbType
|
|
* @param stdClass $params
|
|
* @return string
|
|
*/
|
|
private function createDsn(string $dbType, stdClass $params): string
|
|
{
|
|
$pairs = [];
|
|
|
|
if ( ! empty($params->database))
|
|
{
|
|
$pairs[] = implode('=', ['dbname', $params->database]);
|
|
}
|
|
|
|
$skip = [
|
|
'name' => 'name',
|
|
'pass' => 'pass',
|
|
'user' => 'user',
|
|
'type' => 'type',
|
|
'prefix' => 'prefix',
|
|
'options' => 'options',
|
|
'database' => 'database',
|
|
'alias' => 'alias'
|
|
];
|
|
|
|
foreach($params as $key => $val)
|
|
{
|
|
if (( ! array_key_exists($key, $skip)) && ! empty($val))
|
|
{
|
|
$pairs[] = implode('=', [$key, $val]);
|
|
}
|
|
}
|
|
|
|
return strtolower($dbType) . ':' . implode(';', $pairs);
|
|
}
|
|
} |