suda\database\statement\ReadStatement

Complexity

Total Complexity

30

Size/Duplication

Total Lines	313
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	isRawRead()	0	3	1
A	distinct()	0	4	1
A	read()	0	13	4
A	havingStringArray()	0	5	1
A	orderBy()	0	10	2
A	page()	0	7	2
A	whereStringArray()	0	5	1
A	where()	0	11	4
A	havingArray()	0	4	1
A	limit()	0	4	2
A	prepareWhere()	0	5	1
A	clearOrderBy()	0	3	1
A	aliasKeyField()	0	8	2
A	groupBy()	0	5	1
A	prepareQuery()	0	8	1
A	having()	0	11	3
A	whereArray()	0	4	1

<?php

namespace suda\database\statement;

use function func_get_args;
use function func_num_args;
use function is_array;
use suda\database\struct\TableStruct;
use suda\database\middleware\Middleware;
use suda\database\exception\SQLException;

/**
 * Class ReadStatement
 * @package suda\database\statement
 */
class ReadStatement extends QueryStatement
{
    use PrepareTrait;

    /**
     * 数据表结构
     *
     * @var TableStruct
     */
    protected $struct;

    /**
     * 数据原始表名
     *
     * @var string
     */
    protected $table;

    /**
     * @var string
     */
    protected $distinct = '';

    /**
     * @var string
     */
    protected $select = '*';

    /**
     * @var string
     */
    protected $where = '';

    /**
     * @var string
     */
    protected $groupBy = '';

    /**
     * @var string
     */
    protected $having = '';

    /**
     * @var string
     */
    protected $orderBy = '';

    /**
     * @var string
     */
    protected $limit = '';

    /**
     * @var bool
     */
    protected $rawRead = true;

    /**
     * 创建写
     *
     * @param string $rawTableName
     * @param TableStruct $struct
     * @param Middleware $middleware
     * @throws SQLException
     */
    public function __construct(string $rawTableName, TableStruct $struct, Middleware $middleware)
    {
        parent::__construct('');
        $this->struct = $struct;
        $this->table = $rawTableName;
        $this->type = self::READ;
        $this->fetch = self::FETCH_ONE;
        $this->middleware = $middleware;
    }

    /**
     * 单独去重复
     *
     * @return $this
     */
    public function distinct()
    {
        $this->distinct = 'DISTINCT';
        return $this;
    }

    /**
     * 查询的列
     *
     * @param array|string $fields
     * @return $this
     */
    public function read($fields)
    {
        if (func_num_args() > 1) {
            $fields = func_get_args();
        }
        if (is_array($fields)) {
            $this->rawRead = false;
            foreach ($fields as $index => $name) {
                $fields[$index] = $this->middleware->inputName($name);
            }
        }
        $this->select = $this->prepareReadFields($fields);
        return $this;
    }

    /**
     * @return bool
     */
    public function isRawRead(): bool
    {
        return $this->rawRead;
    }


    /**
     * 条件
     * @param $where
     * @param mixed ...$args
     * @return $this
     * @throws SQLException
     */
    public function where($where, ...$args)
    {
        if (is_array($where)) {
            $this->whereArray($where, $args[0] ?? []);
        } elseif (count($args) > 0 && is_array($args[0])) {
            $this->whereStringArray($where, $args[0]);
        } else {
            list($string, $array) = $this->prepareQueryMark($where, $args);
            $this->whereStringArray($string, $array);
        }
        return $this;
    }

    /**
     * 处理输入的键
     *
     * @param array $fields
     * @return array
     */
    protected function aliasKeyField(array $fields)
    {
        $values = [];
        foreach ($fields as $value) {
            $value[0] = $this->middleware->inputName($value[0]);
            $values[] = $value;
        }
        return $values;
    }

