Where::parse() - Code Metrics - pomm-project/Foundation - Measure and Improve Code Quality continuously with Scrutinizer

Where::parse() A
last analyzed 2020-12-01 08:51 UTC

↳ Parent: Where

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
cc	3
nc	3
nop	0

<?php
/*
 * This file is part of the PommProject/Foundation package.
 *
 * (c) 2011 - 2017 Grégoire HUBERT <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PommProject\Foundation;

/**
 * Where
 *
 * This class represents a WHERE clause of a SQL statement. It deals with AND &
 * OR operator you can add using handy methods. This allows you to build
 * queries dynamically.
 *
 * @package   Foundation
 * @copyright 2014 - 2017 Grégoire HUBERT
 * @author    Grégoire HUBERT <[email protected]>
 * @license   X11 {@link http://opensource.org/licenses/mit-license.php}
 */
class Where
{
    public $stack = [];
    public $element;
    public $values = [];
    public $operator;

    /**
     * create
     *
     * A constructor you can chain from.
     *
     * @param  string $element
     * @param  array  $values
     * @return Where
     */
    public static function create($element = null, array $values = [])
    {
        return new self($element, $values);
    }

    /**
     * createWhereIn
     *
     * Create an escaped IN clause.
     *
     * @param  string $element
     * @param  array  $values
     * @return Where
     */
    public static function createWhereIn($element, array $values)
    {
        return self::createGroupCondition($element, 'IN', $values);
    }

    /**
     * createWhereNotIn
     *
     * Create an escaped NOT IN clause.
     *
     * @param  string $element
     * @param  array $values
     * @return Where
     */
    public static function createWhereNotIn($element, array $values)
    {
        return self::createGroupCondition($element, 'NOT IN', $values);
    }

    /**
     * createGroupCondition
     *
     * Create a Where instance with multiple escaped parameters. This is mainly
     * useful for IN or NOT IN clauses.
     *
     * @param  string $element
     * @param  string $operation
     * @param  array  $values
     * @return Where
     */
    public static function createGroupCondition($element, $operation, array $values)
    {
        return new self(
            sprintf(
                "%s %s (%s)",
                $element,
                $operation,
                join(", ", static::escapeSet($values))
            ),
            static::extractValues($values)
        );
    }

    /**
     * extractValues
     *
     * Extract values with consistent keys.
     *
     * @param  array $values
     * @return array
     */
    protected static function extractValues(array $values)
    {
        $array = [];

        foreach (new \RecursiveIteratorIterator(new \RecursiveArrayIterator($values)) as $value) {
            $array[] = $value;
        }

        return $array;
    }

    /**
     * escapeSet
     *
     * Create an array of escaped strings from a value set.
     *
     * @param  array $values
     * @return array
     */
    protected static function escapeSet(array $values)
    {
        $escaped_values = [];

        foreach ($values as $value) {
            if (is_array($value)) {
                $escaped_values[] =
                    sprintf("(%s)", join(', ', static::escapeSet($value)));
            } else {
                $escaped_values[] = '$*';
            }
        }

        return $escaped_values;
    }

    /**
     * __construct
     *
     * @param string $element (optional)
     * @param array  $values  (optional)
     */
    public function __construct($element = null, array $values = [])
    {
        if ($element !== null) {
            $this->element = $element;
            $this->values = $values;
        }
    }

    /**
     * setOperator
     *
     * is it an AND or an OR ?
     * or something else.
     * XOR can be expressed as "A = !B"
     *
     * @param  string $operator
     * @return Where
     */
    public function setOperator($operator)
    {
        $this->operator = $operator;

        return $this;
    }

    /**
     * isEmpty
     *
     * is it a fresh brand new object ?
     *
     * @return boolean
     */
    public function isEmpty()
    {
        return (bool) ($this->element === null && count($this->stack) == 0);
    }

    /**
     * transmute
     *
     * Absorbing another Where instance.
     *
     * @param  Where $where
     * @return Where $this
     */
    private function transmute(Where $where)
    {
        $this->stack    = $where->stack;
        $this->element  = $where->element;
        $this->operator = $where->operator;
        $this->values   = $where->values;
    }

    /**
     * addWhere
     *
     * You can add a new WHERE clause with your own operator.
     *
     * @param  mixed  $element
     * @param  array  $values
     * @param  string $operator
     * @return Where
     */
    public function addWhere($element, array $values, $operator)
    {
        if (!$element instanceof Where) {
            $element = new self($element, $values);
        }

        if ($element->isEmpty()) {
            return $this;
        }

        if ($this->isEmpty()) {
            $this->transmute($element);

            return $this;
        }

        if ($this->hasElement()) {
            $this->stack = [new self($this->getElement(), $this->values), $element];
            $this->element = null;
            $this->values = [];
        } else {
            if ($this->operator == $operator) {
                $this->stack[] = $element;
            } else {
                $this->stack = [
                    self::create()
                        ->setStack($this->stack)
                        ->setOperator($this->operator),
                    $element
                ];
            }
        }

        $this->operator = $operator;

        return $this;
    }

