QueryMaker::checkOperator() - Code Metrics - Inspection of "offset, limit, order" - midorikocak/querymaker - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c6af74...0c144d )

by Midori

created 2020-02-03 16:00 UTC

QueryMaker::checkOperator() A

↳ Parent: QueryMaker

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

declare(strict_types=1);

namespace midorikocak\querymaker;

use InvalidArgumentException;

use function array_keys;
use function array_map;
use function array_values;
use function implode;
use function in_array;
use function uniqid;

class QueryMaker implements QueryInterface
{
    private string $query;
    private string $statement;
    private array $params;
    private string $offset;

    private string $limit;
    private string $orderBy;

    private function __construct()
    {
        $this->query     = '';
        $this->statement = '';
        $this->params    = [];

        $this->limit   = '';
        $this->orderBy = '';
    }

    public static function select($table, array $columns = ['*']) : QueryInterface
    {
        $instance            = new QueryMaker();
        $columnsText         = implode(', ', $columns);
        $instance->statement = 'SELECT ' . $columnsText . ' FROM ' . $table;
        $instance->query     = 'SELECT ' . $columnsText . ' FROM ' . $table;
        return $instance;
    }

    public static function update($table, array $values) : QueryInterface
    {
        $instance            = new QueryMaker();
        $instance->statement = 'UPDATE ' . $table . ' SET ';
        $instance->query     = 'UPDATE ' . $table . ' SET ';
        $instance->prepareParams($values, ', ');
        return $instance;
    }

    public static function insert($table, array $values) : QueryInterface
    {
        $fields      = implode(', ', array_keys($values));
        $params      = implode(', ', array_map(fn($key) => ':' . $key, array_keys($values)));
        $queryValues = implode(', ', array_map(fn($value) => "'$value'", array_values($values)));

        $instance            = new QueryMaker();
        $instance->statement = "INSERT INTO $table ($fields) VALUES ($params)";
        $instance->query     = "INSERT INTO $table ($fields) VALUES ($queryValues)";
        $instance->params    = $values;

        return $instance;
    }

    public static function delete($table) : QueryInterface
    {
        $instance            = new QueryMaker();
        $instance->statement = 'DELETE FROM ' . $table;
        $instance->query     = 'DELETE FROM ' . $table;
        return $instance;
    }

    public function where($key, $value, string $operator = '=') : QueryInterface
    {
        $this->checkOperator($operator);

        $this->statement   .= ' WHERE ' . $key . $operator . ':' . $key;
        $this->query       .= ' WHERE ' . $key . $operator . '\'' . $value . '\'';
        $this->params[$key] = $value;
        return $this;
    }

    public function and($key, $value, string $operator = '=') : QueryInterface
    {
        $this->checkOperator($operator);

        $this->query     .= ' AND ';
        $this->statement .= ' AND ';
        $this->prepareParam($key, $value, 'AND', $operator);
        return $this;
    }

    public function orderBy($key, string $order = 'ASC') : QueryInterface
    {
        $this->orderBy .= ' ORDER BY ' . $key . ' ' . $order;
        return $this;
    }

    public function limit(int $limit) : QueryInterface
    {
        $this->limit .= ' LIMIT ' . $limit;
        return $this;
    }

    public function offset(int $offset) : QueryInterface
    {
        $this->limit .= ' OFFSET ' . $offset;
        return $this;
    }

    public function or($key, $value, $operator = '=') : QueryInterface
    {
        $this->checkOperator($operator);

        $this->query     .= " OR ";
        $this->statement .= " OR ";
        $this->prepareParam($key, $value, 'OR');
        return $this;
    }

    public function between($key, $before, $after) : QueryInterface
    {
        $this->query     .= $key . " BETWEEN $before AND $after";
        $this->statement .= $key . ' BETWEEN :before AND :after';

        $this->params['before'] = $before;
        $this->params['after']  = $after;
        return $this;
    }

    public function getQuery() : string
    {
        return $this->query . $this->orderBy . $this->limit;
    }

    public function getStatement() : string
    {
        return $this->statement . $this->orderBy . $this->limit;
    }

    public function getParams() : array
    {
        return $this->params;
    }

    private function prepareParams(array $values, string $glue, string $operator = '=')
    {
        $this->checkOperator($operator);
        $params      = [];
        $queryValues = [];

        foreach ($values as $key => $value) {
            if (!isset($this->params[$key])) {
                $queryValues[] = $key . $operator . '\'' . $value . '\'';
                $params []     = $key . $operator . ':' . $key;

                $this->params[$key] = $value;
            } else {
                $uniqid        = uniqid('', true);
                $queryValues[] = $key . $operator . '\'' . $value . '\'';
                $params []     = $key . $operator . ':' . $key . $uniqid;

                $this->params[$key . $uniqid] = $value;
            }
        }

        $this->query     .= implode($glue, $queryValues);
        $this->statement .= implode($glue, $params);
    }

    private function prepareParam(string $key, $value, string $glue, $operator = '=') : void
    {
        $this->prepareParams([$key => $value], $glue, $operator);
    }

