Connection::queryOneTuple() - Code Metrics - Inspection of "introduce IStatementExecution::queryOneTuple()" - ondrej-bouda/ivory - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1763ff...752297 )

by Ondřej

created 2017-02-18 22:57 UTC

Connection::queryOneTuple() 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
namespace Ivory\Connection;

use Ivory\Exception\StatementExceptionFactory;
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 $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($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);
    }

    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(): bool
    {
        return $this->connCtl->connect();
    }

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

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

    //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 queryOneTuple($sqlFragmentPatternOrRecipe, ...$fragmentsAndParams): ITuple
    {
        return $this->stmtExec->queryOneTuple($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): bool
    {
        return $this->txCtl->startTransaction($transactionOptions);
    }

    public function setupTransaction($transactionOptions)
    {
        $this->txCtl->setupTransaction($transactionOptions);
    }

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

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

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

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

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

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

    public function setTransactionSnapshot(string $snapshotId): bool
    {
        return $this->txCtl->setTransactionSnapshot($snapshotId);
    }

    public function exportTransactionSnapshot()
    {
        return $this->txCtl->exportTransactionSnapshot();
    }

    public function prepareTransaction(string $name): bool
    {
        return $this->txCtl->prepareTransaction($name);
    }

    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 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
}


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

ondrej-bouda / ivory

Push — master ( 1763ff...752297 )

Connection::queryOneTuple() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like