kiri-databases/ActiveQuery.php

<?php
/**
 * Created by PhpStorm.
 * User: whwyy
 * Date: 2018/4/4 0004
 * Time: 14:42
 */
declare(strict_types=1);

namespace Database;

use Database\Traits\QueryTrait;
use Exception;
use JetBrains\PhpStorm\ArrayShape;
use Kiri\Abstracts\Component;

/**
 * Class ActiveQuery
 * @package Database
 */
class ActiveQuery extends Component implements ISqlBuilder
{

    use QueryTrait;

    /** @var array */
    public array $with = [];

    /** @var bool */
    public bool $asArray = FALSE;

    /** @var bool */
    public bool $useCache = FALSE;

    /**
     * @var Connection|null
     */
    public ?Connection $db = NULL;

    /**
     * @var array
     * 参数绑定
     */
    public array $attributes = [];


    /**
     * Comply constructor.
     * @param $model
     * @param array $config
     * @throws
     */
    public function __construct($model, array $config = [])
    {
        $this->modelClass = $model;

        $this->builder = SqlBuilder::builder($this);
        parent::__construct($config);
    }


    /**
     * 清除不完整数据
     */
    public function clear()
    {
        $this->db = NULL;
        $this->useCache = FALSE;
        $this->with = [];
    }

    /**
     * @param $key
     * @param $value
     * @return $this
     */
    public function addParam($key, $value): static
    {
        $this->attributes[$key] = $value;
        return $this;
    }


    /**
     * @param int $size
     * @param int $page
     * @return array
     * @throws
     */
    #[ArrayShape([])]
    public function pagination(int $size = 20, int $page = 1): array
    {
        $page = max(1, $page);
        $size = max(1, $size);

        $offset = ($page - 1) * $size;

        $count = $this->count();
        $lists = $this->limit($offset, $size)->get()->toArray();
        return [
            'code'   => 0,
            'message'   => 'ok',
            'size'   => $size,
            'page'   => $page,
            'count'  => $count,
            'next'   => max($page + 1, 1),
            'prev'   => max($page - 1, 1),
            'param' => $lists,
        ];
    }
	
	
	/**
	 * @param bool $asArray
	 * @return static
	 */
	public function asArray(bool $asArray = true): static
	{
		$this->asArray = $asArray;
		return $this;
	}


    /**
     * @param array $values
     * @return $this
     */
    public function addParams(array $values): static
    {
        foreach ($values as $key => $val) {
            $this->addParam($key, $val);
        }
        return $this;
    }

	/**
	 * @param array $name
	 * @return $this
	 */
    public function with(array $name): static
    {
        foreach ($name as $val) {
	        $this->with[] = $val;
        }
        return $this;
    }


    /**
     * @param $sql
     * @param array $params
     * @return mixed
     * @throws
     */
    public function execute($sql, array $params = []): Command
    {
        return $this->modelClass->getConnection()->createCommand($sql, $params);
    }


    /**
     * @return ModelInterface|null
     * @throws
     */
    public function first(): ModelInterface|null
    {
        $data = $this->execute($this->builder->one())->one();
        if (!is_null($data)) {
	        return $this->populate($data);
        } else {
	        return NULL;
        }
    }


    /**
     * @return string
     * @throws
     */
    public function toSql(): string
    {
        return $this->builder->get();
    }


    /**
     * @return array|Collection
     */
    public function get(): Collection|array
    {
        return $this->all();
    }


    /**
     * @throws
     */
    public function flush(): array|bool|int|string|null
    {
        return $this->execute($this->builder->truncate())->exec();
    }


    /**
     * @param int $size
     * @param callable $callback
     * @param int $offset
     * @return Pagination
     * @throws
     */
    public function page(int $size, callable $callback, int $offset = 0): Pagination
    {
        $pagination = new Pagination($this);
        $pagination->setOffset($offset);
        $pagination->setLimit($size);
        $pagination->setCallback($callback);
        return $pagination;
    }

    /**
     * @param string $field
     * @param string $setKey
     *
     * @return array|null
     * @throws
     */
    public function column(string $field, string $setKey = ''): ?array
    {
        return $this->all()->column($field, $setKey);
    }



    /**
     * @return array|Collection
     * @throws
     */
    public function all(): Collection|array
    {
        if (!($data = $this->execute($this->builder->all())->all())) {
            return new Collection($this, [], $this->modelClass);
        }

        $this->getWith($this->modelClass);
        $collect = new Collection($this, $data, $this->modelClass);

        return $this->asArray ? $collect->toArray() : $collect;
    }

    /**
     * @param $data
     * @return ModelInterface
     * @throws
     */
    public function populate($data): ModelInterface
    {
        return $this->getWith($this->modelClass::populate($data));
    }


    /**
     * @param ModelInterface $model
     * @return ModelInterface
     */
    public function getWith(ModelInterface $model): ModelInterface
    {
        return $model->setWith($this->with);
    }

    /**
     * @return int
     * @throws
     */
    public function count(): int
    {
        $data = $this->execute($this->builder->count())->one();
        if ($data && is_array($data)) {
            return (int)array_shift($data);
        }
        return 0;
    }


    /**
     * @param array $data
     * @return bool
     * @throws
     */
    public function update(array $data): bool
    {
        $generate = $this->builder->update($data);
        if (is_bool($generate)) {
            return $generate;
        }
        return (bool)$this->execute(...$generate)->exec();
    }

    /**
     * @param array $data
     * @return bool
     * @throws
     */
    public function insert(array $data): bool
    {
        [$sql, $params] = $this->builder->insert($data, TRUE);


        return (bool)$this->execute($sql, $params)->exec();
    }

    /**
     * @param $filed
     *
     * @return null
     * @throws
     */
    public function value($filed)
    {
        return $this->first()[$filed] ?? NULL;
    }

    /**
     * @return bool
     * @throws
     */
    public function exists(): bool
    {
        return !empty($this->execute($this->builder->one())->fetchColumn());
    }
	
	
	/**
	 * @param bool $getSql
	 * @return bool|string
	 * @throws Exception
	 */
    public function delete(bool $getSql = FALSE): bool|string
    {
        $sql = $this->builder->delete();
        if ($getSql === FALSE) {
            return (bool)$this->execute($sql)->delete();
        }
        return $sql;
    }
}