Connection::getDefaultQueryGrammar() - Code Metrics - Inspection of "Making some good progress in ModelTest. Currently..." - Fuitad/laravel-cassandra - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( da7eaf...ab8466 )

by Pierre-Luc

created 2017-03-21 16:11 UTC

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

namespace fuitad\LaravelCassandra;

use Cassandra;
use Cassandra\BatchStatement;
use Cassandra\ExecutionOptions;

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

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

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

    /**
     * Create a new database connection instance.
     *
     * @param  array   $config
     */
    public function __construct(array $config)
    {
        $this->config = $config;

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

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

        if (isset($options['keyspace']) || isset($config['keyspace'])) {
            $this->keyspace = $config['keyspace'];
            $this->session = $this->cluster->connect($config['keyspace']);
        }

        $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, $processor);


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

    /**
     * Get a schema builder instance for the connection.
     *
     * @return Schema\Builder
     */
    public function getSchemaBuilder()
    {
        return new Schema\Builder($this);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

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

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * 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  string  $dsn
     * @param  array   $config
     * @param  array   $options
     * @return \Cassandra\Cluster
     */
    protected function createCluster($dsn, array $config, array $options)

    {
        // By default driver options is an empty array.
        $driverOptions = [];
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if (isset($config['driver_options']) && is_array($config['driver_options'])) {
            $driverOptions = $config['driver_options'];
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        }

        $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'];
            }

            $cluster->withContactPoints($contactPoints);
        }

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

        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
     * @return array
     */
    public function select($query, $bindings = [], $useReadPdo = true)

    {
        return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
            if ($this->pretending()) {
                return [];
            }

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

            return $this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));
        });
    }

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

    /**
     * Execute a group of queries inside a batch statement against the database.
     *
     * @param  array  $queries
     * @param  array  $bindings
     * @return bool
     */
    public function batchStatement($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED)

    {
        return $this->run($queries, $bindings, function ($queries, $bindings) {
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(Cassandra::BATCH_LOGGED);

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

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

    /**
     * Execute an SQL statement and return the boolean result.
     *
     * @param  string  $query
     * @param  array   $bindings
     * @return bool
     */
    public function statement($query, $bindings = [])

    {
        return $this->run($query, $bindings, function ($query, $bindings) {
            if ($this->pretending()) {
                return [];
            }

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

            return $this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));
        });
    }

    /**
     * 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
     * @return int
     */
    public function affectingStatement($query, $bindings = [])

    {
        return $this->run($query, $bindings, function ($query, $bindings) {
            if ($this->pretending()) {
                return 0;
            }

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

            $this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));

            return 1;
        });
    }

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

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

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

    }

    /**
     * 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);
    }
}


1		<?php
2
3		namespace fuitad\LaravelCassandra;
4
5		use Cassandra;
6		use Cassandra\BatchStatement;
7		use Cassandra\ExecutionOptions;
8
9		class Connection extends \Illuminate\Database\Connection
10		{
11		/**
12		* The Cassandra keyspace
13		*
14		* @var string
15		*/
16		protected $keyspace;
17
18		/**
19		* The Cassandra cluster
20		*
21		* @var \Cassandra\Cluster
22		*/
23		protected $cluster;
24
25		/**
26		* The Cassandra connection handler.
27		*
28		* @var \Cassandra\Session
29		*/
30		protected $session;
31
32		/**
33		* Create a new database connection instance.
34		*
35		* @param array $config
36		*/
37		public function __construct(array $config)
38		{
39		$this->config = $config;
40
41		// You can pass options directly to the Cassandra constructor
42		$options = array_get($config, 'options', []);
43
44		// Create the connection
45		$this->cluster = $this->createCluster(null, $config, $options);
46
47		if (isset($options['keyspace']) \|\| isset($config['keyspace'])) {
48		$this->keyspace = $config['keyspace'];
49		$this->session = $this->cluster->connect($config['keyspace']);
50		}
51
52		$this->useDefaultPostProcessor();
53
54		$this->useDefaultSchemaGrammar();
55
56		$this->setQueryGrammar($this->getDefaultQueryGrammar());
57		}
58
59		/**
60		* Begin a fluent query against a database table.
61		*
62		* @param string $table
63		* @return Query\Builder
64		*/
65		public function table($table)
66		{
67		$processor = $this->getPostProcessor();
68
69		$query = new Query\Builder($this, $processor);
		0 ignored issues – show Compatibility introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report `$processor` of type `object<Illuminate\Databa...y\Processors\Processor>` is not a sub-type of `object<fuitad\LaravelCassandra\Query\Processor>`. It seems like you assume a child class of the class `Illuminate\Database\Query\Processors\Processor` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
70
71		return $query->from($table);
72		}
73
74		/**
75		* Get a schema builder instance for the connection.
76		*
77		* @return Schema\Builder
78		*/
79		public function getSchemaBuilder()
80		{
81		return new Schema\Builder($this);
		0 ignored issues – show Bug Best Practice introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report The return type of `return new \fuitad\Larav...\Schema\Builder($this);` (`fuitad\LaravelCassandra\Schema\Builder`) is incompatible with the return type of the parent method `Illuminate\Database\Connection::getSchemaBuilder` of type `Illuminate\Database\Schema\Builder`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
82		}
83
84		/**
85		* return Cassandra cluster.
86		*
87		* @return \Cassandra\Cluster
88		*/
89		public function getCassandraCluster()
90		{
91		return $this->cluster;
92		}
93
94		/**
95		* return Cassandra Session.
96		*
97		* @return \Cassandra\Session
98		*/
99		public function getCassandraSession()
100		{
101		return $this->session;
102		}
103
104		/**
105		* Return the Cassandra keyspace
106		*
107		* @return string
108		*/
109		public function getKeyspace()
110		{
111		return $this->keyspace;
112		}
113
114		/**
115		* Create a new Cassandra cluster object.
116		*
117		* @param string $dsn
118		* @param array $config
119		* @param array $options
120		* @return \Cassandra\Cluster
121		*/
122		protected function createCluster($dsn, array $config, array $options)
		0 ignored issues – show Unused Code introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report The parameter `$dsn` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
