Connection - Code Metrics - Inspection of "fix callback duplication" - lroman242/laravel-cassandra - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — testing ( 88fcdf...a661a9 )

by Roman

created 2019-04-30 19:45 UTC

Connection B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	365
Duplicated Lines	1.64 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	52
lcom	1
cbo	4
dl	6
loc	365
rs	7.44
c	0
b	0
f	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	26	5
A	table()	0	8	1
A	getCassandraCluster()	0	4	1
A	getCassandraSession()	0	4	1
A	getKeyspace()	0	4	1
F	createCluster()	6	65	25
A	disconnect()	0	4	1
A	getDriverName()	0	4	1
A	select()	0	4	1
A	insertBulk()	0	4	1
A	batchStatement()	0	17	3
A	statement()	0	4	1
A	affectingStatement()	0	4	1
A	getDefaultPostProcessor()	0	4	1
A	getDefaultQueryGrammar()	0	4	1
A	getDefaultSchemaGrammar()	0	4	1
A	reconnectIfMissingConnection()	0	6	2
A	__call()	0	4	1
A	runStatement()	0	17	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Connection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Connection, and based on these observations, apply Extract Interface, too.

<?php

namespace lroman242\LaravelCassandra;

use Cassandra;
use Cassandra\BatchStatement;
use Closure;

class Connection extends \Illuminate\Database\Connection
{
    const DEFAULT_PAGE_SIZE = 5000;
    
    /**
     * The Cassandra keyspace
     *
     * @var string
     */
    protected $keyspace;

    /**
     * The Cassandra cluster
     *
     * @var \Cassandra\Cluster
     */
    protected $cluster;

    /**
     * The Cassandra connection handler.
     *
     * @var \Cassandra\Session
     */
    protected $session;

    /**
     * The config
     *
     * @var array
     */
    protected $config;

    /**
     * Create a new database connection instance.
     *
     * @param  array   $config
     */
    public function __construct(array $config)
    {
        $this->config = $config;
        if (empty($this->config['page_size'])) {
            $this->config['page_size'] = self::DEFAULT_PAGE_SIZE;
        }

        // You can pass options directly to the Cassandra constructor
        $options = array_get($config, 'options', []);

        // Create the connection
        $this->cluster = $this->createCluster($config, $options);

        if (isset($options['database']) || isset($config['keyspace'])) {
            $keyspaceName = isset($options['database']) ? $options['database'] : $config['keyspace'];

            $this->keyspace = $keyspaceName;
            $this->session = $this->cluster->connect($keyspaceName);
        }

        $this->useDefaultPostProcessor();

        $this->useDefaultSchemaGrammar();

        $this->setQueryGrammar($this->getDefaultQueryGrammar());
    }

    /**
     * Begin a fluent query against a database table.
     *
     * @param  string  $table
     * @return Query\Builder
     */
    public function table($table)
    {
        $processor = $this->getPostProcessor();

        $query = new Query\Builder($this, null, $processor);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $query->from($table);
    }

    /**
     * return Cassandra cluster.
     *
     * @return \Cassandra\Cluster
     */
    public function getCassandraCluster()
    {
        return $this->cluster;
    }

    /**
     * return Cassandra Session.
     *
     * @return \Cassandra\Session
     */
    public function getCassandraSession()
    {
        return $this->session;
    }

    /**
     * Return the Cassandra keyspace
     *
     * @return string
     */
    public function getKeyspace()
    {
        return $this->keyspace;
    }

