Grammar::getDateFormat() - Code Metrics - Inspection of "Feature/joins (#38)" - LaravelFreelancerNL/laravel-arangodb - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( fa3649...11c8ec )

by Bas

created 2020-12-12 19:42 UTC

Grammar::getDateFormat() A

↳ Parent: Grammar

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace LaravelFreelancerNL\Aranguent\Query;

use Illuminate\Support\Arr;
use Illuminate\Support\Traits\Macroable;
use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesAggregates;
use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesJoins;
use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesWhereClauses;
use LaravelFreelancerNL\Aranguent\Query\Concerns\HasAliases;
use LaravelFreelancerNL\FluentAQL\Exceptions\BindException as BindException;
use LaravelFreelancerNL\FluentAQL\Expressions\FunctionExpression;
use LaravelFreelancerNL\FluentAQL\Grammar as FluentAqlGrammar;

/*
 * Provides AQL syntax functions
 */

class Grammar extends FluentAqlGrammar
{
    use CompilesAggregates;
    use CompilesJoins;

    use CompilesWhereClauses;

    use HasAliases;

    use Macroable;

    public $name;

    /**
     * The grammar table prefix.
     *
     * @var string
     */
    protected $tablePrefix = '';

    /**
     * The grammar table prefix.
     *
     * @var null|int
     */
    protected $offset = null;

    /**
     * The components that make up a select clause.
     *
     * @var array
     */
    protected $selectComponents = [
        'from',
        'joins',
        'wheres',
        'groups',
        'aggregate',
        'havings',
        'orders',
        'offset',
        'limit',
        'columns',
    ];

    protected $operatorTranslations = [
        '='          => '==',
        '<>'         => '!=',
        '<=>'        => '==',
        'rlike'      => '=~',
        'not rlike'  => '!~',
        'regexp'     => '=~',
        'not regexp' => '!~',
    ];

    protected $whereTypeOperators = [
        'In'    => 'IN',
        'NotIn' => 'NOT IN',
    ];

    /**
     * Get the format for database stored dates.
     *
     * @return string
     */
    public function getDateFormat()
    {
        return 'Y-m-d\TH:i:s.v\Z';
    }

    /**
     * Get the grammar specific operators.
     *
     * @return array
     */
    public function getOperators()
    {
        return $this->comparisonOperators;
    }

    protected function prefixTable($table)
    {
        return $this->tablePrefix . $table;
    }

    /**
     * Compile an insert statement into AQL.
     *
     * @param Builder $builder
     * @param array   $values
     *
     * @throws BindException
     *
     * @return Builder
     */
    public function compileInsert(Builder $builder, array $values)
    {
        if (Arr::isAssoc($values)) {
            $values = [$values];
        }
        $table = $this->prefixTable($builder->from);

        if (empty($values)) {
            $builder->aqb = $builder->aqb->insert('{}', $table)->get();

            return $builder;
        }

        $builder->aqb = $builder->aqb->let('values', $values)
            ->for('value', 'values')
            ->insert('value', $table)
            ->return('NEW._key')
            ->get();

        return $builder;
    }

    /**
     * Compile an insert and get ID statement into SQL.
     *
     * @param Builder $builder
     * @param array   $values
     *
     * @throws BindException
     *
     * @return Builder
     */
    public function compileInsertGetId(Builder $builder, $values)
    {
        return $this->compileInsert($builder, $values);
    }

    /**
     * Compile a select query into AQL.
     *
     * @param Builder $builder
     *
     * @return Builder
     */
    public function compileSelect(Builder $builder)
    {
//        if ($builder->unions && $builder->aggregate) {
//            return $this->compileUnionAggregate($builder);
//        }

        // To compile the query, we'll spin through each component of the query and
        // see if that component exists. If it does we'll just call the compiler
        // function for the component which is responsible for making the SQL.

        $builder = $this->compileComponents($builder);

//        if ($builder->unions) {
//            $sql = $this->wrapUnion($sql).' '.$this->compileUnions($builder);
//        }

        $builder->aqb = $builder->aqb->get();

        return $builder;
    }