    /**
     * @param array $where
     * @param array $binders
     * @throws SQLException
     */
    protected function whereArray(array $where, array $binders)
    {
        list($where, $whereBinder) = $this->prepareWhere($where);
        $this->whereStringArray($where, array_merge($whereBinder, $binders));
    }

    /**
     * @param array $where
     * @return array
     * @throws SQLException
     */
    public function prepareWhere(array $where)
    {
        $where = $this->normalizeWhereArray($where);
        $where = $this->aliasKeyField($where);
        return parent::prepareWhere($where);
    }

    /**
     * @param string $where
     * @param array $whereBinder
     * @throws SQLException
     */
    protected function whereStringArray(string $where, array $whereBinder)
    {
        list($where, $whereBinder) = $this->prepareWhereString($where, $whereBinder);
        $this->where = 'WHERE ' . $where;
        $this->binder = $this->mergeBinder($this->binder, $whereBinder);
    }

    /**
     * 分组
     *
     * @param string $what
     * @return $this
     */
    public function groupBy(string $what)
    {
        $what = $this->middleware->inputName($what);
        $this->groupBy = 'GROUP BY `' . $what . '`';
        return $this;
    }

    /**
     * 含
     *
     * @param string|array $what
     * @param array $args
     * @return $this
     * @throws SQLException
     */
    public function having($what, ...$args)
    {
        if (is_array($what)) {
            $this->havingArray($what);
        } elseif (is_array($args[0])) {
            $this->havingStringArray($what, $args[0]);
        } else {
            list($string, $array) = $this->prepareQueryMark($what, $args);
            $this->havingStringArray($string, $array);
        }
        return $this;
    }

    /**
     * @param array $want
     * @throws SQLException
     */
    protected function havingArray(array $want)
    {
        list($having, $havingBinder) = $this->prepareWhere($want);
        $this->havingStringArray($having, $havingBinder);
    }

    /**
     * @param string $having
     * @param array $havingBinder
     * @throws SQLException
     */
    protected function havingStringArray(string $having, array $havingBinder)
    {
        list($having, $havingBinder) = $this->prepareWhereString($having, $havingBinder);
        $this->having = 'HAVING ' . $having;
        $this->binder = $this->mergeBinder($this->binder, $havingBinder);
    }

    /**
     * 排序
     *
     * @param string $what
     * @param string $order
     * @return $this
     */
    public function orderBy(string $what, string $order = 'ASC')
    {
        $what = $this->middleware->inputName($what);
        $order = strtoupper($order);
        if (strlen($this->orderBy) > 0) {
            $this->orderBy .= ',`' . $what . '` ' . $order;
        } else {
            $this->orderBy = 'ORDER BY `' . $what . '` ' . $order;
        }
        return $this;
    }

    /**
     * 清除排序语句
     */
    public function clearOrderBy() {
        $this->orderBy = '';
        return $this;
    }

    /**
     * 限制
     *
     * @param int $start
     * @param integer $length
     * @return $this
     */
    public function limit(int $start, int $length = null)
    {
        $this->limit = 'LIMIT ' . $start . ($length !== null ? ',' . $length : '');
        return $this;
    }

    /**
     * 分页
     *
     * @param integer $page
     * @param integer $length
     * @return $this
     */
    public function page(int $page, int $length)
    {
        if ($page <= 0) {
            $page = 1;
        }
        $this->limit(($page - 1) * $length, $length);
        return $this;
    }

    /**
     * 获取字符串
     *
     * @return Query
     */
    protected function prepareQuery(): Query
    {
        $where = [$this->where, $this->groupBy, $this->having, $this->orderBy, $this->limit];
        $condition = implode(' ', array_filter(array_map('trim', $where), 'strlen'));
        $select = [$this->distinct, $this->select];
        $selection = implode(' ', array_filter(array_map('trim', $select), 'strlen'));
        $string = sprintf("SELECT %s FROM %s %s", $selection, $this->table, $condition);
        return new Query($string, $this->binder);
    }
}