SQLParser\Query\StatementFactory

Complexity

Total Complexity

18

Size/Duplication

Total Lines	107
Duplicated Lines	18.69 %

Coupling/Cohesion

Components	0
Dependencies	3

Importance

Changes	6
Bugs	1	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
C	toObject()	20	68	10
A	checkLimitDesc()	0	6	2
B	mapArrayToNodeObjectList()	0	20	6

<?php

/**
 * expression-types.php.
 *
 *
 * Copyright (c) 2010-2013, Justin Swanhart
 * with contributions by André Rothe <arothe@phosco.info, phosco@gmx.de>
 * and David Négrier <d.negrier@thecodingmachine.com>
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */

namespace SQLParser\Query;

use SQLParser\Node\NodeFactory;
use SQLParser\Node\Operator;

/**
 * This class has the ability to create instances implementing NodeInterface based on a descriptive array.
 *
 * @author David Négrier <d.negrier@thecodingmachine.com>
 */
class StatementFactory
{
    public static function toObject(array $desc)
    {
        if (isset($desc['SELECT'])) {
            $select = new Select();

            $columns = array_map(function ($item) {
                return NodeFactory::toObject($item);
            }, $desc['SELECT']);
            $columns = NodeFactory::simplify($columns);
            $select->setColumns($columns);

$columns is of type array|object, but the function expects a array<integer,object<SQLParser\Node\NodeInterface>>.

            if (isset($desc['OPTIONS'])) {
                $options = $desc['OPTIONS'];
                $key = array_search('DISTINCT', $options);
                if ($key !== false) {
                    $select->setDistinct(true);
                    unset($options[$key]);
                } else {
                    $select->setDistinct(false);
                }
                $select->setOptions($options);
            }

            if (isset($desc['FROM'])) {
                $from = self::mapArrayToNodeObjectList($desc['FROM']);
                $select->setFrom($from);
            }

            if (isset($desc['WHERE'])) {

This code seems to be duplicated across your project.

                $where = self::mapArrayToNodeObjectList($desc['WHERE']);
                $where = NodeFactory::simplify($where);
                $select->setWhere($where);

$where is of type array|object, but the function expects a array<integer,object<SQLParser\Node\NodeInterface>>|object<SQLParser\Node\NodeInterface>.

            }

            if (isset($desc['GROUP'])) {

This code seems to be duplicated across your project.

                $group = self::mapArrayToNodeObjectList($desc['GROUP']);
                $group = NodeFactory::simplify($group);
                $select->setGroup($group);

$group is of type array|object, but the function expects a array<integer,object<SQLParser\Node\NodeInterface>>|object<SQLParser\Node\NodeInterface>.

            }

            if (isset($desc['HAVING'])) {

This code seems to be duplicated across your project.

                $having = self::mapArrayToNodeObjectList($desc['HAVING']);
                $having = NodeFactory::simplify($having);
                $select->setHaving($having);

$having is of type array|object, but the function expects a array<integer,object<SQLParser\Node\NodeInterface>>|object<SQLParser\Node\NodeInterface>.

            }

            if (isset($desc['ORDER'])) {

This code seems to be duplicated across your project.

                $order = self::mapArrayToNodeObjectList($desc['ORDER']);
                $order = NodeFactory::simplify($order);
                $select->setOrder($order);

$order is of type array|object, but the function expects a array<integer,object<SQLParser\Node\NodeInterface>>|object<SQLParser\Node\NodeInterface>.

            }

            if (isset($desc['LIMIT'])) {
                $descLimit = self::checkLimitDesc($desc['LIMIT']);

                $limit = NodeFactory::toObject($descLimit['limit']);
                //$limit = NodeFactory::simplify($limit);

55% of this comment could be valid code. Did you maybe forget this after debugging?

                $select->setLimit($limit);

                $offset = NodeFactory::toObject($descLimit['offset']);
                //$offset = NodeFactory::simplify($offset);

55% of this comment could be valid code. Did you maybe forget this after debugging?

                $select->setOffset($offset);
            }
            return $select;
        } else {
            throw new \BadMethodCallException('Unknown query');
        }
    }

    /**
     * @param array $descLimit
     * @return array
     * @throws \Exception
     */
    private static function checkLimitDesc(array $descLimit) {
        if(count($descLimit) > 2) {
            throw new \Exception('The limit returned by the SQLParser contains more than 2 items, something might went wrong.');
        }
        return ['offset' => $descLimit[0], 'limit' => $descLimit[1]];
    }

    /**
     * @param array $items An array of objects represented as SQLParser arrays.
     */
    private static function mapArrayToNodeObjectList(array $items) {
        $list = [];

        $nextAndPartOfBetween = false;

        // Special case, let's replace the AND of a between with a ANDBETWEEN object.
        foreach ($items as $item) {
            $obj = NodeFactory::toObject($item);
            if ($obj instanceof Operator) {
                if ($obj->getValue() == 'BETWEEN') {
                    $nextAndPartOfBetween = true;
                } elseif ($nextAndPartOfBetween && $obj->getValue() == 'AND') {
                    $nextAndPartOfBetween = false;
                    $obj->setValue('AND_FROM_BETWEEN');
                }
            }
            $list[] = $obj;
        }
        return $list;
    }
}