    /**
     * Compile the components necessary for a select clause.
     *
     * @param Builder $builder
     *
     * @return Builder
     */
    protected function compileComponents(Builder $builder)
    {
        foreach ($this->selectComponents as $component) {
            // To compile the query, we'll spin through each component of the query and
            // see if that component exists. If it does we'll just call the compiler
            // function for the component which is responsible for making the SQL.

            if (isset($builder->$component) && !is_null($builder->$component)) {
                $method = 'compile' . ucfirst($component);

                $builder = $this->$method($builder, $builder->$component);
            }
        }

        return $builder;
    }

    /**
     * Compile the "from" portion of the query -> FOR in AQL.
     *
     * @param Builder $builder
     * @param string  $table
     *
     * @return Builder
     */
    protected function compileFrom(Builder $builder, $table)
    {
        $table = $this->prefixTable($table);
        $alias = $this->registerTableAlias($table);

        $builder->aqb = $builder->aqb->for($alias, $table);

        return $builder;
    }



    /**
     * Compile the "order by" portions of the query.
     *
     * @param Builder $builder
     * @param array   $orders
     *
     * @return Builder
     */
    protected function compileOrders(Builder $builder, $orders)
    {
        if (!empty($orders)) {
            $orders = $this->compileOrdersToFlatArray($builder, $orders);
            $builder->aqb = $builder->aqb->sort(...$orders);

            return $builder;
        }

        return $builder;
    }

    /**
     * Compile the query orders to an array.
     *
     * @param Builder $builder
     * @param array   $orders
     *
     * @return array
     */
    protected function compileOrdersToFlatArray(Builder $builder, $orders)
    {
        $flatOrders = [];

        foreach ($orders as $order) {
            if (!isset($order['type']) || $order['type'] != 'Raw') {
                $order['column'] = $this->normalizeColumn($builder, $order['column']);
            }

            $flatOrders[] = $order['column'];

            if (isset($order['direction'])) {
                $flatOrders[] = $order['direction'];
            }
        }

        return $flatOrders;
    }

    /**
     * Compile the "offset" portions of the query.
     * We are handling this first by saving the offset which will be used by the FluentAQL's limit function.
     *
     * @param Builder $builder
     * @param int     $offset
     *
     * @return Builder
     */
    protected function compileOffset(Builder $builder, $offset)
    {
        $this->offset = (int) $offset;

        return $builder;
    }

    /**
     * Compile the "limit" portions of the query.
     *
     * @param Builder $builder
     * @param int     $limit
     *
     * @return Builder
     */
    protected function compileLimit(Builder $builder, $limit)
    {
        if ($this->offset !== null) {
            $builder->aqb = $builder->aqb->limit((int) $this->offset, (int) $limit);

            return $builder;
        }
        $builder->aqb = $builder->aqb->limit((int) $limit);

        return $builder;
    }

    /**
     * Compile the "RETURN" portion of the query.
     *
     * @param Builder $builder
     * @param array   $columns
     *
     * @return Builder
     */
    protected function compileColumns(Builder $builder, array $columns): Builder
    {
        $returnDocs = [];
        $returnAttributes = [];
        $values = [];


        // Prepare columns
        foreach ($columns as $column) {
            // Extract rows
            if (substr($column, strlen($column) - 2)  === '.*') {
                $table = substr($column, 0, strlen($column) - 2);
                $returnDocs[] = $this->getTableAlias($table);

                continue;
            }

            if ($column != null && $column != '*') {
                [$column, $alias] = $this->extractAlias($column);

                $returnAttributes[$alias] = $this->normalizeColumn($builder, $column);
            }
        }
        $values = $this->determineReturnValues($builder, $returnAttributes, $returnDocs);
        $builder->aqb = $builder->aqb->return($values, (bool) $builder->distinct);

        return $builder;
    }