123		{
124		// By default driver options is an empty array.
125		$driverOptions = [];
		0 ignored issues – show Unused Code introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report `$driverOptions` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
126
127		if (isset($config['driver_options']) && is_array($config['driver_options'])) {
128		$driverOptions = $config['driver_options'];
		0 ignored issues – show Unused Code introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report `$driverOptions` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
129		}
130
131		$cluster = Cassandra::cluster();
132
133		// Check if the credentials are not already set in the options
134	View Code Duplication	if (!isset($options['username']) && !empty($config['username'])) {
		1 ignored issue – show Duplication introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
135		$options['username'] = $config['username'];
136		}
137	View Code Duplication	if (!isset($options['password']) && !empty($config['password'])) {
		1 ignored issue – show Duplication introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
138		$options['password'] = $config['password'];
139		}
140
141		// Authentication
142		if (isset($options['username']) && isset($options['password'])) {
143		$cluster->withCredentials($options['username'], $options['password']);
144		}
145
146		// Contact Points/Host
147		if (isset($options['contactpoints']) \|\| (isset($config['host']) && !empty($config['host']))) {
148		$contactPoints = $config['host'];
149
150		if (isset($options['contactpoints'])) {
151		$contactPoints = $options['contactpoints'];
152		}
153
154		$cluster->withContactPoints($contactPoints);
155		}
156
157		if (!isset($options['port']) && !empty($config['port'])) {
158		$cluster->withPort((int) $config['port']);
159		}
160
161		return $cluster->build();
162		}
163
164		/**
165		* Disconnect from the underlying Cassandra connection.
166		*/
167		public function disconnect()
168		{
169		unset($this->connection);
170		}
171
172		/**
173		* Get the PDO driver name.
174		*
175		* @return string
176		*/
177		public function getDriverName()
178		{
179		return 'cassandra';
180		}
181
182		/**
183		* Run a select statement against the database.
184		*
185		* @param string $query
186		* @param array $bindings
187		* @param bool $useReadPdo
188		* @return array
189		*/
190	View Code Duplication	public function select($query, $bindings = [], $useReadPdo = true)
		0 ignored issues – show Duplication introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