    /**
     * Create a new Cassandra cluster object.
     *
     * @param  array   $config
     * @param  array   $options
     * @return \Cassandra\Cluster
     */
    protected function createCluster(array $config, array $options)
    {
        $cluster = Cassandra::cluster();

        // Check if the credentials are not already set in the options
        if (!isset($options['username']) && !empty($config['username'])) {
            $options['username'] = $config['username'];
        }
        if (!isset($options['password']) && !empty($config['password'])) {
            $options['password'] = $config['password'];
        }

        // Authentication
        if (isset($options['username']) && isset($options['password'])) {
            $cluster->withCredentials($options['username'], $options['password']);
        }

        // Contact Points/Host
        if (isset($options['contactpoints']) || (isset($config['host']) && !empty($config['host']))) {
            $contactPoints = $config['host'];

            if (isset($options['contactpoints'])) {
                $contactPoints = $options['contactpoints'];
            }

            if (is_array($contactPoints)) {
                $contactPoints = implode(',', $contactPoints);
            }

            $contactPoints = !empty($contactPoints) ? $contactPoints : '127.0.0.1';

            $cluster->withContactPoints($contactPoints);
        }

        if (!isset($options['port']) && !empty($config['port'])) {
            $cluster->withPort((int) $config['port']);
        }

        if (array_key_exists('page_size', $config) && !empty($config['page_size'])) {
            $cluster->withDefaultPageSize(intval($config['page_size'] ?? self::DEFAULT_PAGE_SIZE));
        }

        if (array_key_exists('consistency', $config) && in_array(strtoupper($config['consistency']), [
                Cassandra::CONSISTENCY_ANY, Cassandra::CONSISTENCY_ONE, Cassandra::CONSISTENCY_TWO,
                Cassandra::CONSISTENCY_THREE, Cassandra::CONSISTENCY_QUORUM, Cassandra::CONSISTENCY_ALL,
                Cassandra::CONSISTENCY_SERIAL, Cassandra::CONSISTENCY_QUORUM, Cassandra::CONSISTENCY_LOCAL_QUORUM,
                Cassandra::CONSISTENCY_EACH_QUORUM, Cassandra::CONSISTENCY_LOCAL_SERIAL, Cassandra::CONSISTENCY_LOCAL_ONE,
            ])) {
            $cluster->withDefaultConsistency($config['consistency']);
        }

        if (array_key_exists('timeout', $config) && !empty($config['timeout'])) {
            $cluster->withDefaultTimeout(intval($config['timeout']));
        }

        if (array_key_exists('connect_timeout', $config) && !empty($config['connect_timeout'])) {
            $cluster->withConnectTimeout(floatval($config['connect_timeout']));
        }

        if (array_key_exists('request_timeout', $config) && !empty($config['request_timeout'])) {
            $cluster->withRequestTimeout(floatval($config['request_timeout']));
        }

        return $cluster->build();
    }

    /**
     * Disconnect from the underlying Cassandra connection.
     */
    public function disconnect()
    {
        unset($this->connection);
    }

    /**
     * Get the PDO driver name.
     *
     * @return string
     */
    public function getDriverName()
    {
        return 'cassandra';
    }

    /**
     * Run a select statement against the database.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  bool  $useReadPdo
     * @param  array  $customOptions
     *
     * @return array
     */
    public function select($query, $bindings = [], $useReadPdo = true, array $customOptions = [])
    {
        return $this->runStatement($query, $bindings, $customOptions);
    }

    /**
     * Run an bulk insert statement against the database.
     *
     * @param  array  $queries
     * @param  array  $bindings
     * @param  int  $type
     * @param  array  $customOptions
     *
     * @return bool
     */
    public function insertBulk($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED, array $customOptions = [])
    {
        return $this->batchStatement($queries, $bindings, $type, $customOptions);
    }