    /**
     * andWhere
     *
     * Or use a ready to use AND where clause.
     *
     * @param  mixed $element
     * @param  array $values
     * @return Where
     */
    public function andWhere($element, array $values = [])
    {
        return $this->addWhere($element, $values, 'AND');
    }

    /**
     * orWhere
     *
     * @param  mixed $element
     * @param  array $values
     * @return Where
     */
    public function orWhere($element, array $values = [])
    {
        return $this->addWhere($element, $values, 'OR');
    }

    /**
     * setStack
     *
     * @param  array $stack
     * @return Where
     */
    public function setStack(array $stack)
    {
        $this->stack = $stack;

        return $this;
    }

    /**
     * __toString
     *
     * where your SQL statement is built.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->isEmpty() ? 'true' : $this->parse();
    }

    /**
     * hasElement
     *
     * @return boolean
     */
    public function hasElement()
    {
        return $this->element !== null;
    }

    /**
     * getElement
     *
     * @return string
     */
    public function getElement()
    {
        return $this->element;
    }

    /**
     * parse
     *
     * @return string
     */
    protected function parse()
    {
        if ($this->hasElement()) {
            return $this->getElement();
        }

        $stack = [];
        foreach ($this->stack as $offset => $where) {
            $stack[$offset] = $where->parse();
        }

        return sprintf('(%s)', join(sprintf(' %s ', $this->operator), $stack));
    }

    /**
     * getValues
     *
     * Get all the values back for the prepared statement.
     *
     * @return array
     */
    public function getValues()
    {
        if ($this->isEmpty()) {
            return [];
        }

        if ($this->hasElement()) {
            return $this->values;
        }

        $values = [];

        foreach ($this->stack as $where) {
            $values[] = $where->getValues();
        }

        return call_user_func_array('array_merge', $values);
    }
}


