Connection::getDefaultTxConfig() - Code Metrics - Inspection of "move IConnConfig::getDefaultTxConfig() to ITransac..." - ondrej-bouda/ivory - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5f3c84...0c19f1 )

by Ondřej

created 2017-12-14 22:13 UTC

Connection::getDefaultTxConfig() A

↳ Parent: Connection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php
declare(strict_types=1);

namespace Ivory\Connection;

use Ivory\Connection\Config\ConnConfig;
use Ivory\Connection\Config\IConnConfig;
use Ivory\Exception\StatementExceptionFactory;
use Ivory\Ivory;
use Ivory\Relation\IColumn;
use Ivory\Relation\ITuple;
use Ivory\Result\ICommandResult;
use Ivory\Result\ICopyInResult;
use Ivory\Result\IQueryResult;
use Ivory\Result\IResult;
use Ivory\Type\ITypeDictionary;
use Ivory\Type\TypeRegister;
use Ivory\Utils\NotSerializable;

// TODO: consider renaming to Database or Session or... - to reflect it is mere a facade, the single entry point
class Connection implements IConnection
{
    use NotSerializable; // TODO: implement connection serialization instead of giving up

    private $name;
    private $connCtl;
    private $typeCtl;
    private $stmtExec;
    private $copyCtl;
    private $txCtl;
    private $ipcCtl;
    private $cacheCtl;

    private $config;


    /**
     * @param string $name name for the connection
     * @param ConnectionParameters|array|string $params either a connection parameters object, or an associative array
     *                                                    of parameters for {@link ConnectionParameters::__construct()},
     *                                                    or a URL for {@link ConnectionParameters::fromUrl()},
     *                                                    or a PostgreSQL connection string (see {@link pg_connect()})
     */
    public function __construct(string $name, $params)
    {
        $this->name = $name;
        $this->connCtl = new ConnectionControl($this, $params); // TODO: extract all usages of ConnectionControl::requireConnection() - consider introducing an interface specifying the method, named like PGSQLDriver or ConnectionManager or ConnectionPool
        $this->typeCtl = new TypeControl($this, $this->connCtl);
        $this->stmtExec = new StatementExecution($this->connCtl, $this->typeCtl);
        $this->copyCtl = new CopyControl();
        $this->txCtl = new TransactionControl($this->connCtl, $this->stmtExec, $this);
        $this->ipcCtl = new IPCControl($this->connCtl, $this->stmtExec);
        $this->config = new ConnConfig($this->connCtl, $this->stmtExec, $this->txCtl);
        $this->cacheCtl = Ivory::getCoreFactory()->createCacheControl($this); // TODO: consider moving cacheCtl initialization out of Connection itself (let the core factory set it up), or do not hold cache control here but rather besides the connection register at Ivory
    }

    final public function getName(): string
    {
        return $this->name;
    }

    final public function getConfig(): IConnConfig
    {
        return $this->config;
    }


    //region Connection Control

    public function getParameters(): ConnectionParameters
    {
        return $this->connCtl->getParameters();
    }

    public function isConnected(): ?bool
    {
        return $this->connCtl->isConnected();
    }

    public function isConnectedWait(): ?bool
    {
        return $this->connCtl->isConnectedWait();
    }

    public function connect(?\Closure $initProcedure = null): bool
    {
        return $this->connCtl->connect($initProcedure);
    }

    public function connectWait(): bool
    {
        return $this->connCtl->connectWait();
    }

    public function disconnect(): bool
    {
        return $this->connCtl->disconnect();
    }

    public function registerConnectStartHook(\Closure $closure): void
    {
        $this->connCtl->registerConnectStartHook($closure);
    }

    public function registerPreDisconnectHook(\Closure $closure): void
    {
        $this->connCtl->registerPreDisconnectHook($closure);
    }

    public function registerPostDisconnectHook(\Closure $closure): void
    {
        $this->connCtl->registerPostDisconnectHook($closure);
    }

    //endregion

    //region Type Control

    public function getTypeRegister(): TypeRegister
    {
        return $this->typeCtl->getTypeRegister();
    }