    /**
     * Execute a group of queries inside a batch statement against the database.
     *
     * @param  array  $queries
     * @param  array  $bindings
     * @param  int  $type
     * @param  array  $customOptions
     *
     * @return bool
     */
    public function batchStatement($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED, array $customOptions = [])
    {
        return $this->run($queries, $bindings, function ($queries, $bindings) use ($type, $customOptions) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            if ($this->pretending()) {
                return [];
            }

            $batch = new BatchStatement($type);

            foreach ($queries as $k => $query) {
                $preparedStatement = $this->session->prepare($query);
                $batch->add($preparedStatement, $bindings[$k]);
            }

            return $this->session->execute($batch, $customOptions);
        });
    }

    /**
     * Execute an CQL statement and return the boolean result.
     *
     * @param  string  $query
     * @param  array   $bindings
     * @param  array  $customOptions
     *
     * @return bool
     */
    public function statement($query, $bindings = [], array $customOptions = [])
    {
        return $this->runStatement($query, $bindings, $customOptions);
    }

    /**
     * Because Cassandra is an eventually consistent database, it's not possible to obtain
     * the affected count for statements so we're just going to return 0, based on the idea
     * that if the query fails somehow, an exception will be thrown
     *
     * @param  string  $query
     * @param  array   $bindings
     * @param  array  $customOptions
     *
     * @return int
     */
    public function affectingStatement($query, $bindings = [], array $customOptions = [])
    {
        return $this->runStatement($query, $bindings, $customOptions, 0, 1);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @inheritdoc
     */
    protected function getDefaultPostProcessor()
    {
        return new Query\Processor();
    }

    /**
     * @inheritdoc
     */
    protected function getDefaultQueryGrammar()
    {
        return new Query\Grammar();
    }

    /**
     * @inheritdoc
     */
    protected function getDefaultSchemaGrammar()
    {
        //return new Schema\Grammar();
    }

    /**
     * Reconnect to the database if connection is missing.
     *
     * @return void
     */
    protected function reconnectIfMissingConnection()
    {
        if (is_null($this->session)) {
            $this->session = $this->createCluster($this->config, [])->connect($this->keyspace);
        }
    }

    /**
     * Dynamically pass methods to the connection.
     *
     * @param  string  $method
     * @param  array   $parameters
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        return call_user_func_array([$this->cluster, $method], $parameters);
    }

    /**
     * Execute an CQL statement and return the boolean result.
     *
     * @param $query
     * @param array $bindings
     * @param array $customOptions
     * @param array $defaultFailed
     * @param null $defaultSuccess
     *
     * @return mixed
     */
    protected function runStatement($query, $bindings = [], array $customOptions = [], $defaultFailed = [], $defaultSuccess = null)
    {
        return $this->run($query, $bindings, function ($query, $bindings) use ($defaultFailed, $customOptions, $defaultFailed, $defaultSuccess) {
            if ($this->pretending()) {
                return $defaultFailed;
            }

            $preparedStatement = $this->session->prepare($query);

            //Add bindings
            $customOptions['arguments'] = $bindings;

            $result = $this->session->execute($preparedStatement, $customOptions);

            return $defaultSuccess === null ? $result : $defaultSuccess;
        });
    }
}