1			<?php
2			/*
3			* This file is part of the PommProject/Foundation package.
4			*
5			* (c) 2011 - 2017 Grégoire HUBERT <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10			namespace PommProject\Foundation;
11
12			/**
13			* Where
14			*
15			* This class represents a WHERE clause of a SQL statement. It deals with AND &
16			* OR operator you can add using handy methods. This allows you to build
17			* queries dynamically.
18			*
19			* @package Foundation
20			* @copyright 2014 - 2017 Grégoire HUBERT
21			* @author Grégoire HUBERT <[email protected]>
22			* @license X11 {@link http://opensource.org/licenses/mit-license.php}
23			*/
24			class Where
25			{
26			public $stack = [];
27			public $element;
28			public $values = [];
29			public $operator;
30
31			/**
32			* create
33			*
34			* A constructor you can chain from.
35			*
36			* @param string $element
37			* @param array $values
38			* @return Where
39			*/
40			public static function create($element = null, array $values = [])
41			{
42			return new self($element, $values);
43			}
44
45			/**
46			* createWhereIn
47			*
48			* Create an escaped IN clause.
49			*
50			* @param string $element
51			* @param array $values
52			* @return Where
53			*/
54			public static function createWhereIn($element, array $values)
55			{
56			return self::createGroupCondition($element, 'IN', $values);
57			}
58
59			/**
60			* createWhereNotIn
61			*
62			* Create an escaped NOT IN clause.
63			*
64			* @param string $element
65			* @param array $values
66			* @return Where
67			*/
68			public static function createWhereNotIn($element, array $values)
69			{
70			return self::createGroupCondition($element, 'NOT IN', $values);
71			}
72
73			/**
74			* createGroupCondition
75			*
76			* Create a Where instance with multiple escaped parameters. This is mainly
77			* useful for IN or NOT IN clauses.
78			*
79			* @param string $element
80			* @param string $operation
81			* @param array $values
82			* @return Where
83			*/
84			public static function createGroupCondition($element, $operation, array $values)
85			{
86			return new self(
87			sprintf(
88			"%s %s (%s)",
89			$element,
90			$operation,
91			join(", ", static::escapeSet($values))
92			),
93			static::extractValues($values)
94			);
95			}
96
97			/**
98			* extractValues
99			*
100			* Extract values with consistent keys.
101			*
102			* @param array $values
103			* @return array
104			*/
105			protected static function extractValues(array $values)
106			{
107			$array = [];
108
109			foreach (new \RecursiveIteratorIterator(new \RecursiveArrayIterator($values)) as $value) {
110			$array[] = $value;
111			}
112
113			return $array;
114			}
115
116			/**
117			* escapeSet
118			*
119			* Create an array of escaped strings from a value set.
120			*
121			* @param array $values
122			* @return array
123			*/
124			protected static function escapeSet(array $values)
125			{
126			$escaped_values = [];
127
128			foreach ($values as $value) {
129			if (is_array($value)) {
130			$escaped_values[] =
131			sprintf("(%s)", join(', ', static::escapeSet($value)));
132			} else {
133			$escaped_values[] = '$*';
134			}
135			}
136
137			return $escaped_values;
138			}
139
140			/**
141			* __construct
142			*
143			* @param string $element (optional)
144			* @param array $values (optional)
145			*/
146			public function __construct($element = null, array $values = [])
147			{
148			if ($element !== null) {
149			$this->element = $element;
150			$this->values = $values;
151			}
152			}
153
154			/**
155			* setOperator
156			*
157			* is it an AND or an OR ?
158			* or something else.
159			* XOR can be expressed as "A = !B"
160			*
161			* @param string $operator
162			* @return Where
163			*/
164			public function setOperator($operator)
165			{
166			$this->operator = $operator;
167
168			return $this;
169			}
170
171			/**
172			* isEmpty
173			*
174			* is it a fresh brand new object ?
175			*
176			* @return boolean
177			*/
178			public function isEmpty()
179			{
180			return (bool) ($this->element === null && count($this->stack) == 0);
181			}
182
183			/**
184			* transmute
185			*
186			* Absorbing another Where instance.
187			*
188			* @param Where $where
189			* @return Where $this
190			*/
191			private function transmute(Where $where)
192			{
193			$this->stack = $where->stack;
194			$this->element = $where->element;
195			$this->operator = $where->operator;
196			$this->values = $where->values;
197			}
198
199			/**
200			* addWhere
201			*
202			* You can add a new WHERE clause with your own operator.
203			*
204			* @param mixed $element
205			* @param array $values
206			* @param string $operator
207			* @return Where
208			*/
209			public function addWhere($element, array $values, $operator)
210			{
211			if (!$element instanceof Where) {
212			$element = new self($element, $values);
213			}
214
215			if ($element->isEmpty()) {
216			return $this;
217			}
218
219			if ($this->isEmpty()) {
220			$this->transmute($element);
221
222			return $this;
223			}
224
225			if ($this->hasElement()) {
226			$this->stack = [new self($this->getElement(), $this->values), $element];
227			$this->element = null;
228			$this->values = [];
229			} else {
230			if ($this->operator == $operator) {
231			$this->stack[] = $element;
232			} else {
233			$this->stack = [
234			self::create()
235			->setStack($this->stack)
236			->setOperator($this->operator),
237			$element
238			];
239			}
240			}
241
242			$this->operator = $operator;
243
244			return $this;
245			}
246
247			/**
248			* andWhere
249			*
250			* Or use a ready to use AND where clause.
251			*
252			* @param mixed $element
253			* @param array $values
254			* @return Where
255			*/
256			public function andWhere($element, array $values = [])
257			{
258			return $this->addWhere($element, $values, 'AND');
259			}
260
261			/**
262			* orWhere
263			*
264			* @param mixed $element
265			* @param array $values
266			* @return Where
267			*/
268			public function orWhere($element, array $values = [])
269			{
270			return $this->addWhere($element, $values, 'OR');
271			}
272
273			/**
274			* setStack
275			*
276			* @param array $stack
277			* @return Where
278			*/
279			public function setStack(array $stack)
280			{
281			$this->stack = $stack;
282
283			return $this;
284			}
285
286			/**
287			* __toString
288			*
289			* where your SQL statement is built.
290			*
291			* @return string
292			*/
293			public function __toString()
294			{
295			return $this->isEmpty() ? 'true' : $this->parse();
296			}
297
298			/**
299			* hasElement
300			*
301			* @return boolean
302			*/
303			public function hasElement()
304			{
305			return $this->element !== null;
306			}
307
308			/**
309			* getElement
310			*
311			* @return string
312			*/
313			public function getElement()
314			{
315			return $this->element;
316			}
317
318			/**
319			* parse
320			*
321			* @return string
322			*/
323			protected function parse()
324			{
325			if ($this->hasElement()) {
326			return $this->getElement();
327			}
328
329			$stack = [];
330			foreach ($this->stack as $offset => $where) {
331			$stack[$offset] = $where->parse();
332			}
333
334			return sprintf('(%s)', join(sprintf(' %s ', $this->operator), $stack));
335			}
336
337			/**
338			* getValues
339			*
340			* Get all the values back for the prepared statement.
341			*
342			* @return array
343			*/
344			public function getValues()
345			{
346			if ($this->isEmpty()) {
347			return [];
348			}
349
350			if ($this->hasElement()) {
351			return $this->values;
352			}
353
354			$values = [];
355
356			foreach ($this->stack as $where) {
357			$values[] = $where->getValues();
358			}
359
360			return call_user_func_array('array_merge', $values);
361			}
362			}
363

pomm-project / Foundation

Where::parse() A last analyzed 2020-12-01 08:51 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Where::parse() A
last analyzed 2020-12-01 08:51 UTC