Connection::listPreparedTransactions() - Code Metrics - Inspection of "suggest auto-transactions" - ondrej-bouda/ivory - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a49ccc...dd28ca )

by Ondřej

created 2017-05-24 19:24 UTC

Connection::listPreparedTransactions() A

↳ Parent: Connection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
namespace Ivory\Connection;

use Ivory\Connection\Config\ConnConfig;
use Ivory\Connection\Config\IConnConfig;
use Ivory\Exception\StatementExceptionFactory;
use Ivory\Ivory;
use Ivory\Relation\ITuple;
use Ivory\Result\ICommandResult;
use Ivory\Result\ICopyInResult;
use Ivory\Result\IQueryResult;
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->ipcCtl = new IPCControl($this->connCtl);
        $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()
    {
        return $this->connCtl->isConnected();
    }

    public function isConnectedWait()
    {
        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)
    {
        $this->connCtl->registerConnectStartHook($closure);
    }

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

    public function registerPostDisconnectHook(\Closure $closure)
    {
        $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()
    {
        $this->typeCtl->flushTypeDictionary();
    }

    //endregion

    //region Statement Execution

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

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

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

    public function command($sqlFragmentPatternOrRecipe, ...$fragmentsAndParams): ICommandResult
    {
        return $this->stmtExec->command($sqlFragmentPatternOrRecipe, ...$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 rawMultiStatement($sqlStatements)
    {
        return $this->stmtExec->rawMultiStatement($sqlStatements);
    }

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

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

    //endregion

    //region Copy Control

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

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

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

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

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

    public function copyToArray(string $table, $options = [])
    {
        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)
    {
        $this->txCtl->setupSubsequentTransactions($transactionOptions);
    }

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

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

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

    //endregion

    //region Transaction observing

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

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

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

    //endregion

    //region IPC Control

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

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

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

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

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

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

ondrej-bouda / ivory

Push — master ( a49ccc...dd28ca )

Connection::listPreparedTransactions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like