/**
*
* @param PWECore $PWE
* @param bool $forceNewConnection
* @param string $alias
* @return Connection
* @throws DBALException
*/
public static function getConnection(PWECore $PWE, $forceNewConnection = false, $alias = null)
{
if (!$forceNewConnection && self::$connection[$alias]) {
PWELogger::debug('Used cached connection');
return self::$connection[$alias];
}
$settings = $PWE->getModulesManager()->getModuleSettings(self::getClass());
$connections = $settings['!c']['connection'];
$ix = PWEXMLFunctions::findNodeWithAttributeValue($connections, 'alias', $alias);
if ($ix < 0) {
throw new \InvalidArgumentException("Alias {$alias} not found in database configs");
}
$params = $connections[$ix]['!a'];
$config = new Configuration();
$config->setSQLLogger(new PWEDoctrineLogger($alias ? $alias : ''));
PWELogger::debug("Getting connection: %s", $params);
self::$connection[$alias] = DriverManager::getConnection($params, $config);
return self::$connection[$alias];
}
public function register(Container $app)
{
$app['dbal.parameters'] = function ($app) {
$parameters = array('host' => 'localhost', 'port' => null, 'dbname' => null, 'user' => null, 'password' => null, 'driver' => 'pdo_mysql', 'unix_socket' => null, 'charset' => 'utf8');
foreach ($parameters as $key => $value) {
if (isset($app['dbal.' . $key])) {
$parameters[$key] = $app['dbal.' . $key];
}
}
return $parameters;
};
$app['dbal.event_manager'] = function ($app) {
return new EventManager();
};
$app['dbal.logger'] = function ($app) {
return new DBALLogger($app['logger']);
};
$app['dbal.configuration'] = function ($app) {
$cfg = new Configuration();
$cfg->setSqlLogger($app['dbal.logger']);
return $cfg;
};
$app['dbal'] = function ($app) {
return DriverManager::getConnection($app['dbal.parameters'], $app['dbal.configuration'], $app['dbal.event_manager']);
};
}
/**
* Get an instance of a DBAL Connection
*
* @param sting $name the connection name
* @return Doctrine\DBAL\Connection
*/
public function newConnection()
{
$configuration = new DBAL\Configuration();
$logger = new MSQLLogger($this);
$configuration->setSQLLogger($logger);
return DBAL\DriverManager::getConnection($this->config, $configuration);
}
/**
* Tests that the default auto-commit mode for connections can be set in the configuration container.
*
* @group DBAL-81
*/
public function testSetsDefaultConnectionAutoCommitMode()
{
$this->config->setAutoCommit(false);
$this->assertFalse($this->config->getAutoCommit());
$this->config->setAutoCommit(0);
$this->assertFalse($this->config->getAutoCommit());
}
/**
* setup configuration for Doctrine Dbal.
*
* @param array $db_config array config for override the default configuration.
*/
public function setupConfigurationDbal(array $db_config = [])
{
$dbal_config = new Configuration();
if (empty($db_config)) {
//setup connection configuration.
$config = new SystemConfig();
$config->load('db');
$db_params = $config->get('ALL', 'db');
unset($config, $db_params['table_prefix']);
} else {
$db_params = $db_config;
unset($db_params['table_prefix']);
}
$dbal_config->setSQLLogger(new \System\Libraries\Db\Logger());
try {
$this->Conn = DriverManager::getConnection($db_params, $dbal_config);
$this->Conn->connect();
} catch (\Doctrine\DBAL\DBALException $e) {
http_response_code(500);
echo $e->getMessage();
exit;
}
$this->Conn->setFetchMode(\PDO::FETCH_OBJ);
unset($dbal_config, $db_params);
}
/**
* @return \Doctrine\DBAL\Connection
* @throws \Doctrine\DBAL\DBALException
*/
private static function create()
{
$configuration = new Configuration();
$configuration->getSQLLogger(new EchoSQLLogger());
$parameters = ['dbname' => $_ENV['testsuite_db_name'], 'user' => $_ENV['testsuite_db_user'], 'password' => $_ENV['testsuite_db_password'], 'host' => $_ENV['testsuite_db_host'], 'driver' => 'pdo_mysql'];
$connection = DriverManager::getConnection($parameters, $configuration);
return $connection;
}
public function register()
{
$this->container->add('service.dbal.connection', function () {
$connectionParams = $this->container->get('config')['dbal']['connection']['params'];
$config = new Configuration();
$config->setSQLLogger(new DebugStack());
return DriverManager::getConnection($connectionParams, $config);
});
}
protected static function getFacadeAccessor()
{
if (!static::$__db) {
$configuration = new Configuration();
$logger = new base_database_logger();
$configuration->setSQLLogger($logger);
static::$__db = new base_database_manager($configuration);
}
return static::$__db;
}
public function getConn()
{
if (isset(static::$connection)) {
return static::$connection;
}
//set up a special logger that counts queries here
$configuration = new Configuration();
$configuration->setSQLLogger($this->getSQLLogger());
static::$connection = DriverManager::getConnection($this->getConnectionParams(), $configuration);
return static::$connection;
}
/**
* Get DBAL configuration object
* @param boolean $devMode Development mode enables a query logger
* @return Configuration
*/
protected function getConfig($devMode)
{
$config = new Configuration();
if ($devMode) {
//Create logger
$debugStack = new DebugStack();
$config->setSQLLogger($debugStack);
$this->app->instance('dbal.debug', $debugStack);
}
return $config;
}
/**
* @group DBAL-474
*/
public function testFiltersSequences()
{
$configuration = new Configuration();
$configuration->setFilterSchemaAssetsExpression('/^schema/');
$sequences = array(array('relname' => 'foo', 'schemaname' => 'schema'), array('relname' => 'bar', 'schemaname' => 'schema'), array('relname' => 'baz', 'schemaname' => ''), array('relname' => 'bloo', 'schemaname' => 'bloo_schema'));
$this->connection->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration));
$this->connection->expects($this->at(0))->method('fetchAll')->will($this->returnValue($sequences));
$this->connection->expects($this->at(1))->method('fetchAll')->will($this->returnValue(array(array('min_value' => 1, 'increment_by' => 1))));
$this->connection->expects($this->at(2))->method('fetchAll')->will($this->returnValue(array(array('min_value' => 2, 'increment_by' => 2))));
$this->connection->expects($this->exactly(3))->method('fetchAll');
$this->assertEquals(array(new Sequence('schema.foo', 2, 2), new Sequence('schema.bar', 1, 1)), $this->schemaManager->listSequences('database'));
}
/**
* @expectedException \Doctrine\DBAL\DBALException
*/
public function testExecuteCallsLoggerStopQueryOnException()
{
$logger = $this->getMock('\\Doctrine\\DBAL\\Logging\\SQLLogger');
$this->configuration->expects($this->once())->method('getSQLLogger')->will($this->returnValue($logger));
// Needed to satisfy construction of DBALException
$this->conn->expects($this->any())->method('resolveParams')->will($this->returnValue(array()));
$logger->expects($this->once())->method('startQuery');
$logger->expects($this->once())->method('stopQuery');
$this->pdoStatement->expects($this->once())->method('execute')->will($this->throwException(new \Exception("Mock test exception")));
$statement = new Statement("", $this->conn);
$statement->execute();
}
public function register()
{
$this->container['dbal_connection_params'] = function () {
return $this->container->get('config')['dbal']['connection']['params'];
};
$this->container['db_connection'] = function () {
$connectionParams = $this->container->get('dbal_connection_params');
$debugStack = new DebugStack();
$config = new Configuration();
$config->setSQLLogger($debugStack);
return DriverManager::getConnection($connectionParams, $config);
};
}
/**
* @param ServiceLocatorInterface $serviceLocator
* @param Configuration $config
*/
public function setupDBALConfiguration(ServiceLocatorInterface $serviceLocator, Configuration $config)
{
$options = $this->getOptions($serviceLocator);
$config->setResultCacheImpl($serviceLocator->get($options->resultCache));
$config->setSQLLogger($options->sqlLogger);
foreach ($options->types as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
}
public function testExecuteCallsLoggerStartQueryWithParametersWhenParamsPassedToExecute()
{
$name = 'foo';
$var = 'bar';
$values = array($name => $var);
$types = array();
$sql = '';
$logger = $this->getMock('\\Doctrine\\DBAL\\Logging\\SQLLogger');
$logger->expects($this->once())->method('startQuery')->with($this->equalTo($sql), $this->equalTo($values), $this->equalTo($types));
$this->configuration->expects($this->once())->method('getSQLLogger')->will($this->returnValue($logger));
$statement = new Statement($sql, $this->conn);
$statement->execute($values);
}
/**
* Creates a RepositoryFactory
*
* @param Container $container The container
*
* @return RepositoryFactory
*/
public function createRepositoryFactory(Container $container)
{
$config = parse_ini_file(JPATH_ROOT . '/config/database.ini', true);
$configuration = new Configuration();
// Add logger
$logger = new DebugStack();
$configuration->setSQLLogger($logger);
$connection = DriverManager::getConnection(['url' => $config['databaseUrl']], $configuration);
$transactor = new DoctrineTransactor($connection);
$repositoryFactory = new RepositoryFactory($config, $connection, $transactor);
if ($container->has('dispatcher')) {
$repositoryFactory->setDispatcher($container->get('dispatcher'));
}
return $repositoryFactory;
}
/**
* Cancel any database changes done during the current transaction.
*
* this method can be listened with onPreTransactionRollback and onTransactionRollback
* eventlistener methods
*
* @throws ConnectionException If the rollback operation failed.
*/
public function rollBack()
{
if ($this->_transactionNestingLevel == 0) {
throw ConnectionException::noActiveTransaction();
}
$this->connect();
$logger = $this->_config->getSQLLogger();
if ($this->_transactionNestingLevel == 1) {
if ($logger) {
$logger->startQuery('"ROLLBACK"');
}
$this->_transactionNestingLevel = 0;
$this->_conn->rollback();
$this->_isRollbackOnly = false;
if ($logger) {
$logger->stopQuery();
}
} else {
if ($this->_nestTransactionsWithSavepoints) {
if ($logger) {
$logger->startQuery('"ROLLBACK TO SAVEPOINT"');
}
$this->rollbackSavepoint($this->_getNestedTransactionSavePointName());
--$this->_transactionNestingLevel;
if ($logger) {
$logger->stopQuery();
}
} else {
$this->_isRollbackOnly = true;
--$this->_transactionNestingLevel;
}
}
}
/**
* Creates a new connection to the database
*
* @param Context $context
* @param array|Config $db_data
*/
public function __construct(Context $context, $db_data = [])
{
parent::__construct($context);
// load the defaults if the config object has been passed
if ($db_data instanceof Config) {
$db_data = $db_data->get('foolz/foolframe', 'db', 'default');
}
$config = new Configuration();
$config->setSQLLogger(new DoctrineLogger($context));
$data = ['dbname' => $db_data['dbname'], 'user' => $db_data['user'], 'password' => $db_data['password'], 'host' => $db_data['host'], 'driver' => $db_data['driver']];
if ($db_data['driver'] == 'pdo_mysql') {
$data['charset'] = $db_data['charset'];
}
$this->prefix = $db_data['prefix'];
$this->connection = DriverManager::getConnection($data, $config);
}
/**
* @param ContainerInterface $container
* @param Configuration $config
*/
public function setupDBALConfiguration(ContainerInterface $container, Configuration $config)
{
$options = $this->getOptions($container);
$config->setResultCacheImpl($container->get($options->resultCache));
$sqlLogger = $options->sqlLogger;
if (is_string($sqlLogger) and $container->has($sqlLogger)) {
$sqlLogger = $container->get($sqlLogger);
}
$config->setSQLLogger($sqlLogger);
foreach ($options->types as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
}
public function register(Neptune $neptune)
{
$neptune['db.config'] = function ($neptune) {
$config = $neptune['config']->get('neptune.database', []);
if (empty($config)) {
throw new ConfigKeyException('Database configuration is empty');
}
return $config;
};
$neptune['dbs'] = function ($neptune) {
$dbs = new Container();
$config = $neptune['db.config'];
//register types
if (isset($config['_types'])) {
foreach ($config['_types'] as $name => $classname) {
Type::addType($name, $classname);
}
unset($config['_types']);
}
foreach ($config as $name => $config) {
$dbs[$name] = function ($dbs) use($config, $neptune) {
$configuration = new Configuration();
if (isset($config['logger'])) {
$configuration->setSQLLogger(new PsrSqlLogger($neptune[$config['logger']]));
}
return DriverManager::getConnection($config, $configuration);
};
}
return $dbs;
};
//shortcut for the first database
$neptune['db'] = function ($neptune) {
$config = $neptune['db.config'];
reset($config);
$default = key($config);
return $neptune['dbs'][$default];
};
}
/**
* @param array
* @param \Doctrine\Common\EventManager|NULL
* @return \Doctrine\DBAL\Connection
*/
public static function createConnection(array $params, EventManager $evm)
{
$panel = NULL;
$config = new Configuration();
if (isset($params['debugger']) && $params['debugger'] === TRUE) {
$panel = new ConnectionPanel();
if (Debugger::$bar) {
Debugger::$bar->addPanel($panel);
}
Debugger::$blueScreen->addPanel(array($panel, 'renderException'));
$config->setSQLLogger($panel);
} else {
Debugger::$blueScreen->addPanel('Nette\\Database\\Diagnostics\\ConnectionPanel::renderException');
}
$cfg = $params['connection'];
$connection = DriverManager::getConnection($cfg, $config, $evm);
if ($connection->getDatabasePlatform()->getName() == 'mysql' && isset($cfg['charset'])) {
$evm->addEventSubscriber(new MysqlSessionInit($cfg['charset'], $cfg['collation']));
}
if ($panel && $panel->doExplains) {
$panel->setConnection($connection);
}
return $connection;
}
public function setSqlLogger(Doctrine\DBAL\Logging\SQLLogger $sqlLogger)
{
$this->entityManagerConfiguration->setSQLLogger($sqlLogger);
}
/**
* Initializes a new instance of the Connection class.
*
* @param array $params The connection parameters.
* @param \Doctrine\DBAL\Driver $driver The driver to use.
* @param \Doctrine\DBAL\Configuration|null $config The configuration, optional.
* @param \Doctrine\Common\EventManager|null $eventManager The event manager, optional.
*
* @throws \Doctrine\DBAL\DBALException
*/
public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null)
{
$this->_driver = $driver;
$this->_params = $params;
if (isset($params['pdo'])) {
$this->_conn = $params['pdo'];
$this->_isConnected = true;
}
// Create default config and event manager if none given
if (!$config) {
$config = new Configuration();
}
if (!$eventManager) {
$eventManager = new EventManager();
}
$this->_config = $config;
$this->_eventManager = $eventManager;
$this->_expr = new Query\Expression\ExpressionBuilder($this);
if (!isset($params['platform'])) {
$this->_platform = $driver->getDatabasePlatform();
} elseif ($params['platform'] instanceof Platforms\AbstractPlatform) {
$this->_platform = $params['platform'];
} else {
throw DBALException::invalidPlatformSpecified();
}
$this->_platform->setEventManager($eventManager);
$this->_transactionIsolationLevel = $this->_platform->getDefaultTransactionIsolationLevel();
$this->autoCommit = $config->getAutoCommit();
}
/**
* Initialize the panel (set a SQL logger)
*
* @param Configuration $doctrineConfiguration The doctrine configuration
* @param string $name The name of the panel (Useful if you watch multiple Doctrine instance)
*/
public function __construct(Configuration $doctrineConfiguration, $name = '')
{
$doctrineConfiguration->setSQLLogger(new DebugStack());
$this->doctrineConfiguration = $doctrineConfiguration;
$this->name = $name;
}
/**
* Initializes a new instance of the Connection class.
*
* @param array $params The connection parameters.
* @param \Doctrine\DBAL\Driver $driver The driver to use.
* @param \Doctrine\DBAL\Configuration|null $config The configuration, optional.
* @param \Doctrine\Common\EventManager|null $eventManager The event manager, optional.
*
* @throws \Doctrine\DBAL\DBALException
*/
public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null)
{
$this->_driver = $driver;
$this->_params = $params;
if (isset($params['pdo'])) {
$this->_conn = $params['pdo'];
$this->_isConnected = true;
unset($this->_params['pdo']);
}
// Create default config and event manager if none given
if (!$config) {
$config = new Configuration();
}
if (!$eventManager) {
$eventManager = new EventManager();
}
$this->_config = $config;
$this->_eventManager = $eventManager;
$this->_expr = new Query\Expression\ExpressionBuilder($this);
$this->autoCommit = $config->getAutoCommit();
}
/**
* Initializes a new instance of the Connection class.
*
* @param array $params The connection parameters.
* @param Driver $driver
* @param Configuration $config
* @param EventManager $eventManager
*/
public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null)
{
$this->_driver = $driver;
$this->_params = $params;
if (isset($params['pdo'])) {
$this->_conn = $params['pdo'];
$this->_isConnected = true;
}
// Create default config and event manager if none given
if (!$config) {
$config = new Configuration();
}
if (!$eventManager) {
$eventManager = new EventManager();
}
$this->_config = $config;
$this->_eventManager = $eventManager;
$this->_platform = $driver->getDatabasePlatform();
$this->_transactionIsolationLevel = $this->_platform->getDefaultTransactionIsolationLevel();
$this->_quoteIdentifiers = $config->getQuoteIdentifiers();
$this->_platform->setQuoteIdentifiers($this->_quoteIdentifiers);
}
public function addMysqlFunctions()
{
$this->config->addCustomNumericFunction('RAND', DoctrineFunctions\Mysql\Rand::class);
$this->config->addCustomNumericFunction('DISTANCE', DoctrineFunctions\Mysql\Distance::class);
}
/**
* Creates a new configuration that can be used for Doctrine.
*/
public function __construct()
{
parent::__construct();
$this->_attributes = array_merge($this->_attributes, array('resultCacheImpl' => null, 'queryCacheImpl' => null, 'metadataCacheImpl' => null, 'metadataDriverImpl' => null, 'proxyDir' => null, 'useCExtension' => false, 'autoGenerateProxyClasses' => true, 'proxyNamespace' => null));
}
/**
* @throws \Doctrine\DBAL\DBALException
*/
protected function connect()
{
$config = new DBAL\Configuration();
if ($this->appMode === ApplicationMode::DEVELOPMENT) {
$config->setSQLLogger(new SQLLogger($this->logger));
}
$config->setResultCacheImpl($this->cacheDriverFactory->create('db-queries'));
return DBAL\DriverManager::getConnection($this->connectionParams, $config);
}
/**
* Executes an SQL statement, returning a result set as a Statement object.
*
* @return \Doctrine\DBAL\Driver\Statement
*
* @throws \Doctrine\DBAL\DBALException
*/
public function query()
{
$this->connect();
$args = func_get_args();
$logger = $this->_config->getSQLLogger();
if ($logger) {
$logger->startQuery($args[0]);
}
try {
switch (func_num_args()) {
case 1:
$statement = $this->_conn->query($args[0]);
break;
case 2:
$statement = $this->_conn->query($args[0], $args[1]);
break;
default:
$statement = call_user_func_array(array($this->_conn, 'query'), $args);
break;
}
} catch (\Exception $ex) {
throw DBALException::driverExceptionDuringQuery($this->_driver, $ex, $args[0]);
}
$statement->setFetchMode($this->defaultFetchMode);
if ($logger) {
$logger->stopQuery();
}
return $statement;
}