    protected function determineReturnValues($builder, $returnAttributes = [], $returnDocs = [])
    {
        $values = [];

        if (! empty($returnAttributes)) {
            $values = $returnAttributes;
        }

        if (! empty($returnAttributes) && ! empty($returnDocs)) {
            $returnDocs[] = $returnAttributes;
        }

        if (! empty($returnDocs)) {
            $values = $builder->aqb->merge(...$returnDocs);
        }

        if ($builder->aggregate !== null) {
            $values = ['aggregate' => 'aggregateResult'];
        }

        if (empty($values)) {
            $values = $this->getTableAlias($builder->from);
            if (is_array($builder->joins) && !empty($builder->joins)) {
                $values = $this->mergeJoinResults($builder, $values);
            }
        }

        return $values;
    }


    protected function mergeJoinResults($builder, $baseTable)
    {
        $tablesToJoin = [];
        foreach ($builder->joins as $join) {
            $tablesToJoin[] = $this->getTableAlias($join->table);
        }
        $tablesToJoin = array_reverse($tablesToJoin);
        $tablesToJoin[] = $baseTable;

        return $builder->aqb->merge(...$tablesToJoin);
    }

    /**
     * Compile an update statement into SQL.
     *
     * @param Builder $builder
     * @param array   $values
     *
     * @return Builder
     */
    public function compileUpdate(Builder $builder, array $values)
    {

        $table = $this->prefixTable($builder->from);
        $tableAlias = $this->generateTableAlias($table);

        $builder->aqb = $builder->aqb->for($tableAlias, $table);

        //Fixme: joins?
        $builder = $this->compileWheres($builder);

        $builder->aqb = $builder->aqb->update($tableAlias, $values, $table)->get();

        return $builder;
    }

    /**
     * Compile a delete statement into SQL.
     *
     * @SuppressWarnings(PHPMD.CamelCaseParameterName)
     * @SuppressWarnings(PHPMD.CamelCaseVariableName)
     *
     * @param Builder $builder
     * @param null    $id

     *
     * @return Builder
     */
    public function compileDelete(Builder $builder, $id = null)
    {
        $table = $this->prefixTable($builder->from);
        $tableAlias = $this->generateTableAlias($table);


        if (!is_null($id)) {

            $builder->aqb = $builder->aqb->remove((string) $id, $table)->get();

            return $builder;
        }

        $builder->aqb = $builder->aqb->for($tableAlias, $table);

        //Fixme: joins?
        $builder = $this->compileWheres($builder);

        $builder->aqb = $builder->aqb->remove($tableAlias, $table)->get();

        return $builder;
    }

    /**
     * Compile the random statement into SQL.
     *
     * @param Builder $builder
     *
     * @return FunctionExpression;
     */
    public function compileRandom(Builder $builder)
    {
        return $builder->aqb->rand();
    }
}


