Builder::__construct() - Code Metrics - Inspection of "55927362b0e48fd589fbba235043379c032ba774" - lroman242/laravel-cassandra - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — testing (559273)

by Roman

created 2019-05-22 16:28 UTC

Builder::__construct() A

↳ Parent: Builder

Complexity

Conditions	3
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	5
cts	5
cp	1
rs	10
c	0
b	0
f	0
cc	3
nc	4
nop	3
crap	3

<?php

namespace lroman242\LaravelCassandra\Query;

use lroman242\LaravelCassandra\Collection;
use lroman242\LaravelCassandra\Connection;
use Illuminate\Database\Query\Builder as BaseBuilder;
use Illuminate\Support\Arr;

class Builder extends BaseBuilder
{
    /**
     * Use cassandra filtering
     *
     * @var bool
     */
    public $allowFiltering = false;

    /**
     * Size of fetched page
     *
     * @var null|int
     */
    protected $pageSize = null;

    /**
     * Pagination state token
     *
     * @var null|string
     */
    protected $paginationStateToken = null;

    /**
     * Indicate what amount of pages should be fetched
     * all or single
     *
     * @var bool
     */
    protected $fetchAllResults = true;

    /**
     * @inheritdoc
     */
    public function __construct(Connection $connection, Grammar $grammar = null, Processor $processor = null)
    {
        $this->connection = $connection;
        $this->grammar = $grammar ?: $connection->getQueryGrammar();
        $this->processor = $processor ?: $connection->getPostProcessor();
    }

    /**
     * Support "allow filtering"
     */
    public function allowFiltering($bool = true) {
        $this->allowFiltering = (bool) $bool;

        return $this;
    }

    /**
     * Insert a new record into the database.
     *
     * @param  array  $values
     * @return bool
     */
    public function insert(array $values)
    {
        // Since every insert gets treated like a batch insert, we will make sure the
        // bindings are structured in a way that is convenient when building these
        // inserts statements by verifying these elements are actually an array.
        if (empty($values)) {
            return true;
        }

        if (!is_array(reset($values))) {
            $values = [$values];

            return $this->connection->insert(
                $this->grammar->compileInsert($this, $values),
                $this->cleanBindings(Arr::flatten($values, 1))
            );
        }

        // Here, we'll generate the insert queries for every record and send those
        // for a batch query
        else {
            $queries = [];
            $bindings = [];

            foreach ($values as $key => $value) {
                ksort($value);

                $queries[] = $this->grammar->compileInsert($this, $value);
                $bindings[] = $this->cleanBindings(Arr::flatten($value, 1));
            }

            return $this->connection->insertBulk($queries, $bindings);

        }
    }
    
    /**
     * Execute the query as a "select" statement.
     *
     * @param  array  $columns
     *
     * @return \Illuminate\Support\Collection
     */
    public function get($columns = ['*'])
    {
        $original = $this->columns;

        if (is_null($original)) {
            $this->columns = $columns;
        }

        //Set up custom options
        $options = [];
        if ($this->pageSize !== null && (int) $this->pageSize > 0) {
            $options['page_size'] = (int) $this->pageSize;
        }
        if ($this->paginationStateToken !== null) {
            $options['paging_state_token'] = $this->paginationStateToken;
        }

        // Process select with custom options
        $results = $this->processor->processSelect($this, $this->runSelect($options));

        // Get results from all pages
        $collection = new Collection($results);

        if ($this->fetchAllResults) {
            while (!$collection->isLastPage()) {
                $collection = $collection->appendNextPage();
            }
        }

        $this->columns = $original;
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}

        return $collection;
    }

    /**
     * Run the query as a "select" statement against the connection.
     *
     * @param array $options
     *
     * @return array
     */
    protected function runSelect(array $options = [])
    {
        return $this->connection->select(
            $this->toSql(), $this->getBindings(), !$this->useWritePdo, $options

        );
    }

    /**
     * Set pagination state token to fetch
     * next page
     *
     * @param string $token
     *
     * @return Builder
     */
    public function setPaginationStateToken($token = null)
    {
        $this->paginationStateToken = $token;

        return $this;
    }

    /**
     * Set page size
     *
     * @param int $pageSize
     *
     * @return Builder
     */
    public function setPageSize($pageSize = null)
    {
        if ($pageSize !== null) {
            $this->pageSize = (int) $pageSize;
        } else {
            $this->pageSize = $pageSize;
        }

        return $this;
    }

    /**
     * Get collection with single page results
     *
     * @param $columns array
     *
     * @return \Illuminate\Support\Collection
     */
    public function getPage($columns = ['*'])
    {
        $this->fetchAllResults = false;

        $result = $this->get($columns);

        $this->fetchAllResults = true;

        return $result;
    }
}


