Nip\Database\Query\Insert

Complexity

Total Complexity

20

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

89.36%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	assemble()	0	9	1
A	parseCols()	0	7	3
A	setCols()	0	5	1
A	parseValues()	0	9	3
B	parseData()	0	20	6
A	parseOnDuplicate()	0	18	4
A	setValues()	0	6	1
A	onDuplicate()	0	4	1

<?php


namespace Nip\Database\Query;

/**
 * Class Insert
 * @package Nip\Database\Query
 */
class Insert extends AbstractQuery
{
    protected $_cols;

    protected $_values;

    /**
     * @return string
     */
    public function assemble()
    {
        $return = "INSERT INTO " . $this->protect($this->getTable());
        $return .= $this->parseCols();
        $return .= $this->parseValues();
        $return .= $this->parseOnDuplicate();

        return $return;
    }

    /**
     * @return string
     */
    public function parseCols()
    {
        if (is_array($this->parts['data'][0])) {
            $this->setCols(array_keys($this->parts['data'][0]));
        }
        return $this->_cols ? ' (' . implode(',', array_map([$this, 'protect'], $this->_cols)) . ')' : '';
    }

    /**
     * @param array|string $cols
     * @return $this
     */
    public function setCols($cols = null)
    {
        $this->_cols = $cols;
        return $this;
    }

    /**
     * @return string|false
     */
    public function parseValues()
    {
        if ($this->_values instanceof AbstractQuery) {
            return ' ' . (string) $this->_values;
        } elseif (is_array($this->parts['data'])) {
            return $this->parseData();
        }
        return false;
    }

    /**
     * Parses INSERT data
     *
     * @return string
     */
    protected function parseData()
    {
        $values = [];
        foreach ($this->parts['data'] as $key => $data) {
            foreach ($data as $value) {
                if (!is_array($value)) {
                    $value = [$value];
                }

                foreach ($value as $insertValue) {
                    $values[$key][] = $this->getManager()->getAdapter()->quote($insertValue);
                }
            }
        }
        foreach ($values as &$value) {
            $value = "(" . implode(", ", $value) . ")";
        }

        return ' VALUES ' . implode(', ', $values);
    }

    /**
     * @return string
     */
    public function parseOnDuplicate()
    {
        if ($this->hasPart('onDuplicate')) {
            $update = $this->getManager()->newUpdate();

            $onDuplicates = $this->getPart('onDuplicate');
            $data = [];
            foreach ($onDuplicates as $onDuplicate) {
                foreach ($onDuplicate as $key => $value) {
                    $data[$key] = $value;
                }
            }
            $update->data($data);

The call to Update::data() has too many arguments starting with $data.

            return " ON DUPLICATE KEY UPDATE {$update->parseUpdate()}";
        }
        return '';
    }

    public function setValues($values)
    {
        $this->_values = $values;

        return $this;
    }

    public function onDuplicate($value)
    {
        $this->addPart('onDuplicate', $value);
    }
}