191		{
192		return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
193		if ($this->pretending()) {
194		return [];
195		}
196
197		$preparedStatement = $this->session->prepare($query);
198
199		return $this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));
200		});
201		}
202
203		/**
204		* Run an bulk insert statement against the database.
205		*
206		* @param array $queries
207		* @param array $bindings
208		* @return bool
209		*/
210		public function insertBulk($queries, $bindings = [], $type = Cassandra::BATCH_LOGGED)
211		{
212		return $this->batchStatement($queries, $bindings, $type);
213		}
214
215		/**
216		* Execute a group of queries inside a batch statement against the database.
217		*
218		* @param array $queries
219		* @param array $bindings
220		* @return bool
221		*/
222		public function batchStatement($queries = [], $bindings = [], $type = Cassandra::BATCH_LOGGED)
		0 ignored issues – show Unused Code introduced 2017-03-21 16:17 UTC by Report Bug Copy Issue Report The parameter `$type` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
223		{
224		return $this->run($queries, $bindings, function ($queries, $bindings) {
		0 ignored issues – show Documentation introduced 2017-03-21 16:17 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...
225		if ($this->pretending()) {
226		return [];
227		}
228
229		$batch = new BatchStatement(Cassandra::BATCH_LOGGED);
230
231		foreach ($queries as $k => $query) {
232		$preparedStatement = $this->session->prepare($query);
233		$batch->add($preparedStatement, $bindings[$k]);
234		}
235
236		return $this->session->execute($batch);
237		});
238		}
239
240		/**
241		* Execute an SQL statement and return the boolean result.
242		*
243		* @param string $query
244		* @param array $bindings
245		* @return bool
246		*/
247	View Code Duplication	public function statement($query, $bindings = [])
		0 ignored issues – show Duplication introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
248		{
249		return $this->run($query, $bindings, function ($query, $bindings) {
250		if ($this->pretending()) {
251		return [];
252		}
253
254		$preparedStatement = $this->session->prepare($query);
255
256		return $this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));
257		});
258		}
259
260		/**
261		* Because Cassandra is an eventually consistent database, it's not possible to obtain
262		* the affected count for statements so we're just going to return 0, based on the idea
263		* that if the query fails somehow, an exception will be thrown
264		*
265		* @param string $query
266		* @param array $bindings
267		* @return int
268		*/
269	View Code Duplication	public function affectingStatement($query, $bindings = [])
		0 ignored issues – show Duplication introduced 2017-03-20 17:24 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
270		{
271		return $this->run($query, $bindings, function ($query, $bindings) {
272		if ($this->pretending()) {
273		return 0;
274		}
275
276		$preparedStatement = $this->session->prepare($query);
277
278		$this->session->execute($preparedStatement, new ExecutionOptions(['arguments' => $bindings]));
279
280		return 1;
281		});
282		}
283
284		/**
285		* @inheritdoc
286		*/
287		protected function getDefaultPostProcessor()
288		{
289		return new Query\Processor();
290		}
291
292		/**
293		* @inheritdoc
294		*/
295		protected function getDefaultQueryGrammar()
296		{
297		return new Query\Grammar();
298		}
299
300		/**
301		* @inheritdoc
302		*/
303		protected function getDefaultSchemaGrammar()
304		{
305		//return new Schema\Grammar();
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-03-20 19:45 UTC by Report Bug Copy Issue Report `63%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
306		}
307
308		/**
309		* Dynamically pass methods to the connection.
310		*
311		* @param string $method
312		* @param array $parameters
313		* @return mixed
314		*/
315		public function __call($method, $parameters)
316		{
317		return call_user_func_array([$this->cluster, $method], $parameters);
318		}
319		}
320

Fuitad / laravel-cassandra

GitHub Access Token became invalid

Push — master ( da7eaf...ab8466 )

Connection::getDefaultQueryGrammar() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like