1		<?php
2
3		namespace lroman242\LaravelCassandra\Query;
4
5		use lroman242\LaravelCassandra\Collection;
6		use lroman242\LaravelCassandra\Connection;
7		use Illuminate\Database\Query\Builder as BaseBuilder;
8		use Illuminate\Support\Arr;
9
10		class Builder extends BaseBuilder
11		{
12		/**
13		* Use cassandra filtering
14		*
15		* @var bool
16		*/
17		public $allowFiltering = false;
18
19		/**
20		* Size of fetched page
21		*
22		* @var null\|int
23		*/
24		protected $pageSize = null;
25
26		/**
27		* Pagination state token
28		*
29		* @var null\|string
30		*/
31		protected $paginationStateToken = null;
32
33		/**
34		* Indicate what amount of pages should be fetched
35		* all or single
36		*
37		* @var bool
38		*/
39		protected $fetchAllResults = true;
40
41		/**
42		* @inheritdoc
43		*/
44	43	public function __construct(Connection $connection, Grammar $grammar = null, Processor $processor = null)
45		{
46	43	$this->connection = $connection;
47	43	$this->grammar = $grammar ?: $connection->getQueryGrammar();
48	43	$this->processor = $processor ?: $connection->getPostProcessor();
49	43	}
50
51		/**
52		* Support "allow filtering"
53		*/
54	1	public function allowFiltering($bool = true) {
55	1	$this->allowFiltering = (bool) $bool;
56
57	1	return $this;
58		}
59
60		/**
61		* Insert a new record into the database.
62		*
63		* @param array $values
64		* @return bool
65		*/
66	36	public function insert(array $values)
67		{
68		// Since every insert gets treated like a batch insert, we will make sure the
69		// bindings are structured in a way that is convenient when building these
70		// inserts statements by verifying these elements are actually an array.
71	36	if (empty($values)) {
72		return true;
73		}
74
75	36	if (!is_array(reset($values))) {
76	33	$values = [$values];
77
78	33	return $this->connection->insert(
79	33	$this->grammar->compileInsert($this, $values),
80	33	$this->cleanBindings(Arr::flatten($values, 1))
81		);
82		}
83
84		// Here, we'll generate the insert queries for every record and send those
85		// for a batch query
86		else {
87	3	$queries = [];
88	3	$bindings = [];
89
90	3	foreach ($values as $key => $value) {
91	3	ksort($value);
92
93	3	$queries[] = $this->grammar->compileInsert($this, $value);
94	3	$bindings[] = $this->cleanBindings(Arr::flatten($value, 1));
95		}
96
97	3	return $this->connection->insertBulk($queries, $bindings);
		0 ignored issues – show Bug introduced 2019-04-24 19:07 UTC by Report Bug Copy Issue Report The method `insertBulk()` does not exist on `Illuminate\Database\ConnectionInterface`. Did you maybe mean `insert()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
98		}
99		}
100
101		/**
102		* Execute the query as a "select" statement.
103		*
104		* @param array $columns
105		*
106		* @return \Illuminate\Support\Collection
107		*/
108	39	public function get($columns = ['*'])
109		{
110	39	$original = $this->columns;
111
112	39	if (is_null($original)) {
113	39	$this->columns = $columns;
114		}
115
116		//Set up custom options
117	39	$options = [];
118	39	if ($this->pageSize !== null && (int) $this->pageSize > 0) {
119	9	$options['page_size'] = (int) $this->pageSize;
120		}
121	39	if ($this->paginationStateToken !== null) {
122	1	$options['paging_state_token'] = $this->paginationStateToken;
123		}
124
125		// Process select with custom options
126	39	$results = $this->processor->processSelect($this, $this->runSelect($options));
127
128		// Get results from all pages
129	39	$collection = new Collection($results);
130
131	39	if ($this->fetchAllResults) {
132	32	while (!$collection->isLastPage()) {
133	2	$collection = $collection->appendNextPage();
134		}
135		}
136
137	39	$this->columns = $original;
		0 ignored issues – show Documentation Bug introduced 2019-04-24 19:07 UTC by Report Bug Copy Issue Report It seems like `$original` can be `null`. However, the property `$columns` is declared as `array`. Maybe change the type of the property to `array\|null` or add a type check? Our type inference engine has found an assignment of a scalar value (like a string, an integer or null) to a property which is an array. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property. To type hint that a parameter can be either an array or null, you can set a type hint of array and a default value of null. The PHP interpreter will then accept both an array or null for that parameter. function aContainsB(array $needle = null, array $haystack) { if (!$needle) { return false; } return array_intersect($haystack, $needle) == $haystack; } The function can be called with either null or an array for the parameter `$needle` but will only accept an array as `$haystack`. Loading history...
138
139	39	return $collection;
140		}
141
142		/**
143		* Run the query as a "select" statement against the connection.
144		*
145		* @param array $options
146		*
147		* @return array
148		*/
149	39	protected function runSelect(array $options = [])
150		{
151	39	return $this->connection->select(
152	39	$this->toSql(), $this->getBindings(), !$this->useWritePdo, $options
		0 ignored issues – show Unused Code introduced 2019-04-24 19:07 UTC by Report Bug Copy Issue Report The call to `ConnectionInterface::select()` has too many arguments starting with `!$this->useWritePdo`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
153		);
154		}
155
156		/**
157		* Set pagination state token to fetch
158		* next page
159		*
160		* @param string $token
161		*
162		* @return Builder
163		*/
164	1	public function setPaginationStateToken($token = null)
165		{
166	1	$this->paginationStateToken = $token;
167
168	1	return $this;
169		}
170
171		/**
172		* Set page size
173		*
174		* @param int $pageSize
175		*
176		* @return Builder
177		*/
178	9	public function setPageSize($pageSize = null)
179		{
180	9	if ($pageSize !== null) {
181	9	$this->pageSize = (int) $pageSize;
182		} else {
183	1	$this->pageSize = $pageSize;
184		}
185
186	9	return $this;
187		}
188
189		/**
190		* Get collection with single page results
191		*
192		* @param $columns array
193		*
194		* @return \Illuminate\Support\Collection
195		*/
196	8	public function getPage($columns = ['*'])
197		{
198	8	$this->fetchAllResults = false;
199
200	8	$result = $this->get($columns);
201
202	8	$this->fetchAllResults = true;
203
204	8	return $result;
205		}
206		}
207

lroman242 / laravel-cassandra

Branch — testing (559273)

Builder::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like