    private function checkOperator(string $operator) : void
    {
        $operators = ['=', '>', '>=', '<', '<=', 'LIKE'];
        if (!in_array($operator, $operators, true)) {
            throw new InvalidArgumentException('Invalid Operator');
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace midorikocak\querymaker;
6
7		use InvalidArgumentException;
8
9		use function array_keys;
10		use function array_map;
11		use function array_values;
12		use function implode;
13		use function in_array;
14		use function uniqid;
15
16		class QueryMaker implements QueryInterface
17		{
18		private string $query;
19		private string $statement;
20	21	private array $params;
21		private string $offset;
		0 ignored issues – show introduced 2020-02-03 16:12 UTC by Report Bug Copy Issue Report The private property `$offset` is not used, and could be removed. Loading history...
22	21	private string $limit;
23	21	private string $orderBy;
24	21
25	21	private function __construct()
26		{
27	18	$this->query = '';
28		$this->statement = '';
29	18	$this->params = [];
30	18
31	18	$this->limit = '';
32	18	$this->orderBy = '';
33		}
34
35	3	public static function select($table, array $columns = ['*']) : QueryInterface
36		{
37	3	$instance = new QueryMaker();
38	3	$columnsText = implode(', ', $columns);
39	3	$instance->statement = 'SELECT ' . $columnsText . ' FROM ' . $table;
40	3	$instance->query = 'SELECT ' . $columnsText . ' FROM ' . $table;
41		return $instance;
42		}
43	15
44		public static function update($table, array $values) : QueryInterface
45	15	{
46	15	$instance = new QueryMaker();
47		$instance->statement = 'UPDATE ' . $table . ' SET ';
48		$instance->query = 'UPDATE ' . $table . ' SET ';
49	15	$instance->prepareParams($values, ', ');
50		return $instance;
51		}
52	15
53	15	public static function insert($table, array $values) : QueryInterface
54	15	{
55	15	$fields = implode(', ', array_keys($values));
56		$params = implode(', ', array_map(fn($key) => ':' . $key, array_keys($values)));
57		$queryValues = implode(', ', array_map(fn($value) => "'$value'", array_values($values)));
58	6
59		$instance = new QueryMaker();
60	6	$instance->statement = "INSERT INTO $table ($fields) VALUES ($params)";
61	6	$instance->query = "INSERT INTO $table ($fields) VALUES ($queryValues)";
62	6	$instance->params = $values;
63	6
64		return $instance;
65		}
66	6
67		public static function delete($table) : QueryInterface
68	6	{
69	6	$instance = new QueryMaker();
70	6	$instance->statement = 'DELETE FROM ' . $table;
71	6	$instance->query = 'DELETE FROM ' . $table;
72		return $instance;
73		}
74
75		public function where($key, $value, string $operator = '=') : QueryInterface
76		{
77		$this->checkOperator($operator);
78
79		$this->statement .= ' WHERE ' . $key . $operator . ':' . $key;
80		$this->query .= ' WHERE ' . $key . $operator . '\'' . $value . '\'';
81		$this->params[$key] = $value;
82		return $this;
83		}
84	21
85		public function and($key, $value, string $operator = '=') : QueryInterface
86	21	{
87		$this->checkOperator($operator);
88
89	21	$this->query .= ' AND ';
90		$this->statement .= ' AND ';
91	21	$this->prepareParam($key, $value, 'AND', $operator);
92		return $this;
93		}
94
95		public function orderBy($key, string $order = 'ASC') : QueryInterface
96		{
97		$this->orderBy .= ' ORDER BY ' . $key . ' ' . $order;
98		return $this;
99	12	}
100
101	12	public function limit(int $limit) : QueryInterface
102	12	{
103		$this->limit .= ' LIMIT ' . $limit;
104	12	return $this;
105	12	}
106	12
107		public function offset(int $offset) : QueryInterface
108		{
109		$this->limit .= ' OFFSET ' . $offset;
110	12	return $this;
111		}
112
113	12	public function or($key, $value, $operator = '=') : QueryInterface
114	12	{
115	12	$this->checkOperator($operator);
116
117	12	$this->query .= " OR ";
118		$this->statement .= " OR ";
119		$this->prepareParam($key, $value, 'OR');
120		return $this;
121		}
122
123		public function between($key, $before, $after) : QueryInterface
124		{
125		$this->query .= $key . " BETWEEN $before AND $after";
126		$this->statement .= $key . ' BETWEEN :before AND :after';
127	12
128	12	$this->params['before'] = $before;
129	12	$this->params['after'] = $after;
130		return $this;
131	9	}
132
133	9	public function getQuery() : string
134	9	{
135		return $this->query . $this->orderBy . $this->limit;
136		}
137
138		public function getStatement() : string
139		{
140		return $this->statement . $this->orderBy . $this->limit;
141		}
142
143		public function getParams() : array
144		{
145		return $this->params;
146		}
147
148		private function prepareParams(array $values, string $glue, string $operator = '=')
149		{
150		$this->checkOperator($operator);
151		$params = [];
152		$queryValues = [];
153
154		foreach ($values as $key => $value) {
155		if (!isset($this->params[$key])) {
156		$queryValues[] = $key . $operator . '\'' . $value . '\'';
157		$params [] = $key . $operator . ':' . $key;
158
159		$this->params[$key] = $value;
160		} else {
161		$uniqid = uniqid('', true);
162		$queryValues[] = $key . $operator . '\'' . $value . '\'';
163		$params [] = $key . $operator . ':' . $key . $uniqid;
164
165		$this->params[$key . $uniqid] = $value;
166		}
167		}
168
169		$this->query .= implode($glue, $queryValues);
170		$this->statement .= implode($glue, $params);
171		}
172
173		private function prepareParam(string $key, $value, string $glue, $operator = '=') : void
174		{
175		$this->prepareParams([$key => $value], $glue, $operator);
176		}
177
178		private function checkOperator(string $operator) : void
179		{
180		$operators = ['=', '>', '>=', '<', '<=', 'LIKE'];
181		if (!in_array($operator, $operators, true)) {
182		throw new InvalidArgumentException('Invalid Operator');
183		}
184		}
185		}
186

midorikocak / querymaker

Push — master ( c6af74...0c144d )

QueryMaker::checkOperator() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like