1		<?php
2
3		namespace LaravelFreelancerNL\Aranguent\Query;
4
5		use Illuminate\Support\Arr;
6		use Illuminate\Support\Traits\Macroable;
7		use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesAggregates;
8		use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesJoins;
9		use LaravelFreelancerNL\Aranguent\Query\Concerns\CompilesWhereClauses;
10		use LaravelFreelancerNL\Aranguent\Query\Concerns\HasAliases;
11		use LaravelFreelancerNL\FluentAQL\Exceptions\BindException as BindException;
12		use LaravelFreelancerNL\FluentAQL\Expressions\FunctionExpression;
13		use LaravelFreelancerNL\FluentAQL\Grammar as FluentAqlGrammar;
14
15		/*
16		* Provides AQL syntax functions
17		*/
18
19		class Grammar extends FluentAqlGrammar
20		{
21		use CompilesAggregates;
22		use CompilesJoins;
		0 ignored issues – show introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report The trait `LaravelFreelancerNL\Aran...\Concerns\CompilesJoins` requires some properties which are not provided by `LaravelFreelancerNL\Aranguent\Query\Grammar`: `$type`, `$table` Loading history...
23		use CompilesWhereClauses;
		0 ignored issues – show Bug introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report The trait `LaravelFreelancerNL\Aran...ns\CompilesWhereClauses` requires the property `$wheres` which is not provided by `LaravelFreelancerNL\Aranguent\Query\Grammar`. Loading history...
24		use HasAliases;
		0 ignored issues – show Bug introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report The trait `LaravelFreelancerNL\Aran...ery\Concerns\HasAliases` requires the property `$from` which is not provided by `LaravelFreelancerNL\Aranguent\Query\Grammar`. Loading history...
25		use Macroable;
26
27		public $name;
28
29		/**
30		* The grammar table prefix.
31		*
32		* @var string
33		*/
34		protected $tablePrefix = '';
35
36		/**
37		* The grammar table prefix.
38		*
39		* @var null\|int
40		*/
41		protected $offset = null;
42
43		/**
44		* The components that make up a select clause.
45		*
46		* @var array
47		*/
48		protected $selectComponents = [
49		'from',
50		'joins',
51		'wheres',
52		'groups',
53		'aggregate',
54		'havings',
55		'orders',
56		'offset',
57		'limit',
58		'columns',
59		];
60
61		protected $operatorTranslations = [
62		'=' => '==',
63		'<>' => '!=',
64		'<=>' => '==',
65		'rlike' => '=~',
66		'not rlike' => '!~',
67		'regexp' => '=~',
68		'not regexp' => '!~',
69		];
70
71		protected $whereTypeOperators = [
72		'In' => 'IN',
73		'NotIn' => 'NOT IN',
74		];
75
76		/**
77		* Get the format for database stored dates.
78		*
79		* @return string
80		*/
81	57	public function getDateFormat()
82		{
83	57	return 'Y-m-d\TH:i:s.v\Z';
84		}
85
86		/**
87		* Get the grammar specific operators.
88		*
89		* @return array
90		*/
91	2	public function getOperators()
92		{
93	2	return $this->comparisonOperators;
94		}
95
96	80	protected function prefixTable($table)
97		{
98	80	return $this->tablePrefix . $table;
99		}
100
101		/**
102		* Compile an insert statement into AQL.
103		*
104		* @param Builder $builder
105		* @param array $values
106		*
107		* @throws BindException
108		*
109		* @return Builder
110		*/
111	57	public function compileInsert(Builder $builder, array $values)
112		{
113	57	if (Arr::isAssoc($values)) {
114	8	$values = [$values];
115		}
116	57	$table = $this->prefixTable($builder->from);
117
118	57	if (empty($values)) {
119		$builder->aqb = $builder->aqb->insert('{}', $table)->get();
120
121		return $builder;
122		}
123
124	57	$builder->aqb = $builder->aqb->let('values', $values)
125	57	->for('value', 'values')
126	57	->insert('value', $table)
127	57	->return('NEW._key')
128	57	->get();
129
130	57	return $builder;
131		}
132
133		/**
134		* Compile an insert and get ID statement into SQL.
135		*
136		* @param Builder $builder
137		* @param array $values
138		*
139		* @throws BindException
140		*
141		* @return Builder
142		*/
143	8	public function compileInsertGetId(Builder $builder, $values)
144		{
145	8	return $this->compileInsert($builder, $values);
146		}
147
148		/**
149		* Compile a select query into AQL.
150		*
151		* @param Builder $builder
152		*
153		* @return Builder
154		*/
155	76	public function compileSelect(Builder $builder)
156		{
157		// if ($builder->unions && $builder->aggregate) {
158		// return $this->compileUnionAggregate($builder);
159		// }
160
161		// To compile the query, we'll spin through each component of the query and
162		// see if that component exists. If it does we'll just call the compiler
163		// function for the component which is responsible for making the SQL.
164
165	76	$builder = $this->compileComponents($builder);
166
167		// if ($builder->unions) {
168		// $sql = $this->wrapUnion($sql).' '.$this->compileUnions($builder);
169		// }
170
171	76	$builder->aqb = $builder->aqb->get();
172
173	76	return $builder;
174		}
175
176		/**
177		* Compile the components necessary for a select clause.
178		*
179		* @param Builder $builder
180		*
181		* @return Builder
182		*/
183	76	protected function compileComponents(Builder $builder)
184		{
185	76	foreach ($this->selectComponents as $component) {
186		// To compile the query, we'll spin through each component of the query and
187		// see if that component exists. If it does we'll just call the compiler
188		// function for the component which is responsible for making the SQL.
189
190	76	if (isset($builder->$component) && !is_null($builder->$component)) {
191	76	$method = 'compile' . ucfirst($component);
192
193	76	$builder = $this->$method($builder, $builder->$component);
194		}
195		}
196
197	76	return $builder;
198		}
199
200		/**
201		* Compile the "from" portion of the query -> FOR in AQL.
202		*
203		* @param Builder $builder
204		* @param string $table
205		*
206		* @return Builder
207		*/
208	76	protected function compileFrom(Builder $builder, $table)
209		{
210	76	$table = $this->prefixTable($table);
211	76	$alias = $this->registerTableAlias($table);
212
213	76	$builder->aqb = $builder->aqb->for($alias, $table);
214
215	76	return $builder;
216		}
217
218
219
220		/**
221		* Compile the "order by" portions of the query.
222		*
223		* @param Builder $builder
224		* @param array $orders
225		*
226		* @return Builder
227		*/
228	2	protected function compileOrders(Builder $builder, $orders)
229		{
230	2	if (!empty($orders)) {
231	2	$orders = $this->compileOrdersToFlatArray($builder, $orders);
232	2	$builder->aqb = $builder->aqb->sort(...$orders);
233
234	2	return $builder;
235		}
236
237		return $builder;
238		}
239
240		/**
241		* Compile the query orders to an array.
242		*
243		* @param Builder $builder
244		* @param array $orders
245		*
246		* @return array
247		*/
248	2	protected function compileOrdersToFlatArray(Builder $builder, $orders)
249		{
250	2	$flatOrders = [];
251
252	2	foreach ($orders as $order) {
253	2	if (!isset($order['type']) \|\| $order['type'] != 'Raw') {
254	1	$order['column'] = $this->normalizeColumn($builder, $order['column']);
255		}
256
257	2	$flatOrders[] = $order['column'];
258
259	2	if (isset($order['direction'])) {
260	1	$flatOrders[] = $order['direction'];
261		}
262		}
263
264	2	return $flatOrders;
265		}
266
267		/**
268		* Compile the "offset" portions of the query.
269		* We are handling this first by saving the offset which will be used by the FluentAQL's limit function.
270		*
271		* @param Builder $builder
272		* @param int $offset
273		*
274		* @return Builder
275		*/
276	2	protected function compileOffset(Builder $builder, $offset)
277		{
278	2	$this->offset = (int) $offset;
279
280	2	return $builder;
281		}
282
283		/**
284		* Compile the "limit" portions of the query.
285		*
286		* @param Builder $builder
287		* @param int $limit
288		*
289		* @return Builder
290		*/
291	38	protected function compileLimit(Builder $builder, $limit)
292		{
293	38	if ($this->offset !== null) {
294	2	$builder->aqb = $builder->aqb->limit((int) $this->offset, (int) $limit);
295
296	2	return $builder;
297		}
298	36	$builder->aqb = $builder->aqb->limit((int) $limit);
299
300	36	return $builder;
301		}
302
303		/**
304		* Compile the "RETURN" portion of the query.
305		*
306		* @param Builder $builder
307		* @param array $columns
308		*
309		* @return Builder
310		*/
311	75	protected function compileColumns(Builder $builder, array $columns): Builder
312		{
313	75	$returnDocs = [];
314	75	$returnAttributes = [];
315	75	$values = [];
		0 ignored issues – show Unused Code introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report The assignment to `$values` is dead and can be removed. Loading history...
316
317		// Prepare columns
318	75	foreach ($columns as $column) {
319		// Extract rows
320	75	if (substr($column, strlen($column) - 2) === '.*') {
321	11	$table = substr($column, 0, strlen($column) - 2);
322	11	$returnDocs[] = $this->getTableAlias($table);
323
324	11	continue;
325		}
326
327	75	if ($column != null && $column != '*') {
328	17	[$column, $alias] = $this->extractAlias($column);
329
330	17	$returnAttributes[$alias] = $this->normalizeColumn($builder, $column);
331		}
332		}
333	75	$values = $this->determineReturnValues($builder, $returnAttributes, $returnDocs);
334	75	$builder->aqb = $builder->aqb->return($values, (bool) $builder->distinct);
335
336	75	return $builder;
337		}
338
339	75	protected function determineReturnValues($builder, $returnAttributes = [], $returnDocs = [])
340		{
341	75	$values = [];
342
343	75	if (! empty($returnAttributes)) {
344	17	$values = $returnAttributes;
345		}
346
347	75	if (! empty($returnAttributes) && ! empty($returnDocs)) {
348	11	$returnDocs[] = $returnAttributes;
349		}
350
351	75	if (! empty($returnDocs)) {
352	11	$values = $builder->aqb->merge(...$returnDocs);
353		}
354
355	75	if ($builder->aggregate !== null) {
356	7	$values = ['aggregate' => 'aggregateResult'];
357		}
358
359	75	if (empty($values)) {
360	69	$values = $this->getTableAlias($builder->from);
361	69	if (is_array($builder->joins) && !empty($builder->joins)) {
362	3	$values = $this->mergeJoinResults($builder, $values);
363		}
364		}
365
366	75	return $values;
367		}
368
369
370	3	protected function mergeJoinResults($builder, $baseTable)
371		{
372	3	$tablesToJoin = [];
373	3	foreach ($builder->joins as $join) {
374	3	$tablesToJoin[] = $this->getTableAlias($join->table);
375		}
376	3	$tablesToJoin = array_reverse($tablesToJoin);
377	3	$tablesToJoin[] = $baseTable;
378
379	3	return $builder->aqb->merge(...$tablesToJoin);
380		}
381
382		/**
383		* Compile an update statement into SQL.
384		*
385		* @param Builder $builder
386		* @param array $values
387		*
388		* @return Builder
389		*/
390	13	public function compileUpdate(Builder $builder, array $values)
391		{
392
393	13	$table = $this->prefixTable($builder->from);
394	13	$tableAlias = $this->generateTableAlias($table);
395
396	13	$builder->aqb = $builder->aqb->for($tableAlias, $table);
397
398		//Fixme: joins?
399	13	$builder = $this->compileWheres($builder);
400
401	13	$builder->aqb = $builder->aqb->update($tableAlias, $values, $table)->get();
402
403	13	return $builder;
404		}
405
406		/**
407		* Compile a delete statement into SQL.
408		*
409		* @SuppressWarnings(PHPMD.CamelCaseParameterName)
410		* @SuppressWarnings(PHPMD.CamelCaseVariableName)
411		*
412		* @param Builder $builder
413		* @param null $id
		0 ignored issues – show Documentation Bug introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$id` is correct as it would always require `null` to be passed? Loading history...
414		*
415		* @return Builder
416		*/
417	6	public function compileDelete(Builder $builder, $id = null)
418		{
419	6	$table = $this->prefixTable($builder->from);
420	6	$tableAlias = $this->generateTableAlias($table);
421
422
423	6	if (!is_null($id)) {
		0 ignored issues – show introduced 2020-12-12 19:37 UTC by Report Bug Copy Issue Report The condition `is_null($id)` is always `true`. Loading history...
424	1	$builder->aqb = $builder->aqb->remove((string) $id, $table)->get();
425
426	1	return $builder;
427		}
428
429	6	$builder->aqb = $builder->aqb->for($tableAlias, $table);
430
431		//Fixme: joins?
432	6	$builder = $this->compileWheres($builder);
433
434	6	$builder->aqb = $builder->aqb->remove($tableAlias, $table)->get();
435
436	6	return $builder;
437		}
438
439		/**
440		* Compile the random statement into SQL.
441		*
442		* @param Builder $builder
443		*
444		* @return FunctionExpression;
445		*/
446	1	public function compileRandom(Builder $builder)
447		{
448	1	return $builder->aqb->rand();
449		}
450		}
451

LaravelFreelancerNL / laravel-arangodb

Push — master ( fa3649...11c8ec )

Grammar::getDateFormat() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like