ntentan\nibii\QueryParameters

Complexity

Total Complexity

37

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Coupling/Cohesion

Components	5
Dependencies	3

Test Coverage

Coverage

84.88%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getFields()	0	10	2
A	setFields()	0	5	1
A	getTable()	0	4	1
A	setTable()	0	5	1
A	getLimit()	0	4	2
A	getOffset()	0	4	2
B	getWhereClause()	0	15	5
B	getBoundData()	0	16	5
B	setBoundData()	0	16	6
A	getSorts()	0	4	2
A	addFilter()	0	19	3
A	setFilter()	0	8	1
A	setFirstOnly()	0	5	1
A	getFirstOnly()	0	4	1
A	setLimit()	0	4	1
A	setOffset()	0	4	1
A	addSort()	0	4	1

<?php

namespace ntentan\nibii;

use ntentan\nibii\exceptions\FieldNotFoundException;
use ntentan\nibii\exceptions\NibiiException;

/**
 * Holds parameters used for the fields, where clauses, limits and offsets in queries
 *
 * @author ekow
 */
class QueryParameters
{
    /**
     * The where clause string of the query parameters.
     *
     * @var string
     */
    private $whereClause;

    /**
     * The string used for conjuctions.
     * This could either be 'AND' and or an 'OR' operator.
     *
     * @var string
     */
    private $conjunction = '';

    /**
     * Data that will be bound when a query is executed with this object.
     *
     * @var array
     */
    private $boundData = [];

    /**
     * This flag is set to true whenever there is bound data prepared.
     *
     * @var bool
     */
    private $preparedBoundData = false;

    /**
     * A list of fields that have arrays bound to them.
     *
     * @var array
     */
    private $boundArrays = [];

    /**
     * A list of fields that should be returned for the query.
     *
     * @var array
     */
    private $fields = [];

    /**
     * The database table to be queried.
     *
     * @var null|string
     */
    private $table;

    /**
     * When this flag is set, only the first item in the query is returned.
     * It essentially forces a limit of 1.
     *
     * @var bool
     */
    private $firstOnly = false;

    /**
     * The number of records to return after the query.
     *
     * @var int
     */
    private $limit;

    /**
     * The number of items to skip in the query.
     *
     * @var int
     */
    private $offset;

    /**
     * Holds a list of sorted fields, sort order and the order by which they should all be sorted.
     *
     * @var array
     */
    private $sorts = [];

    /**
     * QueryParameters constructor
     *
     * @param string $table The name of the table
     */
    public function __construct($table = null)
    {
        $this->table = $table;
    }

    /**
     * Get the comma seperated list of fields for the query.
     * In cases where no fields have been specifid, the wildcard * is returned.
     *
     * @return string
     */
    public function getFields()
    {
        $fields = '*';

        if (count($this->fields) > 0) {
            $fields = implode(', ', $this->fields);
        }

        return $fields;
    }

    /**
     * Set an array of fields that this query should return.
     *
     * @param array $fields
     * @return $this
     */
    public function setFields(array $fields)
    {
        $this->fields = $fields;
        return $this;
    }

    /**
     * Get the table for this query.
     *
     * @return null|string
     */
    public function getTable()
    {
        return $this->table;
    }

    /**
     * Set the table for this query.
     *
     * @param $table
     * @return $this For chaining
     */
    public function setTable($table)
    {
        $this->table = $table;
        return $this;
    }

    /**
     * Gets the limit clause of the query.
     *
     * @return null|string
     */
    public function getLimit()
    {
        return $this->limit > 0 ? " LIMIT {$this->limit}" : null;
    }

    public function getOffset()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->offset > 0 ? " OFFSET {$this->offset}" : null;
    }

    public function getWhereClause()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if ($this->whereClause) {
            foreach ($this->boundArrays as $boundArray) {
                $where = "";
                $comma = "";
                for ($i = 0; $i < count($this->boundData[$boundArray]); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                    $where .= "{$comma}:{$boundArray}_{$i}";
                    $comma = ', ';
                }
                $this->whereClause = str_replace("%{$boundArray}%", $where, $this->whereClause);
            }
        }
        return $this->whereClause ? " WHERE {$this->whereClause}" : '';
    }

    public function getBoundData()
    {
        if ($this->preparedBoundData === false) {
            $this->preparedBoundData = [];

It seems like array() of type array is incompatible with the declared type boolean of property $preparedBoundData.

            foreach ($this->boundData as $key => $value) {
                if (in_array($key, $this->boundArrays)) {
                    foreach ($value as $i => $v) {
                        $this->preparedBoundData["{$key}_{$i}"] = $v;
                    }
                } else {
                    $this->preparedBoundData[$key] = $value;
                }
            }
        }
        return $this->preparedBoundData;
    }

    public function setBoundData($field, $value)
    {
        if (array_key_exists($field, $this->boundData)) {
            $isArray = is_array($value);
            $boundArray = in_array($field, $this->boundArrays);
            if ($isArray && !$boundArray) {
                throw new NibiiException("The field '{$field}' cannot be bound to an array");
            } else if (!$isArray && $boundArray) {
                throw new NibiiException("The field '{$field}' must be bound to an array");
            }
            $this->boundData[$field] = $value;
            $this->preparedBoundData = false;
            return $this;
        }
        throw new FieldNotFoundException("The field '{$field}' has not been bound to the current query");
    }

    public function getSorts()
    {
        return count($this->sorts) ? " ORDER BY " . implode(", ", $this->sorts) : null;
    }

    public function addFilter($field, $values = null)
    {
        $this->whereClause .= $this->conjunction;

        if (is_array($values)) {
            $this->whereClause .= "{$field} IN (%{$field}%)";
            $this->boundArrays[] = $field;
            $this->boundData[$field] = $values;
        } else {
            if ($values === null) {
                $this->whereClause .= "{$field} is NULL";
            } else {
                $this->whereClause .= "{$field} = :$field";
                $this->boundData[$field] = $values;
            }
        }
        $this->conjunction = ' AND ';
        return $this;
    }

    public function setFilter($filter, $values)
    {
        $filterCompiler = new FilterCompiler();
        $compiledFilter = $filterCompiler->compile($filter);
        $compiledValues = $filterCompiler->rewriteBoundData($values);
        $this->whereClause .= "{$this->conjunction}$compiledFilter";
        $this->boundData += $compiledValues;
    }

    /**
     * @param boolean $firstOnly
     * @return $this
     */
    public function setFirstOnly($firstOnly)
    {
        $this->firstOnly = $firstOnly;
        return $this;
    }

    public function getFirstOnly()
    {
        return $this->firstOnly;
    }

    public function setLimit($numItems)
    {
        $this->limit = $numItems;
    }

    public function setOffset($offset)
    {
        $this->offset = $offset;
    }

    /**
     * @param string $field
     * @param string $direction
     */
    public function addSort($field, $direction = 'ASC')
    {
        $this->sorts[] = "$field $direction";
    }

}