1		<?php
2
3		namespace lroman242\LaravelCassandra;
4
5		use Cassandra;
6		use Cassandra\BatchStatement;
7		use Closure;
8
9		class Connection extends \Illuminate\Database\Connection
10		{
11		const DEFAULT_PAGE_SIZE = 5000;
12
13		/**
14		* The Cassandra keyspace
15		*
16		* @var string
17		*/
18		protected $keyspace;
19
20		/**
21		* The Cassandra cluster
22		*
23		* @var \Cassandra\Cluster
24		*/
25		protected $cluster;
26
27		/**
28		* The Cassandra connection handler.
29		*
30		* @var \Cassandra\Session
31		*/
32		protected $session;
33
34		/**
35		* The config
36		*
37		* @var array
38		*/
39		protected $config;
40
41		/**
42		* Create a new database connection instance.
43		*
44		* @param array $config
45		*/
46		public function __construct(array $config)
47		{
48		$this->config = $config;
49		if (empty($this->config['page_size'])) {
50		$this->config['page_size'] = self::DEFAULT_PAGE_SIZE;
51		}
52
53		// You can pass options directly to the Cassandra constructor
54		$options = array_get($config, 'options', []);
55
56		// Create the connection
57		$this->cluster = $this->createCluster($config, $options);
58
59		if (isset($options['database']) \|\| isset($config['keyspace'])) {
60		$keyspaceName = isset($options['database']) ? $options['database'] : $config['keyspace'];
61
62		$this->keyspace = $keyspaceName;
63		$this->session = $this->cluster->connect($keyspaceName);
64		}
65
66		$this->useDefaultPostProcessor();
67
68		$this->useDefaultSchemaGrammar();
69
70		$this->setQueryGrammar($this->getDefaultQueryGrammar());
71		}
72
73		/**
74		* Begin a fluent query against a database table.
75		*
76		* @param string $table
77		* @return Query\Builder
78		*/
79		public function table($table)
80		{
81		$processor = $this->getPostProcessor();
82
83		$query = new Query\Builder($this, null, $processor);
		0 ignored issues – show Documentation introduced 2019-04-24 19:07 UTC by Report Bug Copy Issue Report `$processor` is of type `object<Illuminate\Databa...y\Processors\Processor>`, but the function expects a `null\|object<lroman242\La...sandra\Query\Processor>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
84
85		return $query->from($table);
86		}
87
88		/**
89		* return Cassandra cluster.
90		*
91		* @return \Cassandra\Cluster
92		*/
93		public function getCassandraCluster()
94		{
95		return $this->cluster;
96		}
97
98		/**
99		* return Cassandra Session.
100		*
101		* @return \Cassandra\Session
102		*/
103		public function getCassandraSession()
104		{
105		return $this->session;
106		}
107
108		/**
109		* Return the Cassandra keyspace
110		*
111		* @return string
112		*/
113		public function getKeyspace()
114		{
115		return $this->keyspace;
116		}
117
118		/**
119		* Create a new Cassandra cluster object.
120		*
121		* @param array $config
122		* @param array $options
123		* @return \Cassandra\Cluster
124		*/
125		protected function createCluster(array $config, array $options)
126		{
127		$cluster = Cassandra::cluster();
128
129		// Check if the credentials are not already set in the options
130	View Code Duplication	if (!isset($options['username']) && !empty($config['username'])) {
131		$options['username'] = $config['username'];
132		}
133	View Code Duplication	if (!isset($options['password']) && !empty($config['password'])) {
134		$options['password'] = $config['password'];
135		}
136
137		// Authentication
138		if (isset($options['username']) && isset($options['password'])) {
139		$cluster->withCredentials($options['username'], $options['password']);
140		}
141
142		// Contact Points/Host
143		if (isset($options['contactpoints']) \|\| (isset($config['host']) && !empty($config['host']))) {
144		$contactPoints = $config['host'];
145
146		if (isset($options['contactpoints'])) {
147		$contactPoints = $options['contactpoints'];
148		}
149
150		if (is_array($contactPoints)) {
151		$contactPoints = implode(',', $contactPoints);
152		}
153
154		$contactPoints = !empty($contactPoints) ? $contactPoints : '127.0.0.1';
155
156		$cluster->withContactPoints($contactPoints);
157		}
158
159		if (!isset($options['port']) && !empty($config['port'])) {
160		$cluster->withPort((int) $config['port']);
161		}
162
163		if (array_key_exists('page_size', $config) && !empty($config['page_size'])) {
164		$cluster->withDefaultPageSize(intval($config['page_size'] ?? self::DEFAULT_PAGE_SIZE));
165		}
166
167		if (array_key_exists('consistency', $config) && in_array(strtoupper($config['consistency']), [
168		Cassandra::CONSISTENCY_ANY, Cassandra::CONSISTENCY_ONE, Cassandra::CONSISTENCY_TWO,
169		Cassandra::CONSISTENCY_THREE, Cassandra::CONSISTENCY_QUORUM, Cassandra::CONSISTENCY_ALL,
170		Cassandra::CONSISTENCY_SERIAL, Cassandra::CONSISTENCY_QUORUM, Cassandra::CONSISTENCY_LOCAL_QUORUM,
171		Cassandra::CONSISTENCY_EACH_QUORUM, Cassandra::CONSISTENCY_LOCAL_SERIAL, Cassandra::CONSISTENCY_LOCAL_ONE,
172		])) {
173		$cluster->withDefaultConsistency($config['consistency']);
174		}
175
176		if (array_key_exists('timeout', $config) && !empty($config['timeout'])) {
177		$cluster->withDefaultTimeout(intval($config['timeout']));
178		}
179
180		if (array_key_exists('connect_timeout', $config) && !empty($config['connect_timeout'])) {
181		$cluster->withConnectTimeout(floatval($config['connect_timeout']));
182		}
183
184		if (array_key_exists('request_timeout', $config) && !empty($config['request_timeout'])) {
185		$cluster->withRequestTimeout(floatval($config['request_timeout']));
186		}
187
188		return $cluster->build();
189		}
190
191		/**
192		* Disconnect from the underlying Cassandra connection.
193		*/
194		public function disconnect()
195		{
196		unset($this->connection);
197		}
198
199		/**
200		* Get the PDO driver name.
201		*
202		* @return string
203		*/
204		public function getDriverName()
205		{
206		return 'cassandra';
207		}
208
209		/**
210		* Run a select statement against the database.
211		*
212		* @param string $query
213		* @param array $bindings
214		* @param bool $useReadPdo
215		* @param array $customOptions
216		*
217		* @return array
218		*/
219		public function select($query, $bindings = [], $useReadPdo = true, array $customOptions = [])
220		{
221		return $this->runStatement($query, $bindings, $customOptions);
222		}
223
224		/**
225		* Run an bulk insert statement against the database.
226		*
227		* @param array $queries
228		* @param array $bindings
229		* @param int $type
230		* @param array $customOptions
231		*
232		* @return bool
233		*/
234		public function insertBulk($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED, array $customOptions = [])
235		{
236		return $this->batchStatement($queries, $bindings, $type, $customOptions);
237		}
238
239		/**
240		* Execute a group of queries inside a batch statement against the database.
241		*
242		* @param array $queries
243		* @param array $bindings
244		* @param int $type
245		* @param array $customOptions
246		*
247		* @return bool
248		*/
249		public function batchStatement($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED, array $customOptions = [])
250		{
251		return $this->run($queries, $bindings, function ($queries, $bindings) use ($type, $customOptions) {
		0 ignored issues – show Documentation introduced 2019-04-28 15:42 UTC by Report Bug Copy Issue Report `$queries` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
252		if ($this->pretending()) {
253		return [];
254		}
255
256		$batch = new BatchStatement($type);
257
258		foreach ($queries as $k => $query) {
259		$preparedStatement = $this->session->prepare($query);
260		$batch->add($preparedStatement, $bindings[$k]);
261		}
262
263		return $this->session->execute($batch, $customOptions);
264		});
265		}
266
267		/**
268		* Execute an CQL statement and return the boolean result.
269		*
270		* @param string $query
271		* @param array $bindings
272		* @param array $customOptions
273		*
274		* @return bool
275		*/
276		public function statement($query, $bindings = [], array $customOptions = [])
277		{
278		return $this->runStatement($query, $bindings, $customOptions);
279		}
280
281		/**
282		* Because Cassandra is an eventually consistent database, it's not possible to obtain
283		* the affected count for statements so we're just going to return 0, based on the idea
284		* that if the query fails somehow, an exception will be thrown
285		*
286		* @param string $query
287		* @param array $bindings
288		* @param array $customOptions
289		*
290		* @return int
291		*/
292		public function affectingStatement($query, $bindings = [], array $customOptions = [])
293		{
294		return $this->runStatement($query, $bindings, $customOptions, 0, 1);
		0 ignored issues – show Documentation introduced 2019-04-30 19:49 UTC by Report Bug Copy Issue Report `0` is of type `integer`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
295		}
296
297		/**
298		* @inheritdoc
299		*/
300		protected function getDefaultPostProcessor()
301		{
302		return new Query\Processor();
303		}
304
305		/**
306		* @inheritdoc
307		*/
308		protected function getDefaultQueryGrammar()
309		{
310		return new Query\Grammar();
311		}
312
313		/**
314		* @inheritdoc
315		*/
316		protected function getDefaultSchemaGrammar()
317		{
318		//return new Schema\Grammar();
319		}
320
321		/**
322		* Reconnect to the database if connection is missing.
323		*
324		* @return void
325		*/
326		protected function reconnectIfMissingConnection()
327		{
328		if (is_null($this->session)) {
329		$this->session = $this->createCluster($this->config, [])->connect($this->keyspace);
330		}
331		}
332
333		/**
334		* Dynamically pass methods to the connection.
335		*
336		* @param string $method
337		* @param array $parameters
338		* @return mixed
339		*/
340		public function __call($method, $parameters)
341		{
342		return call_user_func_array([$this->cluster, $method], $parameters);
343		}
344
345		/**
346		* Execute an CQL statement and return the boolean result.
347		*
348		* @param $query
349		* @param array $bindings
350		* @param array $customOptions
351		* @param array $defaultFailed
352		* @param null $defaultSuccess
353		*
354		* @return mixed
355		*/
356		protected function runStatement($query, $bindings = [], array $customOptions = [], $defaultFailed = [], $defaultSuccess = null)
357		{
358		return $this->run($query, $bindings, function ($query, $bindings) use ($defaultFailed, $customOptions, $defaultFailed, $defaultSuccess) {
359		if ($this->pretending()) {
360		return $defaultFailed;
361		}
362
363		$preparedStatement = $this->session->prepare($query);
364
365		//Add bindings
366		$customOptions['arguments'] = $bindings;
367
368		$result = $this->session->execute($preparedStatement, $customOptions);
369
370		return $defaultSuccess === null ? $result : $defaultSuccess;
371		});
372		}
373		}
374

lroman242 / laravel-cassandra