Connection::querySingleColumn() - Code Metrics - Inspection of "extend ITxHandle::prepareTransaction() to generate..." - ondrej-bouda/ivory - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6001b7...42953d )

by Ondřej

created 2017-12-05 00:14 UTC

Connection::querySingleColumn() 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	2

<?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->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(): ?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 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);
52			$this->ipcCtl = new IPCControl($this->connCtl);
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 commitPreparedTransaction(string $name): void
252			{
253			$this->txCtl->commitPreparedTransaction($name);
254			}
255
256			public function rollbackPreparedTransaction(string $name): void
257			{
258			$this->txCtl->rollbackPreparedTransaction($name);
259			}
260
261			public function listPreparedTransactions(): IQueryResult
262			{
263			return $this->txCtl->listPreparedTransactions();
264			}
265
266			//endregion
267
268			//region Transaction observing
269
270			public function addTransactionControlObserver(ITransactionControlObserver $observer): void
271			{
272			$this->txCtl->addObserver($observer);
273			}
274
275			public function removeTransactionControlObserver(ITransactionControlObserver $observer): void
276			{
277			$this->txCtl->removeObserver($observer);
278			}
279
280			public function removeAllTransactionControlObservers(): void
281			{
282			$this->txCtl->removeAllObservers();
283			}
284
285			//endregion
286
287			//region IPC Control
288
289			public function getBackendPID(): int
290			{
291			return $this->ipcCtl->getBackendPID();
292			}
293
294			public function notify(string $channel, ?string $payload = null): void
295			{
296			$this->ipcCtl->notify($channel, $payload);
297			}
298
299			public function listen(string $channel): void
300			{
301			$this->ipcCtl->listen($channel);
302			}
303
304			public function unlisten(string $channel): void
305			{
306			$this->ipcCtl->unlisten($channel);
307			}
308
309			public function unlistenAll(): void
310			{
311			$this->ipcCtl->unlistenAll();
312			}
313
314			public function pollNotification(): ?Notification
315			{
316			return $this->ipcCtl->pollNotification();
317			}
318
319			//endregion
320
321			//region Cache Control
322
323			public function isCacheEnabled(): bool
324			{
325			return $this->cacheCtl->isCacheEnabled();
326			}
327
328			public function cachePermanently(string $cacheKey, $object): bool
329			{
330			return $this->cacheCtl->cachePermanently($cacheKey, $object);
331			}
332
333			public function getCached(string $cacheKey)
334			{
335			return $this->cacheCtl->getCached($cacheKey);
336			}
337
338			public function flushCache(string $cacheKey): bool
339			{
340			return $this->cacheCtl->flushCache($cacheKey);
341			}
342
343			//endregion
344			}
345

ondrej-bouda / ivory

Push — master ( 6001b7...42953d )

Connection::querySingleColumn() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like