    public function getTypeDictionary(): ITypeDictionary
    {
        return $this->typeCtl->getTypeDictionary();
    }

    public function flushTypeDictionary(): void
    {
        $this->typeCtl->flushTypeDictionary();
    }

    public function setTypeControlOption(int $option): void
    {
        $this->typeCtl->setTypeControlOption($option);
    }

    public function unsetTypeControlOption(int $option): void
    {
        $this->typeCtl->unsetTypeControlOption($option);
    }

    //endregion

    //region Statement Execution

    public function query($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): IQueryResult
    {
        return $this->stmtExec->query($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
    }

    public function querySingleTuple($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): ITuple
    {
        return $this->stmtExec->querySingleTuple($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
    }

    public function querySingleColumn($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): IColumn
    {
        return $this->stmtExec->querySingleColumn($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
    }

    public function querySingleValue($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams)
    {
        return $this->stmtExec->querySingleValue($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
    }

    public function command($sqlFragmentPatternOrCommand, ...$fragmentsAndParams): ICommandResult
    {
        return $this->stmtExec->command($sqlFragmentPatternOrCommand, ...$fragmentsAndParams);
    }

    public function rawQuery(string $sqlQuery): IQueryResult
    {
        return $this->stmtExec->rawQuery($sqlQuery);
    }

    public function rawCommand(string $sqlCommand): ICommandResult
    {
        return $this->stmtExec->rawCommand($sqlCommand);
    }

    public function executeStatement($sqlStatement): IResult
    {
        return $this->stmtExec->executeStatement($sqlStatement);
    }

    public function runScript(string $sqlScript): array
    {
        return $this->stmtExec->runScript($sqlScript);
    }

    public function getStatementExceptionFactory(): StatementExceptionFactory
    {
        return $this->stmtExec->getStatementExceptionFactory();
    }

    //endregion

    //region Copy Control

    public function copyFromFile(string $file, string $table, ?array $columns = null, array $options = []): ICommandResult
    {
        return $this->copyCtl->copyFromFile($file, $table, $columns, $options);
    }

    public function copyFromProgram(string $program, string $table, ?array $columns = null, array $options = []): ICommandResult
    {
        return $this->copyCtl->copyFromProgram($program, $table, $columns, $options);
    }

    public function copyFromInput(string $table, ?array $columns = null, array $options = []): ICopyInResult
    {
        return $this->copyCtl->copyFromInput($table, $columns, $options);
    }

    public function copyToFile(string $file, $tableOrRelationDefinition, ?array $columns = null, array $options = []): ICommandResult
    {
        return $this->copyCtl->copyToFile($file, $tableOrRelationDefinition, $columns, $options);
    }

    public function copyToProgram(string $program, $tableOrRelationDefinition, ?array $columns = null, array $options = []): ICommandResult
    {
        return $this->copyCtl->copyToProgram($program, $tableOrRelationDefinition, $columns, $options);
    }

    public function copyToArray(string $table, array $options = []): array
    {
        return $this->copyCtl->copyToArray($table, $options);
    }

    //endregion

    //region Transaction Control

    public function inTransaction(): bool
    {
        return $this->txCtl->inTransaction();
    }

    public function startTransaction($transactionOptions = 0): ITxHandle
    {
        return $this->txCtl->startTransaction($transactionOptions);
    }

    public function setupSubsequentTransactions($transactionOptions): void
    {
        $this->txCtl->setupSubsequentTransactions($transactionOptions);
    }

    public function getDefaultTxConfig(): TxConfig
    {
        return $this->txCtl->getDefaultTxConfig();
    }

    public function commitPreparedTransaction(string $name): void
    {
        $this->txCtl->commitPreparedTransaction($name);
    }

    public function rollbackPreparedTransaction(string $name): void
    {
        $this->txCtl->rollbackPreparedTransaction($name);
    }

    public function listPreparedTransactions(): IQueryResult
    {
        return $this->txCtl->listPreparedTransactions();
    }

    //endregion

    //region Transaction observing

    public function addTransactionControlObserver(ITransactionControlObserver $observer): void
    {
        $this->txCtl->addObserver($observer);
    }

    public function removeTransactionControlObserver(ITransactionControlObserver $observer): void
    {
        $this->txCtl->removeObserver($observer);
    }

    public function removeAllTransactionControlObservers(): void
    {
        $this->txCtl->removeAllObservers();
    }

    //endregion

    //region IPC Control

    public function getBackendPID(): int
    {
        return $this->ipcCtl->getBackendPID();
    }

    public function notify(string $channel, ?string $payload = null): void
    {
        $this->ipcCtl->notify($channel, $payload);
    }

    public function listen(string $channel): void
    {
        $this->ipcCtl->listen($channel);
    }

    public function unlisten(string $channel): void
    {
        $this->ipcCtl->unlisten($channel);
    }

    public function unlistenAll(): void
    {
        $this->ipcCtl->unlistenAll();
    }

    public function pollNotification(): ?Notification
    {
        return $this->ipcCtl->pollNotification();
    }

    //endregion

    //region Cache Control

    public function isCacheEnabled(): bool
    {
        return $this->cacheCtl->isCacheEnabled();
    }

    public function cachePermanently(string $cacheKey, $object): bool
    {
        return $this->cacheCtl->cachePermanently($cacheKey, $object);
    }

    public function getCached(string $cacheKey)
    {
        return $this->cacheCtl->getCached($cacheKey);
    }

    public function flushCache(string $cacheKey): bool
    {
        return $this->cacheCtl->flushCache($cacheKey);
    }

    //endregion
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Ivory\Connection;
5
6			use Ivory\Connection\Config\ConnConfig;
7			use Ivory\Connection\Config\IConnConfig;
8			use Ivory\Exception\StatementExceptionFactory;
9			use Ivory\Ivory;
10			use Ivory\Relation\IColumn;
11			use Ivory\Relation\ITuple;
12			use Ivory\Result\ICommandResult;
13			use Ivory\Result\ICopyInResult;
14			use Ivory\Result\IQueryResult;
15			use Ivory\Result\IResult;
16			use Ivory\Type\ITypeDictionary;
17			use Ivory\Type\TypeRegister;
18			use Ivory\Utils\NotSerializable;
19
20			// TODO: consider renaming to Database or Session or... - to reflect it is mere a facade, the single entry point
21			class Connection implements IConnection
22			{
23			use NotSerializable; // TODO: implement connection serialization instead of giving up
24
25			private $name;
26			private $connCtl;
27			private $typeCtl;
28			private $stmtExec;
29			private $copyCtl;
30			private $txCtl;
31			private $ipcCtl;
32			private $cacheCtl;
33
34			private $config;
35
36
37			/**
38			* @param string $name name for the connection
39			* @param ConnectionParameters\|array\|string $params either a connection parameters object, or an associative array
40			* of parameters for {@link ConnectionParameters::__construct()},
41			* or a URL for {@link ConnectionParameters::fromUrl()},
42			* or a PostgreSQL connection string (see {@link pg_connect()})
43			*/
44			public function __construct(string $name, $params)
45			{
46			$this->name = $name;
47			$this->connCtl = new ConnectionControl($this, $params); // TODO: extract all usages of ConnectionControl::requireConnection() - consider introducing an interface specifying the method, named like PGSQLDriver or ConnectionManager or ConnectionPool
48			$this->typeCtl = new TypeControl($this, $this->connCtl);
49			$this->stmtExec = new StatementExecution($this->connCtl, $this->typeCtl);
50			$this->copyCtl = new CopyControl();
51			$this->txCtl = new TransactionControl($this->connCtl, $this->stmtExec, $this);
52			$this->ipcCtl = new IPCControl($this->connCtl, $this->stmtExec);
53			$this->config = new ConnConfig($this->connCtl, $this->stmtExec, $this->txCtl);
54			$this->cacheCtl = Ivory::getCoreFactory()->createCacheControl($this); // TODO: consider moving cacheCtl initialization out of Connection itself (let the core factory set it up), or do not hold cache control here but rather besides the connection register at Ivory
55			}
56
57			final public function getName(): string
58			{
59			return $this->name;
60			}
61
62			final public function getConfig(): IConnConfig
63			{
64			return $this->config;
65			}
66
67
68			//region Connection Control
69
70			public function getParameters(): ConnectionParameters
71			{
72			return $this->connCtl->getParameters();
73			}
74
75			public function isConnected(): ?bool
76			{
77			return $this->connCtl->isConnected();
78			}
79
80			public function isConnectedWait(): ?bool
81			{
82			return $this->connCtl->isConnectedWait();
83			}
84
85			public function connect(?\Closure $initProcedure = null): bool
86			{
87			return $this->connCtl->connect($initProcedure);
88			}
89
90			public function connectWait(): bool
91			{
92			return $this->connCtl->connectWait();
93			}
94
95			public function disconnect(): bool
96			{
97			return $this->connCtl->disconnect();
98			}
99
100			public function registerConnectStartHook(\Closure $closure): void
101			{
102			$this->connCtl->registerConnectStartHook($closure);
103			}
104
105			public function registerPreDisconnectHook(\Closure $closure): void
106			{
107			$this->connCtl->registerPreDisconnectHook($closure);
108			}
109
110			public function registerPostDisconnectHook(\Closure $closure): void
111			{
112			$this->connCtl->registerPostDisconnectHook($closure);
113			}
114
115			//endregion
116
117			//region Type Control
118
119			public function getTypeRegister(): TypeRegister
120			{
121			return $this->typeCtl->getTypeRegister();
122			}
123
124			public function getTypeDictionary(): ITypeDictionary
125			{
126			return $this->typeCtl->getTypeDictionary();
127			}
128
129			public function flushTypeDictionary(): void
130			{
131			$this->typeCtl->flushTypeDictionary();
132			}
133
134			public function setTypeControlOption(int $option): void
135			{
136			$this->typeCtl->setTypeControlOption($option);
137			}
138
139			public function unsetTypeControlOption(int $option): void
140			{
141			$this->typeCtl->unsetTypeControlOption($option);
142			}
143
144			//endregion
145
146			//region Statement Execution
147
148			public function query($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): IQueryResult
149			{
150			return $this->stmtExec->query($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
151			}
152
153			public function querySingleTuple($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): ITuple
154			{
155			return $this->stmtExec->querySingleTuple($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
156			}
157
158			public function querySingleColumn($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams): IColumn
159			{
160			return $this->stmtExec->querySingleColumn($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
161			}
162
163			public function querySingleValue($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams)
164			{
165			return $this->stmtExec->querySingleValue($sqlFragmentPatternOrRelationDefinition, ...$fragmentsAndParams);
166			}
167
168			public function command($sqlFragmentPatternOrCommand, ...$fragmentsAndParams): ICommandResult
169			{
170			return $this->stmtExec->command($sqlFragmentPatternOrCommand, ...$fragmentsAndParams);
171			}
172
173			public function rawQuery(string $sqlQuery): IQueryResult
174			{
175			return $this->stmtExec->rawQuery($sqlQuery);
176			}
177
178			public function rawCommand(string $sqlCommand): ICommandResult
179			{
180			return $this->stmtExec->rawCommand($sqlCommand);
181			}
182
183			public function executeStatement($sqlStatement): IResult
184			{
185			return $this->stmtExec->executeStatement($sqlStatement);
186			}
187
188			public function runScript(string $sqlScript): array
189			{
190			return $this->stmtExec->runScript($sqlScript);
191			}
192
193			public function getStatementExceptionFactory(): StatementExceptionFactory
194			{
195			return $this->stmtExec->getStatementExceptionFactory();
196			}
197
198			//endregion
199
200			//region Copy Control
201
202			public function copyFromFile(string $file, string $table, ?array $columns = null, array $options = []): ICommandResult
203			{
204			return $this->copyCtl->copyFromFile($file, $table, $columns, $options);
205			}
206
207			public function copyFromProgram(string $program, string $table, ?array $columns = null, array $options = []): ICommandResult
208			{
209			return $this->copyCtl->copyFromProgram($program, $table, $columns, $options);
210			}
211
212			public function copyFromInput(string $table, ?array $columns = null, array $options = []): ICopyInResult
213			{
214			return $this->copyCtl->copyFromInput($table, $columns, $options);
215			}
216
217			public function copyToFile(string $file, $tableOrRelationDefinition, ?array $columns = null, array $options = []): ICommandResult
218			{
219			return $this->copyCtl->copyToFile($file, $tableOrRelationDefinition, $columns, $options);
220			}
221
222			public function copyToProgram(string $program, $tableOrRelationDefinition, ?array $columns = null, array $options = []): ICommandResult
223			{
224			return $this->copyCtl->copyToProgram($program, $tableOrRelationDefinition, $columns, $options);
225			}
226
227			public function copyToArray(string $table, array $options = []): array
228			{
229			return $this->copyCtl->copyToArray($table, $options);
230			}
231
232			//endregion
233
234			//region Transaction Control
235
236			public function inTransaction(): bool
237			{
238			return $this->txCtl->inTransaction();
239			}
240
241			public function startTransaction($transactionOptions = 0): ITxHandle
242			{
243			return $this->txCtl->startTransaction($transactionOptions);
244			}
245
246			public function setupSubsequentTransactions($transactionOptions): void
247			{
248			$this->txCtl->setupSubsequentTransactions($transactionOptions);
249			}
250
251			public function getDefaultTxConfig(): TxConfig
252			{
253			return $this->txCtl->getDefaultTxConfig();
254			}
255
256			public function commitPreparedTransaction(string $name): void
257			{
258			$this->txCtl->commitPreparedTransaction($name);
259			}
260
261			public function rollbackPreparedTransaction(string $name): void
262			{
263			$this->txCtl->rollbackPreparedTransaction($name);
264			}
265
266			public function listPreparedTransactions(): IQueryResult
267			{
268			return $this->txCtl->listPreparedTransactions();
269			}
270
271			//endregion
272
273			//region Transaction observing
274
275			public function addTransactionControlObserver(ITransactionControlObserver $observer): void
276			{
277			$this->txCtl->addObserver($observer);
278			}
279
280			public function removeTransactionControlObserver(ITransactionControlObserver $observer): void
281			{
282			$this->txCtl->removeObserver($observer);
283			}
284
285			public function removeAllTransactionControlObservers(): void
286			{
287			$this->txCtl->removeAllObservers();
288			}
289
290			//endregion
291
292			//region IPC Control
293
294			public function getBackendPID(): int
295			{
296			return $this->ipcCtl->getBackendPID();
297			}
298
299			public function notify(string $channel, ?string $payload = null): void
300			{
301			$this->ipcCtl->notify($channel, $payload);
302			}
303
304			public function listen(string $channel): void
305			{
306			$this->ipcCtl->listen($channel);
307			}
308
309			public function unlisten(string $channel): void
310			{
311			$this->ipcCtl->unlisten($channel);
312			}
313
314			public function unlistenAll(): void
315			{
316			$this->ipcCtl->unlistenAll();
317			}
318
319			public function pollNotification(): ?Notification
320			{
321			return $this->ipcCtl->pollNotification();
322			}
323
324			//endregion
325
326			//region Cache Control
327
328			public function isCacheEnabled(): bool
329			{
330			return $this->cacheCtl->isCacheEnabled();
331			}
332
333			public function cachePermanently(string $cacheKey, $object): bool
334			{
335			return $this->cacheCtl->cachePermanently($cacheKey, $object);
336			}
337
338			public function getCached(string $cacheKey)
339			{
340			return $this->cacheCtl->getCached($cacheKey);
341			}
342
343			public function flushCache(string $cacheKey): bool
344			{
345			return $this->cacheCtl->flushCache($cacheKey);
346			}
347
348			//endregion
349			}
350

ondrej-bouda / ivory

Push — master ( 5f3c84...0c19f1 )

Connection::getDefaultTxConfig() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like