e

.gitignore

@@ -0,0 +1,34 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Yii template
+assets/*
+!assets/.gitignore
+protected/runtime/*
+!protected/runtime/.gitignore
+protected/data/*.db
+themes/classic/views/
+
+### Example user template template
+### Example user template
+
+# IntelliJ project files
+.idea
+*.iml
+out
+gen
+
+composer.lock
+
+*.log
+commands/result
+config/setting.php
+tests/
+vendor/
+runtime/
+
+*.xml
+*.lock
+
+oot
+d
+
+composer.lock

.phpstorm.meta.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace PHPSTORM_META {
+
+    // Reflect
+	use Kiri\Di\Container;
+
+	override(Container::get(0), map('@'));
+	override(Container::newObject(0), map('@'));
+//    override(\Hyperf\Utils\Context::get(0), map('@'));
+//    override(\make(0), map('@'));
+    override(\di(0), map('@'));
+    override(\duplicate(0), map('@'));
+
+}

composer.json

@@ -0,0 +1,26 @@
+{
+  "name": "game-worker/db-connection",
+  "description": "db",
+  "authors": [
+    {
+      "name": "XiangLin",
+      "email": "as2252258@163.com"
+    }
+  ],
+  "license": "MIT",
+  "require": {
+    "php": ">=8.0",
+    "ext-json": "*",
+    "ext-pdo": "*",
+    "game-worker/snowflake": "dev-master"
+  },
+  "autoload": {
+    "psr-4": {
+      "Database\\": "src/"
+     }
+  },
+  "require-dev": {
+    "kwn/php-rdkafka-stubs": "^2.0"
+  }
+}
+

src/ActiveQuery.php

@@ -0,0 +1,310 @@
+<?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 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 array $values
+	 * @return $this
+	 */
+	public function addParams(array $values): static
+	{
+		foreach ($values as $key => $val) {
+			$this->addParam($key, $val);
+		}
+		return $this;
+	}
+
+	/**
+	 * @param $name
+	 * @return $this
+	 */
+	public function with($name): static
+	{
+		if (empty($name)) {
+			return $this;
+		}
+		if (is_string($name)) {
+			$name = explode(',', $name);
+		}
+		foreach ($name as $val) {
+			array_push($this->with, $val);
+		}
+		return $this;
+	}
+
+
+	/**
+	 * @param $sql
+	 * @param array $params
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function execute($sql, array $params = []): Command
+	{
+		return $this->modelClass::getDb()->createCommand($sql, $params);
+	}
+
+
+	/**
+	 * @return ActiveRecord|null
+	 * @throws Exception
+	 */
+	public function first(): ActiveRecord|null
+	{
+		$data = $this->execute($this->builder->one())->one();
+		if (empty($data)) {
+			return NULL;
+		}
+		return $this->modelClass::populate($data);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function toSql(): string
+	{
+		return $this->builder->get();
+	}
+
+
+	/**
+	 * @return array|Collection
+	 */
+	public function get(): Collection|array
+	{
+		return $this->all();
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function flush(): array|bool|int|string|null
+	{
+		return $this->execute($this->builder->truncate())->exec();
+	}
+
+
+	/**
+	 * @param int $size
+	 * @param callable $callback
+	 * @return Pagination
+	 * @throws Exception
+	 */
+	public function page(int $size, callable $callback): Pagination
+	{
+		$pagination = new Pagination($this);
+		$pagination->setOffset(0);
+		$pagination->setLimit($size);
+		$pagination->setCallback($callback);
+		return $pagination;
+	}
+
+	/**
+	 * @param string $field
+	 * @param string $setKey
+	 *
+	 * @return array|null
+	 * @throws Exception
+	 */
+	public function column(string $field, string $setKey = ''): ?array
+	{
+		return $this->all()->column($field, $setKey);
+	}
+
+	/**
+	 * @return array|Collection
+	 * @throws
+	 */
+	public function all(): Collection|array
+	{
+		$data = $this->execute($this->builder->all())->all();
+
+		$collect = new Collection($this, $data, $this->modelClass);
+		if ($this->asArray) {
+			return $collect->toArray();
+		}
+		return $collect;
+	}
+
+	/**
+	 * @param ActiveRecord $model
+	 * @param $data
+	 * @return ActiveRecord
+	 * @throws Exception
+	 */
+	public function populate(ActiveRecord $model, $data): ActiveRecord
+	{
+		return $this->getWith($model::populate($data));
+	}
+
+
+	/**
+	 * @param ActiveRecord $model
+	 * @return ActiveRecord
+	 */
+	public function getWith(ActiveRecord $model): ActiveRecord
+	{
+		if (empty($this->with) || !is_array($this->with)) {
+			return $model;
+		}
+		return $model->setWith($this->with);
+	}
+
+	/**
+	 * @return int
+	 * @throws Exception
+	 */
+	public function count(): int
+	{
+		$this->select = ['COUNT(*)'];
+		$data = $this->execute($this->builder->count())->one();
+		if ($data && is_array($data)) {
+			return (int)array_shift($data);
+		}
+		return 0;
+	}
+
+
+	/**
+	 * @param array $data
+	 * @return array|Command|bool|int|string
+	 * @throws Exception
+	 */
+	public function batchUpdate(array $data): Command|array|bool|int|string
+	{
+		$generate = $this->builder->update($data);
+		if (is_bool($generate)) {
+			return $generate;
+		}
+		return $this->execute(...$generate)->exec();
+	}
+
+	/**
+	 * @param array $data
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function batchInsert(array $data): bool
+	{
+		[$sql, $params] = $this->builder->insert($data, true);
+
+
+		return $this->execute($sql, $params)->exec();
+	}
+
+	/**
+	 * @param $filed
+	 *
+	 * @return null
+	 * @throws Exception
+	 */
+	public function value($filed)
+	{
+		return $this->first()[$filed] ?? null;
+	}
+
+	/**
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function exists(): bool
+	{
+		return !empty($this->execute($this->builder->one())->fetchColumn());
+	}
+
+
+	/**
+	 * @param bool $getSql
+	 * @return string|bool
+	 * @throws Exception
+	 */
+	public function delete(bool $getSql = false): string|bool
+	{
+		$sql = $this->builder->delete();
+		if ($getSql === false) {
+			return $this->execute($sql)->delete();
+		}
+		return $sql;
+	}
+}

src/ActiveRecord.php

@@ -0,0 +1,420 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 14:39
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Database\Base\BaseActiveRecord;
+use Database\Traits\HasBase;
+use Exception;
+use ReflectionException;
+use Kiri\Exception\NotFindClassException;
+use Kiri\Kiri;
+
+defined('SAVE_FAIL') or define('SAVE_FAIL', 3227);
+defined('FIND_OR_CREATE_MESSAGE') or define('FIND_OR_CREATE_MESSAGE', 'Create a new model, but the data cannot be empty.');
+
+/**
+ * Class Orm
+ * @package Database
+ *
+ * @property $attributes
+ * @property-read $oldAttributes
+ * @method beforeSearch($model)
+ */
+class ActiveRecord extends BaseActiveRecord
+{
+
+
+	/**
+	 * @return array
+	 */
+	public function rules(): array
+	{
+		return [];
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return ActiveRecord|false
+	 * @throws Exception
+	 */
+	public function increment(string $column, int $value): bool|ActiveRecord
+	{
+		if (!$this->mathematics([$column => $value], '+', null)) {
+			return false;
+		}
+		$this->{$column} += $value;
+		return $this->refresh();
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return ActiveRecord|false
+	 * @throws Exception
+	 */
+	public function decrement(string $column, int $value): bool|ActiveRecord
+	{
+		if (!$this->mathematics([$column => $value], '-', null)) {
+			return false;
+		}
+		$this->{$column} -= $value;
+		return $this->refresh();
+	}
+
+
+	/**
+	 * @param array $columns
+	 * @return ActiveRecord|false
+	 * @throws Exception
+	 */
+	public function increments(array $columns): bool|static
+	{
+		if (!$this->mathematics($columns, '+', null)) {
+			return false;
+		}
+		foreach ($columns as $key => $attribute) {
+			$this->$key += $attribute;
+		}
+		return $this;
+	}
+
+
+	/**
+	 * @param array $columns
+	 * @return ActiveRecord|false
+	 * @throws Exception
+	 */
+	public function decrements(array $columns): bool|static
+	{
+		if (!$this->mathematics($columns, '-', null)) {
+			return false;
+		}
+		foreach ($columns as $key => $attribute) {
+			$this->$key -= $attribute;
+		}
+		return $this;
+	}
+
+	/**
+	 * @param array $condition
+	 * @param array $attributes
+	 * @return bool|ActiveRecord
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
+	 * @throws Exception
+	 */
+	public static function findOrCreate(array $condition, array $attributes = []): bool|static
+	{
+		$logger = Kiri::app()->getLogger();
+
+		/** @var static $select */
+		$select = static::find()->where($condition)->first();
+		if (!empty($select)) {
+			return $select;
+		}
+		if (empty($attributes)) {
+			return $logger->addError(FIND_OR_CREATE_MESSAGE, 'mysql');
+		}
+		$select = duplicate(static::class);
+		$select->attributes = $attributes;
+		if (!$select->save()) {
+			return $logger->addError($select->getLastError(), 'mysql');
+		}
+		return $select;
+	}
+
+
+	/**
+	 * @param array $condition
+	 * @param array $attributes
+	 * @return bool|static
+	 * @throws Exception
+	 */
+	public static function createOrUpdate(array $condition, array $attributes = []): bool|static
+	{
+		$logger = Kiri::app()->getLogger();
+		if (empty($attributes)) {
+			return $logger->addError(FIND_OR_CREATE_MESSAGE, 'mysql');
+		}
+		/** @var static $select */
+		$select = static::find()->where($condition)->first();
+		if (empty($select)) {
+			$select = duplicate(static::class);
+		}
+		$select->attributes = $attributes;
+		if (!$select->save()) {
+			return $logger->addError($select->getLastError(), 'mysql');
+		}
+		return $select;
+	}
+
+
+	/**
+	 * @param $action
+	 * @param $columns
+	 * @param null|array $condition
+	 * @return array|bool|int|string|null
+	 * @throws Exception
+	 */
+	private function mathematics($columns, $action, ?array $condition): int|bool|array|string|null
+	{
+		if (empty($condition)) {
+			$condition = [$this->getPrimary() => $this->getPrimaryValue()];
+		}
+
+		$activeQuery = static::find()->where($condition);
+		$create = SqlBuilder::builder($activeQuery)->mathematics($columns, $action);
+		if (is_bool($create)) {
+			return false;
+		}
+		return static::getDb()->createCommand($create[0], $create[1])->exec();
+	}
+
+
+	/**
+	 * @param array $fields
+	 * @return ActiveRecord|bool
+	 * @throws Exception
+	 */
+	public function update(array $fields): static|bool
+	{
+		return $this->save($fields);
+	}
+
+
+	/**
+	 * @param array $data
+	 * @return bool
+	 * @throws Exception
+	 */
+	public static function inserts(array $data): bool
+	{
+		/** @var static $class */
+		$class = Kiri::createObject(['class' => static::class]);
+		if (empty($data)) {
+			return $class->addError('Insert data empty.', 'mysql');
+		}
+		return $class::find()->batchInsert($data);
+	}
+
+	/**
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function delete(): bool
+	{
+		$conditions = $this->_oldAttributes;
+		if (empty($conditions)) {
+			return $this->addError("Delete condition do not empty.", 'mysql');
+		}
+		$primary = $this->getPrimary();
+
+		if (!empty($primary)) {
+			$conditions = [$primary => $this->getAttribute($primary)];
+		}
+		return static::deleteByCondition($conditions);
+	}
+
+
+	/**
+	 * @param mixed $condition
+	 * @param array $attributes
+	 *
+	 * @return bool
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public static function updateAll(mixed $condition, array $attributes = []): bool
+	{
+		$condition = static::find()->where($condition);
+		return $condition->batchUpdate($attributes);
+	}
+
+	/**
+	 * @param       $condition
+	 * @param array $attributes
+	 *
+	 * @return array|Collection
+	 * @throws Exception
+	 */
+	public static function findAll($condition, array $attributes = []): array|Collection
+	{
+		$query = static::find()->where($condition);
+		if (!empty($attributes)) {
+			$query->bindParams($attributes);
+		}
+		return $query->all();
+	}
+
+	/**
+	 * @param $method
+	 * @return mixed
+	 * @throws Exception
+	 */
+	private function resolveObject($method): mixed
+	{
+		$resolve = $this->{$this->getRelate($method)}();
+		if ($resolve instanceof HasBase) {
+			$resolve = $resolve->get();
+		}
+		if ($resolve instanceof Collection) {
+			return $resolve->toArray();
+		} else if ($resolve instanceof ActiveRecord) {
+			return $resolve->toArray();
+		} else if (is_object($resolve)) {
+			return get_object_vars($resolve);
+		} else {
+			return $resolve;
+		}
+	}
+
+
+	/**
+	 * @return array
+	 * @throws Exception
+	 */
+	public function toArray(): array
+	{
+		$data = $this->_attributes;
+
+		$lists = Kiri::getAnnotation()->getGets(static::class);
+		foreach ($lists as $key => $item) {
+			$data[$key] = $this->{$item}($data[$key] ?? null);
+		}
+		return array_merge($data, $this->runRelate());
+	}
+
+	/**
+	 * @return array
+	 * @throws Exception
+	 */
+	private function runRelate(): array
+	{
+		$relates = [];
+		if (empty($with = $this->getWith())) {
+			return $relates;
+		}
+		foreach ($with as $val) {
+			$relates[$val] = $this->resolveObject($val);
+		}
+		return $relates;
+	}
+
+
+	/**
+	 * @param string $modelName
+	 * @param $foreignKey
+	 * @param $localKey
+	 * @return HasOne|ActiveQuery
+	 * @throws Exception
+	 */
+	public function hasOne(string $modelName, $foreignKey, $localKey): HasOne|ActiveQuery
+	{
+		if (($value = $this->getAttribute($localKey)) === null) {
+			throw new Exception("Need join table primary key.");
+		}
+
+		$relation = $this->getRelation();
+
+		return new HasOne($modelName, $foreignKey, $value, $relation);
+	}
+
+
+	/**
+	 * @param $modelName
+	 * @param $foreignKey
+	 * @param $localKey
+	 * @return ActiveQuery|HasCount
+	 * @throws Exception
+	 */
+	public function hasCount($modelName, $foreignKey, $localKey): ActiveQuery|HasCount
+	{
+		if (($value = $this->getAttribute($localKey)) === null) {
+			throw new Exception("Need join table primary key.");
+		}
+
+		$relation = $this->getRelation();
+
+		return new HasCount($modelName, $foreignKey, $value, $relation);
+	}
+
+
+	/**
+	 * @param $modelName
+	 * @param $foreignKey
+	 * @param $localKey
+	 * @return ActiveQuery|HasMany
+	 * @throws Exception
+	 */
+	public function hasMany($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
+	{
+		if (($value = $this->getAttribute($localKey)) === null) {
+			throw new Exception("Need join table primary key.");
+		}
+
+		$relation = $this->getRelation();
+
+		return new HasMany($modelName, $foreignKey, $value, $relation);
+	}
+
+	/**
+	 * @param $modelName
+	 * @param $foreignKey
+	 * @param $localKey
+	 * @return ActiveQuery|HasMany
+	 * @throws Exception
+	 */
+	public function hasIn($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
+	{
+		if (($value = $this->getAttribute($localKey)) === null) {
+			throw new Exception("Need join table primary key.");
+		}
+
+		$relation = $this->getRelation();
+
+		return new HasMany($modelName, $foreignKey, $value, $relation);
+	}
+
+	/**
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function afterDelete(): bool
+	{
+		if (!$this->hasPrimary()) {
+			return TRUE;
+		}
+		$value = $this->getPrimaryValue();
+		if (empty($value)) {
+			return TRUE;
+		}
+		return TRUE;
+	}
+
+	/**
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function beforeDelete(): bool
+	{
+		if (!$this->hasPrimary()) {
+			return TRUE;
+		}
+		$value = $this->getPrimaryValue();
+		if (empty($value)) {
+			return TRUE;
+		}
+		return TRUE;
+	}
+}

src/Base/AbstractCollection.php

@@ -0,0 +1,161 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/9 0009
+ * Time: 9:44
+ */
+declare(strict_types=1);
+
+namespace Database\Base;
+
+
+use ArrayIterator;
+use Database\ActiveQuery;
+use Database\ActiveRecord;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+use Kiri\Abstracts\Component;
+use Kiri\Kiri;
+use Traversable;
+
+/**
+ * Class AbstractCollection
+ * @package Database\Base
+ */
+abstract class AbstractCollection extends Component implements \IteratorAggregate, \ArrayAccess
+{
+
+    /**
+     * @var ActiveRecord[]
+     */
+    protected array $_item = [];
+
+    protected ActiveRecord|string|null $model;
+
+    protected ActiveQuery $query;
+
+
+    public function clean()
+    {
+        unset($this->query, $this->model, $this->_item);
+    }
+
+
+    /**
+     * Collection constructor.
+     *
+     * @param $query
+     * @param array $array
+     * @param string|ActiveRecord|null $model
+     * @throws Exception
+     */
+    public function __construct($query, array $array = [], string|ActiveRecord $model = null)
+    {
+        $this->_item = $array;
+        $this->query = $query;
+        $this->model = duplicate($model);
+
+        parent::__construct([]);
+    }
+
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getLength(): int
+    {
+        return count($this->_item);
+    }
+
+
+    /**
+     * @param $item
+     */
+    public function setItems($item)
+    {
+        $this->_item = $item;
+    }
+
+
+    /**
+     * @param $model
+     */
+    public function setModel($model)
+    {
+        $this->model = $model;
+    }
+
+    /**
+     * @param $item
+     */
+    public function addItem($item)
+    {
+        array_push($this->_item, $item);
+    }
+
+    /**
+     * @return Traversable|CollectionIterator|ArrayIterator
+     * @throws Exception
+     */
+    public function getIterator(): Traversable|CollectionIterator|ArrayIterator
+    {
+        return new CollectionIterator($this->model, $this->query, $this->_item);
+    }
+
+
+    /**
+     * @return mixed
+     * @throws Exception
+     */
+    public function getModel(): ActiveRecord
+    {
+        return $this->model;
+    }
+
+
+    /**
+     * @param mixed $offset
+     * @return bool
+     */
+    public function offsetExists(mixed $offset): bool
+    {
+        return !empty($this->_item) && isset($this->_item[$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return ActiveRecord|null
+     * @throws Exception
+     */
+    public function offsetGet(mixed $offset): ?ActiveRecord
+    {
+        if (!$this->offsetExists($offset)) {
+            return NULL;
+        }
+        if (!($this->_item[$offset] instanceof ActiveRecord)) {
+            return $this->model->setAttributes($this->_item[$offset]);
+        }
+        return $this->_item[$offset];
+    }
+
+    /**
+     * @param mixed $offset
+     * @param mixed $value
+     */
+    public function offsetSet(mixed $offset, mixed $value)
+    {
+        $this->_item[$offset] = $value;
+    }
+
+
+    /**
+     * @param mixed $offset
+     */
+    public function offsetUnset(mixed $offset)
+    {
+        if ($this->offsetExists($offset)) {
+            unset($this->_item[$offset]);
+        }
+    }
+}

src/Base/CollectionIterator.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Database\Base;
+
+
+use Database\ActiveQuery;
+use Database\ActiveRecord;
+use Exception;
+
+
+/**
+ * Class CollectionIterator
+ * @package Database\Base
+ */
+class CollectionIterator extends \ArrayIterator
+{
+
+	private ActiveRecord|string $model;
+
+
+	/** @var ActiveQuery */
+	private ActiveQuery $query;
+
+
+	private ?ActiveRecord $_clone = null;
+
+
+	public function clean()
+	{
+		unset($this->query);
+	}
+
+
+	/**
+	 * CollectionIterator constructor.
+	 * @param $model
+	 * @param $query
+	 * @param array $array
+	 * @param int $flags
+	 * @throws Exception
+	 */
+	public function __construct($model, $query, array $array = [], int $flags = 0)
+	{
+		$this->model = $model;
+		$this->query = $query;
+		parent::__construct($array, $flags);
+	}
+
+
+	/**
+	 * @param $current
+	 * @return ActiveRecord
+	 * @throws Exception
+	 */
+	protected function newModel($current): ActiveRecord
+	{
+		return $this->model->setAttributes($current);
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function current(): ActiveRecord
+	{
+		if (is_array($current = parent::current())) {
+			$current = $this->newModel($current);
+		}
+		return $this->query->getWith($current);
+	}
+
+
+}

src/Base/ConditionClassMap.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+namespace Database\Base;
+
+
+use Database\Condition\BetweenCondition;
+use Database\Condition\InCondition;
+use Database\Condition\LikeCondition;
+use Database\Condition\LLikeCondition;
+use Database\Condition\MathematicsCondition;
+use Database\Condition\NotBetweenCondition;
+use Database\Condition\NotInCondition;
+use Database\Condition\NotLikeCondition;
+use Database\Condition\RLikeCondition;
+
+/**
+ * Class ConditionClassMap
+ * @package Database\Base
+ */
+class ConditionClassMap
+{
+
+	public static array $conditionMap = [
+		'IN'          => [
+			'class' => InCondition::class
+		],
+		'NOT IN'      => [
+			'class' => NotInCondition::class
+		],
+		'LIKE'        => [
+			'class' => LikeCondition::class
+		],
+		'NOT LIKE'    => [
+			'class' => NotLikeCondition::class
+		],
+		'LLike'       => [
+			'class' => LLikeCondition::class
+		],
+		'RLike'       => [
+			'class' => RLikeCondition::class
+		],
+		'EQ'          => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'EQ'
+		],
+		'NEQ'         => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'NEQ'
+		],
+		'GT'          => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'GT'
+		],
+		'EGT'         => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'EGT'
+		],
+		'LT'          => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'LT'
+		],
+		'ELT'         => [
+			'class' => MathematicsCondition::class,
+			'type'  => 'ELT'
+		],
+		'BETWEEN'     => BetweenCondition::class,
+		'NOT BETWEEN' => NotBetweenCondition::class,
+	];
+
+}

src/Collection.php

@@ -0,0 +1,242 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/4 0004
+ * Time: 13:38
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+use Database\Base\AbstractCollection;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+
+/**
+ * Class Collection
+ * @package Database
+ * @property-read $length
+ */
+class Collection extends AbstractCollection
+{
+
+	/**
+	 * @return array
+	 */
+	public function getItems(): array
+	{
+		// TODO: Change the autogenerated stub
+		return $this->_item;
+	}
+
+	/**
+	 * @param $field
+	 *
+	 * @return array|null
+	 * @throws Exception
+	 */
+	public function values($field): ?array
+	{
+		if (empty($field) || !is_string($field)) {
+			return NULL;
+		}
+		$_tmp = [];
+		$data = $this->toArray();
+		foreach ($data as $val) {
+			/** @var ActiveRecord $val */
+			$_tmp[] = $val[$field];
+		}
+		return $_tmp;
+	}
+
+	/**
+	 * @param string $field
+	 * @return array|null
+	 */
+	public function keyBy(string $field): ?array
+	{
+		$array = $this->toArray();
+		$column = array_flip(array_column($array, $field));
+		foreach ($column as $key => $value) {
+			$column[$key] = $array[$value];
+		}
+
+		return $column;
+	}
+
+	/**
+	 * @return $this
+	 */
+	public function orderRand(): static
+	{
+		shuffle($this->_item);
+		return $this;
+	}
+
+	/**
+	 * @param int $start
+	 * @param int $length
+	 *
+	 * @return array
+	 */
+	#[Pure] public function slice(int $start = 0, int $length = 20): array
+	{
+		if (empty($this->_item) || !is_array($this->_item)) {
+			return [];
+		}
+		if (count($this->_item) < $length) {
+			return $this->_item;
+		} else {
+			return array_slice($this->_item, $start, $length);
+		}
+	}
+
+	/**
+	 * @param        $field
+	 * @param string $setKey
+	 *
+	 * @return array|null
+	 */
+	public function column(string $field, string $setKey = ''): ?array
+	{
+		$data = $this->toArray();
+		if (empty($data)) {
+			return [];
+		}
+		if (!empty($setKey) && is_string($setKey)) {
+			return array_column($data, $field, $setKey);
+		} else {
+			return array_column($data, $field);
+		}
+	}
+
+	/**
+	 * @param string $field
+	 *
+	 * @return float|int|null
+	 */
+	public function sum(string $field): float|int|null
+	{
+		$array = $this->column($field);
+		if (empty($array)) {
+			return NULL;
+		}
+		return array_sum($array);
+	}
+
+	/**
+	 * @return ActiveRecord|array
+	 */
+	#[Pure] public function current(): ActiveRecord|array
+	{
+		return current($this->_item);
+	}
+
+	/**
+	 * @return int
+	 */
+	#[Pure] public function size(): int
+	{
+		return (int)count($this->_item);
+	}
+
+	/**
+	 * @return array
+	 * @throws
+	 */
+	public function toArray(): array
+	{
+		$array = [];
+		foreach ($this as $value) {
+			if (!is_object($value)) {
+				continue;
+			}
+			$array[] = $value->toArray();
+		}
+		$this->_item = [];
+		return $array;
+	}
+
+	/**
+	 * @throws Exception
+	 * 批量删除
+	 */
+	public function delete(): bool
+	{
+		$model = $this->getModel();
+		if (!$model->hasPrimary()) return false;
+		$ids = [];
+		foreach ($this as $item) {
+			$id = $item->getPrimaryValue();
+			if (!empty($id)) {
+				$ids[] = $id;
+			}
+		}
+		return $model::find()->whereIn($model->getPrimary(), $ids)->delete();
+	}
+
+	/**
+	 * @param array $condition
+	 * @return Collection
+	 * @throws
+	 */
+	public function filter(array $condition): Collection|static
+	{
+		$_filters = [];
+		if (empty($condition)) {
+			return $this;
+		}
+		foreach ($this as $value) {
+			if (!$this->filterCheck($value, $condition)) {
+				continue;
+			}
+			$_filters[] = $value;
+		}
+		return new Collection($this->query, $_filters, $this->model);
+	}
+
+
+	/**
+	 * @param $value
+	 * @param $condition
+	 * @return bool
+	 * @throws Exception
+	 */
+	private function filterCheck($value, $condition): bool
+	{
+		$_value = $value;
+		if ($_value instanceof ActiveRecord) {
+			$_value = $_value->toArray();
+		}
+		$_tmp = array_intersect_key($_value, $condition);
+		if (count(array_diff_assoc($_tmp, $condition)) > 0) {
+			return false;
+		}
+		return true;
+	}
+
+
+	/**
+	 * @param $key
+	 * @param $value
+	 * @return mixed
+	 */
+	public function exists($key, $value): mixed
+	{
+		foreach ($this as $item) {
+			if ($item->$key === $value) {
+				return $item;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * @return bool
+	 */
+	#[Pure] public function isEmpty(): bool
+	{
+		return $this->size() < 1;
+	}
+}

src/Command.php

@@ -0,0 +1,318 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 15:23
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Exception;
+use PDO;
+use PDOStatement;
+use Kiri\Abstracts\Component;
+use Kiri\Core\Json;
+
+/**
+ * Class Command
+ * @package Database
+ */
+class Command extends Component
+{
+	const ROW_COUNT = 'ROW_COUNT';
+	const FETCH = 'FETCH';
+	const FETCH_ALL = 'FETCH_ALL';
+	const EXECUTE = 'EXECUTE';
+	const FETCH_COLUMN = 'FETCH_COLUMN';
+
+	const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
+
+	/** @var Connection */
+	public Connection $db;
+
+	/** @var ?string */
+	public ?string $sql = '';
+
+	/** @var array */
+	public array $params = [];
+
+	/** @var string */
+	private string $_modelName;
+
+	public string $dbname = '';
+
+	private ?PDOStatement $prepare = null;
+
+
+	/**
+	 * @return array|bool|int|string|PDOStatement|null
+	 * @throws Exception
+	 */
+	public function incrOrDecr(): array|bool|int|string|PDOStatement|null
+	{
+		return $this->execute(static::EXECUTE);
+	}
+
+	/**
+	 * @param bool $isInsert
+	 * @param mixed $hasAutoIncrement
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function save(bool $isInsert = TRUE, mixed $hasAutoIncrement = null): int|bool|array|string|null
+	{
+		return $this->execute(static::EXECUTE, $isInsert, $hasAutoIncrement);
+	}
+
+
+	/**
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function all(): int|bool|array|string|null
+	{
+		return $this->execute(static::FETCH_ALL);
+	}
+
+	/**
+	 * @return array|bool|int|string|null
+	 * @throws Exception
+	 */
+	public function one(): null|array|bool|int|string
+	{
+		return $this->execute(static::FETCH);
+	}
+
+	/**
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function fetchColumn(): int|bool|array|string|null
+	{
+		return $this->execute(static::FETCH_COLUMN);
+	}
+
+	/**
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function rowCount(): int|bool|array|string|null
+	{
+		return $this->execute(static::ROW_COUNT);
+	}
+
+	/**
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function flush(): int|bool|array|string|null
+	{
+		return $this->execute(static::EXECUTE);
+	}
+
+	/**
+	 * @param $type
+	 * @param null $isInsert
+	 * @param bool|null $hasAutoIncrement
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	private function execute($type, $isInsert = null, mixed $hasAutoIncrement = null): int|bool|array|string|null
+	{
+		try {
+			$time = microtime(true);
+			if ($type === static::EXECUTE) {
+				$result = $this->insert_or_change($isInsert, $hasAutoIncrement);
+			} else {
+				$result = $this->search($type);
+			}
+			if (microtime(true) - $time >= 0.02) {
+				$this->warning('Mysql:' . Json::encode([$this->sql, $this->params]) . (microtime(true) - $time));
+			}
+			$this->prepare?->closeCursor();
+		} catch (\Throwable $exception) {
+			$result = $this->addError($this->sql . '. error: ' . $exception->getMessage(), 'mysql');
+		} finally {
+			$this->db->release();
+			return $result;
+		}
+	}
+
+
+	/**
+	 * @param $type
+	 * @return mixed
+	 * @throws Exception
+	 */
+	private function search($type): mixed
+	{
+		if (($prepare = $this->prepare()) == false) {
+			return false;
+		}
+		if ($type === static::FETCH_COLUMN) {
+			$data = $prepare->fetchAll(PDO::FETCH_ASSOC);
+		} else if ($type === static::ROW_COUNT) {
+			$data = $prepare->rowCount();
+		} else if ($type === static::FETCH_ALL) {
+			$data = $prepare->fetchAll(PDO::FETCH_ASSOC);
+		} else {
+			$data = $prepare->fetch(PDO::FETCH_ASSOC);
+		}
+		$prepare->closeCursor();
+		return $data;
+	}
+
+
+	/**
+	 * @param $isInsert
+	 * @param $hasAutoIncrement
+	 * @return bool|string|int
+	 * @throws Exception
+	 */
+	private function insert_or_change($isInsert, $hasAutoIncrement): bool|string|int
+	{
+		if (($result = $this->getPdoStatement()) === false) {
+			return $result;
+		}
+		if ($isInsert === false || !$hasAutoIncrement) {
+			return true;
+		}
+		if ($result == 0 && $hasAutoIncrement->isAutoIncrement()) {
+			return $this->addError(static::DB_ERROR_MESSAGE, 'mysql');
+		}
+		return $result == 0 ? true : $result;
+	}
+
+
+	/**
+	 * 重新构建
+	 * @throws
+	 */
+	private function getPdoStatement(): bool|int
+	{
+		if (empty($this->sql)) {
+			return $this->addError('no sql.', 'mysql');
+		}
+		if (!(($connect = $this->db->getConnect($this->sql)) instanceof PDO)) {
+			return $this->addError('get client error.', 'mysql');
+		}
+		if (!(($prepare = $connect->prepare($this->sql)) instanceof PDOStatement)) {
+			return $this->addError($this->errorMessage($prepare), 'mysql');
+		}
+		$result = $this->checkResponse($prepare, $connect);
+		$prepare->closeCursor();
+		return $result;
+	}
+
+
+	/**
+	 * @param $prepare
+	 * @return string
+	 */
+	private function errorMessage($prepare): string
+	{
+		return $this->sql . ':' . ($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
+	}
+
+
+	/**
+	 * @return bool|\PDOStatement
+	 * @throws \Exception
+	 */
+	private function prepare(): bool|PDOStatement
+	{
+		if (!(($connect = $this->db->getConnect($this->sql)) instanceof PDO)) {
+			return $this->addError('get client error.', 'mysql');
+		}
+		if (!(($prepare = $connect->query($this->sql)) instanceof PDOStatement)) {
+			$error = $prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE;
+			return $this->addError($this->sql . ':' . $error, 'mysql');
+		}
+		return $prepare;
+	}
+
+
+	/**
+	 * @param $prepare
+	 * @param $connect
+	 * @return bool|int
+	 * @throws \Exception
+	 */
+	private function checkResponse($prepare, $connect): bool|int
+	{
+		$result = $prepare->execute($this->params);
+		if ($result === false) {
+			return $this->addError($connect->errorInfo()[2], 'mysql');
+		}
+		return (int)$connect->lastInsertId();
+	}
+
+
+	/**
+	 * @param $modelName
+	 * @return $this
+	 */
+	public function setModelName($modelName): static
+	{
+		$this->_modelName = $modelName;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getModelName(): string
+	{
+		return $this->_modelName;
+	}
+
+	/**
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function delete(): int|bool|array|string|null
+	{
+		return $this->execute(static::EXECUTE);
+	}
+
+	/**
+	 * @param null $scope
+	 * @param bool $insert
+	 * @return int|bool|array|string|null
+	 * @throws Exception
+	 */
+	public function exec($scope = null, bool $insert = false): int|bool|array|string|null
+	{
+		return $this->execute(static::EXECUTE, $insert, $scope);
+	}
+
+	/**
+	 * @param array $data
+	 * @return $this
+	 */
+	public function bindValues(array $data = []): static
+	{
+		if (!is_array($this->params)) {
+			$this->params = [];
+		}
+		if (!empty($data)) {
+			$this->params = array_merge($this->params, $data);
+		}
+		return $this;
+	}
+
+	/**
+	 * @param $sql
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function setSql($sql): static
+	{
+		$this->sql = $sql;
+		return $this;
+	}
+
+}

src/Condition/BetweenCondition.php

@@ -0,0 +1,23 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+
+/**
+ * Class BetweenCondition
+ * @package Database\Condition
+ */
+class BetweenCondition extends Condition
+{
+
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		return $this->column . ' BETWEEN ' . (int)$this->value[0] . ' AND ' . (int)$this->value[1];
+	}
+
+}

src/Condition/ChildCondition.php

@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+
+/**
+ * Class ChildCondition
+ * @package Database\Condition
+ */
+class ChildCondition extends Condition
+{
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		return $this->column . ' ' . $this->opera . ' (' . $this->value . ')';
+	}
+
+}

src/Condition/Condition.php

@@ -0,0 +1,83 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+
+use JetBrains\PhpStorm\Pure;
+use Kiri\Abstracts\BaseObject;
+use Kiri\Core\Str;
+
+/**
+ * Class Condition
+ * @package Database\Condition
+ */
+abstract class Condition extends BaseObject
+{
+
+	protected string $column = '';
+	protected string $opera = '=';
+
+	/** @var array|mixed */
+	protected $value;
+
+	const INT_TYPE = ['bit', 'bool', 'tinyint', 'smallint', 'mediumint', 'int', 'bigint', 'float', 'double', 'decimal', 'timestamp'];
+
+	protected array $attributes = [];
+
+	abstract public function builder();
+
+	/**
+	 * @param string $column
+	 */
+	public function setColumn(string $column): void
+	{
+		$this->column = $column;
+	}
+
+	/**
+	 * @param string $opera
+	 */
+	public function setOpera(string $opera): void
+	{
+		$this->opera = $opera;
+	}
+
+	/**
+	 * @param $params
+	 */
+	public function setValue($params): void
+	{
+		if (is_array($params)) {
+			$values = [];
+			foreach ($params as $item => $value) {
+				$values[$item] = is_numeric($value) ? $value : '\'' . $value . '\'';
+			}
+			$this->value = $values;
+		} else {
+			$this->value = $this->checkIsSqlString($params);
+		}
+	}
+
+
+	/**
+	 * @param $params
+	 * @return int|string
+	 */
+	#[Pure] private function checkIsSqlString($params): int|string
+	{
+		if (is_numeric($params)) {
+			return $params;
+		}
+
+		$check = ltrim($params, '(');
+		$check = strtolower(substr($check, 0, 6));
+		if (in_array($check, ['update', 'select', 'insert', 'delete'])) {
+			return $params;
+		} else {
+			return sprintf('\'%s\'', $params);
+		}
+	}
+
+
+}

src/Condition/DefaultCondition.php

@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+
+use JetBrains\PhpStorm\Pure;
+
+/**
+ * Class DefaultCondition
+ * @package Database\Condition
+ */
+class DefaultCondition extends Condition
+{
+
+	/**
+	 * @return string
+	 */
+	#[Pure] public function builder(): string
+	{
+		return sprintf('%s %s %s', $this->column, $this->opera, addslashes($this->value));
+	}
+
+}

src/Condition/HashCondition.php

@@ -0,0 +1,31 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+/**
+ * Class HashCondition
+ * @package Yoc\db\condition
+ */
+class HashCondition extends Condition
+{
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		$array = [];
+		if (empty($this->value)) {
+			return '';
+		}
+		foreach ($this->value as $key => $value) {
+			if ($value === null) {
+				continue;
+			}
+			$array[] = sprintf("%s = '%s'", $key, addslashes($value));
+		}
+		return implode(' AND ', $array);
+	}
+
+}

src/Condition/InCondition.php

@@ -0,0 +1,31 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use Database\ActiveQuery;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+
+/**
+ * Class InCondition
+ * @package Database\Condition
+ */
+class InCondition extends Condition
+{
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	#[Pure] public function builder(): string
+	{
+		if (is_array($this->value)) {
+			return sprintf('%s IN (%s)', $this->column, implode(',', $this->value));
+		} else {
+			return sprintf('%s IN (%s)', $this->column, $this->value);
+		}
+	}
+
+}

src/Condition/JsonCondition.php

@@ -0,0 +1,20 @@
+<?php
+
+
+namespace Database\Condition;
+
+
+/**
+ * Class JsonCondition
+ * @package Database\Condition
+ */
+class JsonCondition extends Condition
+{
+
+
+	public function builder()
+	{
+		// TODO: Implement builder() method.
+	}
+
+}

src/Condition/LLikeCondition.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use Kiri\Core\Str;
+
+/**
+ * Class LLikeCondition
+ * @package Database\Condition
+ */
+class LLikeCondition extends Condition
+{
+
+	public string $pos = '';
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		if (!is_string($this->value)) {
+			$this->value = array_shift($this->value);
+		}
+		return $this->column . ' LIKE \'%' . addslashes($this->value) . '\'';
+	}
+
+}

src/Condition/LikeCondition.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use Kiri\Core\Str;
+
+/**
+ * Class LikeCondition
+ * @package Database\Condition
+ */
+class LikeCondition extends Condition
+{
+
+	public string $pos = '';
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		if (!is_string($this->value)) {
+			$this->value = array_shift($this->value);
+		}
+		return $this->column . ' LIKE \'%' . addslashes($this->value) . '%\'';
+	}
+
+}

src/Condition/MathematicsCondition.php

@@ -0,0 +1,78 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+/**
+ * Class MathematicsCondition
+ * @package Database\Condition
+ */
+class MathematicsCondition extends Condition
+{
+
+	public string $type = '';
+
+	/**
+	 * @return mixed
+	 */
+	public function builder(): mixed
+	{
+		return $this->{strtolower($this->type)}((float)$this->value);
+	}
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function eq($value): string
+	{
+		return $this->column . ' = ' . $value;
+	}
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function neq($value): string
+	{
+		return $this->column . ' <> ' . $value;
+	}
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function gt($value): string
+	{
+		return $this->column . ' > ' . $value;
+	}
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function egt($value): string
+	{
+		return $this->column . ' >= ' . $value;
+	}
+
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function lt($value): string
+	{
+		return $this->column . ' < ' . $value;
+	}
+
+	/**
+	 * @param $value
+	 * @return string
+	 */
+	public function elt($value): string
+	{
+		return $this->column . ' <= ' . $value;
+	}
+
+}

src/Condition/NotBetweenCondition.php

@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+/**
+ * Class NotBetweenCondition
+ * @package Database\Condition
+ */
+class NotBetweenCondition extends Condition
+{
+
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		return $this->column . ' NOT BETWEEN ' . (int)$this->value[0] . ' AND ' . (int)$this->value[1];
+	}
+
+}

src/Condition/NotInCondition.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use JetBrains\PhpStorm\Pure;
+
+/**
+ * Class NotInCondition
+ * @package Database\Condition
+ */
+class NotInCondition extends Condition
+{
+
+
+	/**
+	 * @return string|null
+	 */
+	#[Pure] public function builder(): ?string
+	{
+		if (!is_array($this->value)) {
+			return null;
+		}
+		$value = '\'' . implode('\',\'', $this->value) . '\'';
+		return '`' . $this->column . '` not in(' . $value . ')';
+	}
+
+}

src/Condition/NotLikeCondition.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use Kiri\Core\Str;
+
+/**
+ * Class NotLikeCondition
+ * @package Database\Condition
+ */
+class NotLikeCondition extends Condition
+{
+
+	public string $pos = '';
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		if (!is_string($this->value)) {
+			$this->value = array_shift($this->value);
+		}
+		return $this->column . ' NOT LIKE \'%' . addslashes($this->value) . '%\'';
+	}
+
+}

src/Condition/OrCondition.php

@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+
+use JetBrains\PhpStorm\Pure;
+
+/**
+ * Class OrCondition
+ * @package Database\Condition
+ */
+class OrCondition extends Condition
+{
+
+	public array $oldParams = [];
+
+
+	/**
+	 * @return string
+	 */
+	#[Pure] public function builder(): string
+	{
+		return sprintf('(%s) OR %s', implode(' AND ', $this->oldParams), addslashes($this->value));
+	}
+
+}

src/Condition/RLikeCondition.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Condition;
+
+use Kiri\Core\Str;
+
+/**
+ * Class RLikeCondition
+ * @package Database\Condition
+ */
+class RLikeCondition extends Condition
+{
+
+	public string $pos = '';
+
+	/**
+	 * @return string
+	 */
+	public function builder(): string
+	{
+		if (!is_string($this->value)) {
+			$this->value = array_shift($this->value);
+		}
+		return sprintf('%s LIKE \'%s\'', $this->column, addslashes($this->value));
+	}
+
+}

src/Connection.php

@@ -0,0 +1,341 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 14:09
+ */
+declare(strict_types=1);
+
+
+namespace Database;
+
+
+use Annotation\Inject;
+use Database\Affair\BeginTransaction;
+use Database\Affair\Commit;
+use Database\Affair\Rollback;
+use Database\Mysql\Schema;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+use PDO;
+use ReflectionException;
+use Server\Events\OnWorkerExit;
+use Server\Events\OnWorkerStop;
+use Kiri\Abstracts\Component;
+use Kiri\Abstracts\Config;
+use Kiri\Event;
+use Kiri\Events\EventProvider;
+use Kiri\Exception\NotFindClassException;
+use Kiri\Kiri;
+
+/**
+ * Class Connection
+ * @package Database
+ */
+class Connection extends Component
+{
+
+	public string $id = 'db';
+	public string $cds = '';
+	public string $password = '';
+	public string $username = '';
+	public string $charset = 'utf-8';
+	public string $tablePrefix = '';
+
+	public string $database = '';
+
+	public int $timeout = 1900;
+
+	/**
+	 * @var bool
+	 * enable database cache
+	 */
+	public bool $enableCache = false;
+
+
+	/**
+	 * @var string
+	 */
+	public string $cacheDriver = 'redis';
+
+	/**
+	 * @var array
+	 */
+	public array $slaveConfig = [];
+
+
+	/**
+	 * @var Schema
+	 */
+	#[Inject(Schema::class)]
+	public Schema $_schema;
+
+
+	/**
+	 * @var EventProvider
+	 */
+	#[Inject(EventProvider::class)]
+	public EventProvider $eventProvider;
+
+
+	/**
+	 * execute by __construct
+	 */
+	public function init()
+	{
+		$this->eventProvider->on(OnWorkerStop::class, [$this, 'clear_connection'], 0);
+		$this->eventProvider->on(OnWorkerExit::class, [$this, 'clear_connection'], 0);
+		$this->eventProvider->on(BeginTransaction::class, [$this, 'beginTransaction'], 0);
+		$this->eventProvider->on(Rollback::class, [$this, 'rollback'], 0);
+		$this->eventProvider->on(Commit::class, [$this, 'commit'], 0);
+
+		if (Db::transactionsActive()) {
+		    $this->beginTransaction();
+        }
+
+		$this->_schema->db = $this;
+	}
+
+
+	/**
+	 * @param null $sql
+	 * @return PDO
+	 * @throws Exception
+	 */
+	public function getConnect($sql = NULL): PDO
+	{
+		return $this->getPdo($sql);
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function fill()
+	{
+		$connections = $this->connections();
+		$pool = Config::get('databases.pool.max', 10);
+
+		$connections->initConnections('Mysql:' . $this->cds, true, $pool);
+		if (!empty($this->slaveConfig) && $this->cds != $this->slaveConfig['cds']) {
+			$connections->initConnections('Mysql:' . $this->slaveConfig['cds'], false, $pool);
+		}
+	}
+
+
+	/**
+	 * @param $sql
+	 * @return PDO
+	 * @throws Exception
+	 */
+	private function getPdo($sql): PDO
+	{
+		if ($this->isWrite($sql)) {
+			return $this->masterInstance();
+		} else {
+			return $this->slaveInstance();
+		}
+	}
+
+	/**
+	 * @return mixed
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
+	 */
+	public function getSchema(): Schema
+	{
+		if ($this->_schema === null) {
+			$this->_schema = Kiri::createObject([
+				'class' => Schema::class,
+				'db'    => $this
+			]);
+		}
+		return $this->_schema;
+	}
+
+	/**
+	 * @param $sql
+	 * @return bool
+	 */
+	#[Pure] public function isWrite($sql): bool
+	{
+		if (empty($sql)) return false;
+		if (str_starts_with(strtolower($sql), 'select')) {
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function getCacheDriver(): mixed
+	{
+		if (!$this->enableCache) {
+			return null;
+		}
+		return Kiri::app()->get($this->cacheDriver);
+	}
+
+	/**
+	 * @return PDO
+	 * @throws Exception
+	 */
+	public function masterInstance(): PDO
+	{
+		return $this->connections()->get([
+			'cds'      => $this->cds,
+			'username' => $this->username,
+			'password' => $this->password,
+			'database' => $this->database
+		], true);
+	}
+
+	/**
+	 * @return PDO
+	 * @throws Exception
+	 */
+	public function slaveInstance(): PDO
+	{
+		if (empty($this->slaveConfig) || Db::transactionsActive()) {
+			return $this->masterInstance();
+		}
+		if ($this->slaveConfig['cds'] == $this->cds) {
+			return $this->masterInstance();
+		}
+		return $this->connections()->get($this->slaveConfig, false);
+	}
+
+
+	/**
+	 * @return \Kiri\Pool\Connection
+	 * @throws Exception
+	 */
+	private function connections(): \Kiri\Pool\Connection
+	{
+		return Kiri::getDi()->get(\Kiri\Pool\Connection::class);
+	}
+
+
+	/**
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function beginTransaction(): static
+	{
+		$this->connections()->beginTransaction($this->cds);
+		return $this;
+	}
+
+	/**
+	 * @return $this|bool
+	 * @throws Exception
+	 */
+	public function inTransaction(): bool|static
+	{
+		return $this->connections()->inTransaction($this->cds);
+	}
+
+	/**
+	 * @throws Exception
+	 * 事务回滚
+	 */
+	public function rollback()
+	{
+		$this->connections()->rollback($this->cds);
+		$this->release();
+	}
+
+	/**
+	 * @throws Exception
+	 * 事务提交
+	 */
+	public function commit()
+	{
+		$this->connections()->commit($this->cds);
+		$this->release();
+	}
+
+	/**
+	 * @param $sql
+	 * @return PDO
+	 * @throws Exception
+	 */
+	public function refresh($sql): PDO
+	{
+		if ($this->isWrite($sql)) {
+			$instance = $this->masterInstance();
+		} else {
+			$instance = $this->slaveInstance();
+		}
+		return $instance;
+	}
+
+	/**
+	 * @param null $sql
+	 * @param array $attributes
+	 * @return Command
+	 * @throws Exception
+	 */
+	public function createCommand($sql = null, array $attributes = []): Command
+	{
+		$command = new Command(['db' => $this, 'sql' => $sql]);
+		return $command->bindValues($attributes);
+	}
+
+
+	/**
+	 *
+	 * 回收链接
+	 * @throws
+	 */
+	public function release()
+	{
+		if (!Kiri::isWorker() && !Kiri::isProcess()) {
+			$this->clear_connection();
+			return;
+		}
+		$connections = $this->connections();
+		$connections->release($this->cds, true);
+		$connections->release($this->slaveConfig['cds'], false);
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function recovery()
+	{
+		$connections = $this->connections();
+
+		$connections->release($this->cds, true);
+		$connections->release($this->slaveConfig['cds'], false);
+	}
+
+	/**
+	 *
+	 * 回收链接
+	 * @throws
+	 */
+	public function clear_connection()
+	{
+		$connections = $this->connections();
+
+		$connections->disconnect($this->cds, true);
+		$connections->disconnect($this->slaveConfig['cds'], false);
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function disconnect()
+	{
+		$connections = $this->connections();
+		$connections->disconnect($this->cds, true);
+		$connections->disconnect($this->slaveConfig['cds'], false);
+	}
+
+}

src/DatabasesProviders.php

@@ -0,0 +1,116 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Annotation\Inject;
+use Exception;
+use Server\Events\OnWorkerStart;
+use Kiri\Abstracts\Config;
+use Kiri\Abstracts\Providers;
+use Kiri\Application;
+use Kiri\Events\EventProvider;
+use Kiri\Exception\ConfigException;
+use Kiri\Kiri;
+
+/**
+ * Class DatabasesProviders
+ * @package Database
+ */
+class DatabasesProviders extends Providers
+{
+
+	private array $_pooLength = ['min' => 0, 'max' => 1];
+
+
+	/**
+	 * @var EventProvider
+	 */
+	#[Inject(EventProvider::class)]
+	public EventProvider $eventProvider;
+
+
+	/**
+	 * @param Application $application
+	 * @throws Exception
+	 */
+	public function onImport(Application $application)
+	{
+		$application->set('db', $this);
+
+		$this->_pooLength = Config::get('databases.pool', ['min' => 0, 'max' => 1]);
+
+		$this->eventProvider->on(OnWorkerStart::class, [$this, 'createPool']);
+	}
+
+
+	/**
+	 * @param $name
+	 * @return Connection
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function get($name): Connection
+	{
+		$application = Kiri::app();
+		if (!$application->has('databases.' . $name)) {
+			$application->set('databases.' . $name, $this->_settings($this->getConfig($name)));
+		}
+		return $application->get('databases.' . $name);
+	}
+
+
+	/**
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function createPool(OnWorkerStart $onWorkerStart)
+	{
+		$databases = Config::get('databases.connections', []);
+		if (empty($databases)) {
+			return;
+		}
+		$application = Kiri::app();
+		foreach ($databases as $name => $database) {
+			/** @var Connection $connection */
+			$application->set('databases.' . $name, $this->_settings($database));
+			$application->get('databases.' . $name)->fill();
+		}
+	}
+
+
+	/**
+	 * @param $database
+	 * @return array
+	 */
+	private function _settings($database): array
+	{
+		return [
+			'class'       => Connection::class,
+			'id'          => $database['id'],
+			'cds'         => $database['cds'],
+			'username'    => $database['username'],
+			'password'    => $database['password'],
+			'tablePrefix' => $database['tablePrefix'],
+			'database'    => $database['database'],
+			'maxNumber'   => $this->_pooLength['max'],
+			'minNumber'   => $this->_pooLength['min'],
+			'charset'     => $database['charset'] ?? 'utf8mb4',
+			'slaveConfig' => $database['slaveConfig']
+		];
+	}
+
+
+	/**
+	 * @param $name
+	 * @return mixed
+	 * @throws ConfigException
+	 */
+	public function getConfig($name): mixed
+	{
+		return Config::get('databases.connections.' . $name, null, true);
+	}
+
+
+}

src/Db.php

@@ -0,0 +1,365 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/4 0004
+ * Time: 15:40
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+use Database\Affair\BeginTransaction;
+use Database\Affair\Commit;
+use Database\Affair\Rollback;
+use Database\Traits\QueryTrait;
+use Exception;
+use Kiri\Abstracts\Config;
+use Kiri\Events\EventDispatch;
+use Kiri\Exception\ConfigException;
+
+/**
+ * Class Db
+ * @package Database
+ */
+class Db implements ISqlBuilder
+{
+	use QueryTrait;
+
+
+	private static bool $_inTransaction = false;
+
+	/**
+	 * @return bool
+	 */
+	public static function transactionsActive(): bool
+	{
+		return static::$_inTransaction === true;
+	}
+
+	/**
+	 * @throws Exception
+	 */
+	public static function beginTransaction()
+	{
+		if (!static::transactionsActive()) {
+			di(EventDispatch::class)->dispatch(new BeginTransaction());
+		}
+		static::$_inTransaction = true;
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public static function commit()
+	{
+		if (static::transactionsActive()) {
+			di(EventDispatch::class)->dispatch(new Commit());
+		}
+		static::$_inTransaction = false;
+	}
+
+
+	/**
+	 * @throws Exception
+	 */
+	public static function rollback()
+	{
+		if (static::transactionsActive()) {
+			di(EventDispatch::class)->dispatch(new Rollback());
+		}
+		static::$_inTransaction = false;
+	}
+
+
+	/**
+	 * @param $table
+	 *
+	 * @return static
+	 */
+	public static function table($table): Db|static
+	{
+		$connection = new Db();
+		$connection->from($table);
+		return $connection;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param string $alias
+	 * @return string
+	 */
+	public static function any_value(string $column, string $alias = ''): string
+	{
+		if (empty($alias)) {
+			$alias = $column . '_any_value';
+		}
+		return 'ANY_VALUE(' . $column . ') as ' . $alias;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @return string
+	 */
+	public static function increment(string $column): string
+	{
+		return '+ ' . $column;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @return string
+	 */
+	public static function decrement(string $column): string
+	{
+		return '- ' . $column;
+	}
+
+
+	/**
+	 * @param Connection|null $connection
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function get(Connection $connection = NULL): mixed
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand(SqlBuilder::builder($this)->one())
+			->all();
+	}
+
+	/**
+	 * @param $column
+	 * @return string
+	 */
+	public static function raw($column): string
+	{
+		return '`' . $column . '`';
+	}
+
+	/**
+	 * @param Connection|null $connection
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function find(Connection $connection = NULL): mixed
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand(SqlBuilder::builder($this)->all())
+			->one();
+	}
+
+	/**
+	 * @param Connection|NULL $connection
+	 * @return bool|int
+	 * @throws Exception
+	 */
+	public function count(Connection $connection = NULL): bool|int
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand(SqlBuilder::builder($this)->count())
+			->exec();
+	}
+
+	/**
+	 * @param Connection|NULL $connection
+	 * @return bool|int
+	 * @throws Exception
+	 */
+	public function exists(Connection $connection = NULL): bool|int
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand(SqlBuilder::builder($this)->one())
+			->fetchColumn();
+	}
+
+	/**
+	 * @param string $sql
+	 * @param array $attributes
+	 * @param Connection|null $connection
+	 * @return array|bool|int|string|null
+	 * @throws Exception
+	 */
+	public static function findAllBySql(string $sql, array $attributes = [], Connection $connection = NULL): int|bool|array|string|null
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand($sql, $attributes)->all();
+	}
+
+	/**
+	 * @param string $sql
+	 * @param array $attributes
+	 * @param Connection|NULL $connection
+	 * @return string|array|bool|int|null
+	 * @throws Exception
+	 */
+	public static function findBySql(string $sql, array $attributes = [], Connection $connection = NULL): string|array|bool|int|null
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand($sql, $attributes)->one();
+	}
+
+	/**
+	 * @param string $field
+	 * @return array|null
+	 * @throws Exception
+	 */
+	public function values(string $field): ?array
+	{
+		$data = $this->get();
+		if (empty($data) || empty($field)) {
+			return NULL;
+		}
+		$first = current($data);
+		if (!isset($first[$field])) {
+			return NULL;
+		}
+		return array_column($data, $field);
+	}
+
+	/**
+	 * @param $field
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function value($field): mixed
+	{
+		$data = $this->find();
+		if (!empty($field) && isset($data[$field])) {
+			return $data[$field];
+		}
+		return $data;
+	}
+
+	/**
+	 * @param Connection|null $connection
+	 * @return bool|int
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function delete(?Connection $connection = null): bool|int
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		return $connection->createCommand($connection->getBuild()->builder($this))->delete();
+	}
+
+	/**
+	 * @param string $table
+	 * @param null $connection
+	 * @return bool|int
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public static function drop(string $table, $connection = null): bool|int
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		$sprint = sprintf('DROP TABLE `%s`.`%s`', $connection->database, $table);
+		return $connection->createCommand($sprint)->delete();
+	}
+
+	/**
+	 * @param string $table
+	 * @param null $connection
+	 * @return bool|int
+	 * @throws Exception
+	 */
+	public static function truncate(string $table, $connection = null): bool|int
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		$sprint = sprintf('TRUNCATE `%s`.`%s`', $connection->database, $table);
+		return $connection->createCommand($sprint)->exec();
+	}
+
+	/**
+	 * @param string $table
+	 * @param Connection|NULL $connection
+	 * @return mixed
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public static function showCreateSql(string $table, Connection $connection = NULL): mixed
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		$sprint = sprintf('SHOW CREATE TABLE `%s`.`%s`', $connection->database, $table);
+		return $connection->createCommand($sprint)->one();
+	}
+
+	/**
+	 * @param string $table
+	 * @param Connection|NULL $connection
+	 * @return bool|int|null
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public static function desc(string $table, Connection $connection = NULL): bool|int|null
+	{
+		$connection = static::getDefaultConnection($connection);
+
+		$sprint = sprintf('SHOW FULL FIELDS FROM `%s`.`%s`', $connection->database, $table);
+		return $connection->createCommand($sprint)->all();
+	}
+
+
+	/**
+	 * @param string $table
+	 * @param Connection|NULL $connection
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public static function show(string $table, Connection $connection = NULL): mixed
+	{
+		if (empty($table)) {
+			return null;
+		}
+		$connection = static::getDefaultConnection($connection);
+
+		$table = ['	const TABLE = \'select * from %s  where REFERENCED_TABLE_NAME=%s\';'];
+		return $connection->createCommand((new Query())
+			->select('*')
+			->from('INFORMATION_SCHEMA.KEY_COLUMN_USAGE')
+			->where(['REFERENCED_TABLE_NAME' => $table])
+			->getSql())->one();
+	}
+
+
+	/**
+	 * @param null|Connection $connection
+	 * @param null $name
+	 * @return mixed
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public static function getDefaultConnection(?Connection $connection, $name = null): Connection
+	{
+		if ($connection instanceof Connection) {
+			return $connection;
+		}
+		$databases = Config::get('databases.connections', []);
+		if (empty($databases) || !is_array($databases)) {
+			throw new Exception('Please configure the database link.');
+		}
+		if (!empty($name)) {
+			if (!isset($databases[$name])) {
+				throw new Exception('Please configure the database link.');
+			}
+			return $databases[$name];
+		}
+		return current($databases);
+	}
+
+
+}

src/HasCount.php

@@ -0,0 +1,39 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+use Exception;
+use Database\Traits\HasBase;
+
+/**
+ * Class HasCount
+ * @package Database
+ */
+class HasCount extends HasBase
+{
+
+	/**
+	 * @param $name
+	 * @param $arguments
+	 * @return ActiveQuery
+	 * @throws Exception
+	 */
+	public function __call($name, $arguments): mixed
+	{
+		if (method_exists($this, $name)) {
+			return call_user_func([$this, $name], ...$arguments);
+		}
+		return $this->_relation->getQuery($this->model::className())->$name(...$arguments);
+	}
+
+	/**
+	 * @return array|null|ActiveRecord
+	 * @throws Exception
+	 */
+	public function get(): array|ActiveRecord|null
+	{
+		return $this->_relation->count($this->model::className(), $this->value);
+	}
+
+}

src/HasMany.php

@@ -0,0 +1,44 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/4 0004
+ * Time: 13:58
+ */
+declare(strict_types=1);
+namespace Database;
+
+use Exception;
+use Database\Traits\HasBase;
+
+/**
+ * Class HasMany
+ * @package Database
+ *
+ * @method with($name)
+ */
+class HasMany extends HasBase
+{
+
+	/**
+	 * @param $name
+	 * @param $arguments
+	 * @return ActiveQuery
+	 */
+	public function __call($name, $arguments): mixed
+	{
+		if (method_exists($this, $name)) {
+			return call_user_func([$this, $name], ...$arguments);
+		}
+		return $this->_relation->getQuery($this->model::className())->$name(...$arguments);
+	}
+
+	/**
+	 * @return array|null|ActiveRecord
+	 * @throws Exception
+	 */
+	public function get(): array|ActiveRecord|null
+	{
+		return $this->_relation->get($this->model::className(), $this->value);
+	}
+}

src/HasOne.php

@@ -0,0 +1,45 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/4 0004
+ * Time: 13:47
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+use Exception;
+use Database\Traits\HasBase;
+
+/**
+ * Class HasOne
+ * @package Database
+ * @internal Query
+ */
+class HasOne extends HasBase
+{
+
+	/**
+	 * @param $name
+	 * @param $arguments
+	 * @return ActiveQuery
+	 */
+	public function __call($name, $arguments): mixed
+	{
+		if (method_exists($this, $name)) {
+			return call_user_func([$this, $name], ...$arguments);
+		}
+		$this->_relation->getQuery($this->model::className())->$name(...$arguments);
+		return $this;
+	}
+
+	/**
+	 * @return array|null|ActiveRecord
+	 * @throws Exception
+	 */
+	public function get(): array|ActiveRecord|null
+	{
+		return $this->_relation->first($this->model::className(), $this->value);
+	}
+}

src/IOrm.php

@@ -0,0 +1,50 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 14:39
+ */
+declare(strict_types=1);
+namespace Database;
+
+
+/**
+ * Interface IOrm
+ * @package Database
+ */
+interface IOrm
+{
+
+	/**
+	 * @param $param
+	 * @param null $db
+	 * @return ActiveRecord
+	 */
+	public static function findOne($param, $db = NULL): mixed;
+
+
+    /**
+     * @return string
+     */
+	public static function className(): string;
+
+
+    /**
+     * @return ActiveQuery
+     * return a sql queryBuilder
+     */
+	public static function find(): ActiveQuery;
+
+
+	/**
+	 * @param $dbName
+	 * @return Connection
+	 */
+	public static function setDatabaseConnect($dbName): Connection;
+
+//	public static function deleteAll($condition, $attributes);
+
+//	public static function updateAll($condition, $attributes);
+
+}

src/ISqlBuilder.php

@@ -0,0 +1,10 @@
+<?php
+
+
+namespace Database;
+
+
+interface ISqlBuilder
+{
+
+}

src/Mysql/Columns.php

@@ -0,0 +1,406 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: admin
+ * Date: 2019-03-18
+ * Time: 17:22
+ */
+
+declare(strict_types=1);
+
+namespace Database\Mysql;
+
+
+use Database\Connection;
+use Database\SqlBuilder;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+use Kiri\Abstracts\Component;
+use Kiri\Core\Json;
+
+/**
+ * Class Columns
+ * @package Database\Mysql
+ */
+class Columns extends Component
+{
+
+	/**
+	 * @var array
+	 * field types
+	 */
+	private array $columns = [];
+
+	/**
+	 * @var Connection
+	 * Mysql client
+	 */
+	public Connection $db;
+
+	/**
+	 * @var string
+	 * tableName
+	 */
+	public string $table = '';
+
+	/**
+	 * @var array
+	 * field primary key
+	 */
+	private array $_primary = [];
+
+	/**
+	 * @var array
+	 * by mysql field auto_increment
+	 */
+	private array $_auto_increment = [];
+
+
+	private array $_fields = [];
+
+	/**
+	 * @param string $table
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function table(string $table): static
+	{
+		$this->structure($this->table = $table);
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getTable(): string
+	{
+		return $this->table;
+	}
+
+	/**
+	 * @param $key
+	 * @param $val
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function fieldFormat($key, $val): mixed
+	{
+		return $this->encode($val, $this->get_fields($key));
+	}
+
+	/**
+	 * @param $data
+	 * @return array
+	 * @throws
+	 */
+	public function populate($data): array
+	{
+		$column = $this->get_fields();
+		foreach ($data as $key => $val) {
+			if (!isset($column[$key])) {
+				continue;
+			}
+			$data[$key] = $this->decode($val, $column[$key]);
+		}
+		return $data;
+	}
+
+	/**
+	 * @param $val
+	 * @param null $format
+	 * @return mixed
+	 */
+	public function decode($val, $format = null): mixed
+	{
+		if (empty($format) || $val === null) {
+			return $val;
+		}
+		$format = strtolower($format);
+		if ($this->isInt($format)) {
+			return (int)$val;
+		} else if ($this->isJson($format)) {
+			return Json::decode($val, true);
+		} else if ($this->isFloat($format)) {
+			return (float)$val;
+		} else {
+			return stripslashes($val);
+		}
+	}
+
+
+	/**
+	 * @param string $name
+	 * @param $value
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function _decode(string $name, $value): mixed
+	{
+		return $this->decode($value, $this->get_fields($name));
+	}
+
+
+	/**
+	 * @param $val
+	 * @param null $format
+	 * @return float|bool|int|string
+	 * @throws Exception
+	 */
+	public function encode($val, $format = null): float|bool|int|string
+	{
+		if (empty($format)) {
+			return $val;
+		}
+		$format = strtolower($format);
+		if ($this->isInt($format)) {
+			return (int)$val;
+		} else if ($this->isJson($format)) {
+			return Json::encode($val);
+		} else if ($this->isFloat($format)) {
+			return (float)$val;
+		} else {
+			return addslashes($val);
+		}
+	}
+
+	/**
+	 * @param $format
+	 * @return bool
+	 */
+	#[Pure] public function isInt($format): bool
+	{
+		return in_array($format, ['int', 'bigint', 'tinyint', 'smallint', 'mediumint']);
+	}
+
+	/**
+	 * @param $format
+	 * @return bool
+	 */
+	#[Pure] public function isFloat($format): bool
+	{
+		return in_array($format, ['float', 'double', 'decimal']);
+	}
+
+	/**
+	 * @param $format
+	 * @return bool
+	 */
+	#[Pure] public function isJson($format): bool
+	{
+		return in_array($format, ['json']);
+	}
+
+	/**
+	 * @param $format
+	 * @return bool
+	 */
+	#[Pure] public function isString($format): bool
+	{
+		return in_array($format, ['varchar', 'char', 'text', 'longtext', 'tinytext', 'mediumtext']);
+	}
+
+
+	/**
+	 * @return array
+	 * @throws
+	 */
+	public function format(): array
+	{
+		return $this->columns('Default', 'Field');
+	}
+
+
+	/**
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function getFields(): array
+	{
+		if (empty($this->_fields)) {
+			$this->structure($this->table);
+		}
+		return $this->_fields[$this->table];
+	}
+
+
+	/**
+	 * @param string $name
+	 * @return bool
+	 * @throws Exception
+	 */
+	public function hasField(string $name): bool
+	{
+		return array_key_exists($name, $this->getFields());
+	}
+
+
+	/**
+	 * @return int|string|null
+	 * @throws Exception
+	 */
+	public function getAutoIncrement(): int|string|null
+	{
+		return $this->_auto_increment[$this->table] ?? null;
+	}
+
+	/**
+	 * @return array|null|string
+	 *
+	 * @throws Exception
+	 */
+	public function getPrimaryKeys(): array|string|null
+	{
+		if (isset($this->_auto_increment[$this->table])) {
+			return $this->_auto_increment[$this->table];
+		}
+		return $this->_primary[$this->table] ?? null;
+	}
+
+	/**
+	 * @return array|null|string
+	 *
+	 * @throws Exception
+	 */
+	#[Pure] public function getFirstPrimary(): array|string|null
+	{
+		if (isset($this->_auto_increment[$this->table])) {
+			return $this->_auto_increment[$this->table];
+		}
+		if (isset($this->_primary[$this->table])) {
+			return current($this->_primary[$this->table]);
+		}
+		return null;
+	}
+
+	/**
+	 * @param $name
+	 * @param null $index
+	 * @return array
+	 * @throws Exception
+	 */
+	private function columns($name, $index = null): array
+	{
+		if (empty($index)) {
+			return array_column($this->getColumns(), $name);
+		} else {
+			return array_column($this->getColumns(), $name, $index);
+		}
+	}
+
+	/**
+	 * @return array|static
+	 * @throws Exception
+	 */
+	private function getColumns(): array|static
+	{
+		return $this->structure($this->getTable());
+	}
+
+
+	/**
+	 * @param $table
+	 * @return array|Columns
+	 * @throws Exception
+	 */
+	private function structure($table): array|static
+	{
+		if (!isset($this->columns[$table]) || empty($this->columns[$table])) {
+			$column = $this->db->createCommand(SqlBuilder::builder(null)->columns($table))->all();
+			if (empty($column)) {
+				throw new Exception("The table " . $table . " not exists.");
+			}
+			return $this->columns[$table] = $this->resolve($column, $table);
+		}
+		return $this->columns[$table];
+	}
+
+
+	/**
+	 * @param $column
+	 * @param $table
+	 * @return array
+	 */
+	private function resolve(array $column, $table): array
+	{
+		foreach ($column as $key => $item) {
+			$this->addPrimary($item, $table);
+			$column[$key]['Type'] = $this->clean($item['Type']);
+		}
+
+		$this->_fields[$table] = array_column($column, 'Default', 'Field');
+
+		return $column;
+	}
+
+	/**
+	 * @param $item
+	 * @param $table
+	 */
+	private function addPrimary($item, $table)
+	{
+		if (!isset($this->_primary[$table])) {
+			$this->_primary[$table] = [];
+		}
+		if ($item['Key'] === 'PRI') {
+			$this->_primary[$table][] = $item['Field'];
+		}
+		$this->addIncrement($item, $table);
+	}
+
+
+	/**
+	 * @param $item
+	 * @param $table
+	 */
+	private function addIncrement($item, $table)
+	{
+		if ($item['Extra'] !== 'auto_increment') {
+			return;
+		}
+		$this->_auto_increment[$table] = $item['Field'];
+	}
+
+
+	/**
+	 * @param $type
+	 * @return string
+	 */
+	public function clean($type): string
+	{
+		if (!str_contains($type, ')')) {
+			return $type;
+		}
+		$replace = preg_replace('/\(\d+(,\d+)?\)(\s+\w+)*/', '', $type);
+		if (str_contains($replace, ' ')) {
+			$replace = explode(' ', $replace)[1];
+		}
+		return $replace;
+	}
+
+	/**
+	 * @param null $field
+	 * @return array|string|null
+	 * @throws Exception
+	 */
+	public function get_fields($field = null): array|string|null
+	{
+		$fields = $this->getAllField();
+		if (empty($field)) {
+			return $fields;
+		}
+		if (isset($fields[$field])) {
+			return strtolower($fields[$field]);
+		}
+		return null;
+	}
+
+	/**
+	 * @return array
+	 * @throws Exception
+	 */
+	public function getAllField(): array
+	{
+		return $this->columns('Type', 'Field');
+	}
+
+}

src/Mysql/Schema.php

@@ -0,0 +1,36 @@
+<?php
+declare(strict_types=1);
+namespace Database\Mysql;
+
+
+use Exception;
+use Kiri\Abstracts\Component;
+use Database\Connection;
+
+/**
+ * Class Schema
+ * @package Database\Mysql
+ */
+class Schema extends Component
+{
+
+	/** @var ?Connection */
+	public ?Connection $db = null;
+
+	/** @var ?Columns $_column*/
+	private ?Columns $_column = null;
+
+
+	/**
+	 * @return Columns|null
+	 * @throws Exception
+	 */
+	public function getColumns(): ?Columns
+	{
+		if ($this->_column === null) {
+			$this->_column = new Columns(['db' => $this->db]);
+		}
+
+		return $this->_column;
+	}
+}

src/Orm/Condition.php

@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace Database\Orm;
+
+
+use Database\Traits\Builder;
+use Exception;
+
+/**
+ * Trait Condition
+ * @package Database\Orm
+ */
+trait Condition
+{
+
+
+	use Builder;
+
+	/**
+	 * @param $query
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getWhere($query): string
+	{
+		return $this->where($query);
+	}
+}

src/Pagination.php

@@ -0,0 +1,200 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Closure;
+use Exception;
+use Kiri\Abstracts\Component;
+
+/**
+ * Class Pagination
+ * @package Database
+ */
+class Pagination extends Component
+{
+
+	/** @var ActiveQuery */
+	private ActiveQuery $activeQuery;
+
+	/** @var int 从第几个开始查 */
+	private int $_offset = 0;
+
+	/** @var int 每页数量 */
+	private int $_limit = 100;
+
+	/** @var int 最大查询数量 */
+	private int $_max = 0;
+
+	/** @var int 当前已查询数量 */
+	private int $_length = 0;
+
+	/** @var Closure */
+	private Closure $_callback;
+
+
+	/**
+	 * PaginationIteration constructor.
+	 * @param ActiveQuery $activeQuery
+	 * @param array $config
+	 * @throws Exception
+	 */
+	public function __construct(ActiveQuery $activeQuery, array $config = [])
+	{
+		parent::__construct($config);
+		$this->activeQuery = $activeQuery;
+	}
+
+
+	public function clean()
+	{
+		unset($this->activeQuery, $this->_callback, $this->_group);
+		$this->_offset = 0;
+		$this->_limit = 100;
+		$this->_max = 0;
+		$this->_length = 0;;
+	}
+
+
+	/**
+	 * recover class by clone
+	 */
+	public function __clone()
+	{
+		$this->clean();
+	}
+
+
+	/**
+	 * @param array|Closure $callback
+	 * @throws Exception
+	 */
+	public function setCallback(array|Closure $callback)
+	{
+		if (!is_callable($callback, true)) {
+			throw new Exception('非法回调函数~');
+		}
+		$this->_callback = $callback;
+	}
+
+
+	/**
+	 * @param int $number
+	 * @return Pagination
+	 */
+	public function setOffset(int $number): static
+	{
+		if ($number < 0) {
+			$number = 0;
+		}
+		$this->_offset = $number;
+		return $this;
+	}
+
+
+	/**
+	 * @param int $number
+	 * @return Pagination
+	 */
+	public function setLimit(int $number): static
+	{
+		if ($number < 1) {
+			$number = 100;
+		} else if ($number > 5000) {
+			$number = 5000;
+		}
+		$this->_limit = $number;
+		return $this;
+	}
+
+
+	/**
+	 * @param int $number
+	 * @return Pagination
+	 */
+	public function setMax(int $number): static
+	{
+		if ($number < 0) {
+			return $this;
+		}
+		$this->_max = $number;
+		return $this;
+	}
+
+
+	/**
+	 * @param array $param
+	 * @return void
+	 * @throws Exception
+	 */
+	public function plunk($param = [])
+	{
+		$this->loop($param);
+	}
+
+
+	/**
+	 * 轮训
+	 * @param $param
+	 * @return array
+	 * @throws Exception
+	 */
+	public function loop($param): array
+	{
+		if ($this->_max > 0 && $this->_length >= $this->_max) {
+			return $this->output();
+		}
+		[$length, $data] = $this->get();
+
+		$this->executed($data, $param);
+
+		unset($data);
+		if ($length < $this->_limit) {
+			return $this->output();
+		}
+		return $this->loop($param);
+	}
+
+
+	/**
+	 * @return array
+	 */
+	public function output(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * @param $data
+	 * @param $param
+	 * @throws Exception
+	 */
+	private function executed($data, $param): void
+	{
+		try {
+			call_user_func($this->_callback, $data, $param);
+		} catch (\Throwable $exception) {
+			$this->addError($exception, 'throwable');
+		} finally {
+			logger()->insert();
+		}
+	}
+
+
+	/**
+	 * @return array|Collection
+	 */
+	private function get(): Collection|array
+	{
+		if ($this->_max > 0 && $this->_length + $this->_limit > $this->_max) {
+			$this->_limit = $this->_length + $this->_limit - $this->_max;
+		}
+		$data = $this->activeQuery->limit($this->_offset, $this->_limit)->get();
+		$this->_offset += $this->_limit;
+		$this->_length += $data->size();
+		return [$data->size(), $data];
+	}
+
+}

src/Query.php

@@ -0,0 +1,54 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/6/27 0027
+ * Time: 17:49
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Database\Traits\QueryTrait;
+use Exception;
+
+/**
+ * Class Query
+ * @package Database
+ */
+class Query implements ISqlBuilder
+{
+
+	use QueryTrait;
+
+
+	/**
+	 * @throws Exception
+	 */
+	public function __construct()
+	{
+		$this->builder = SqlBuilder::builder($this);
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getSql(): string
+	{
+		return $this->builder->get();
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getCondition(): string
+	{
+		return $this->builder->getCondition();
+	}
+
+
+}

src/Relation.php

@@ -0,0 +1,111 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+
+use Exception;
+use Kiri\Abstracts\Component;
+
+/**
+ * Class Relation
+ * @package Kiri\db
+ */
+class Relation extends Component
+{
+
+	private array $_relations = [];
+
+	/** @var ActiveQuery[] $_query */
+	private array $_query = [];
+
+	/**
+	 * @param string $identification
+	 * @param ActiveQuery $query
+	 * @return $this
+	 */
+	public function bindIdentification(string $identification, ActiveQuery $query): static
+	{
+		$this->_query[$identification] = $query;
+		return $this;
+	}
+
+	/**
+	 * @param $name
+	 * @return ActiveQuery|null
+	 */
+	public function getQuery(string $name): ?ActiveQuery
+	{
+		return $this->_query[$name] ?? null;
+	}
+
+
+	/**
+	 * @param string $identification
+	 * @param $localValue
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function first(string $identification, $localValue): mixed
+	{
+		$_identification = $identification . '_first_' . $localValue;
+		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+			return $this->_relations[$_identification];
+		}
+
+		$activeModel = $this->_query[$identification]->first();
+		if (empty($activeModel)) {
+			return null;
+		}
+
+		return $this->_relations[$_identification] = $activeModel;
+	}
+
+
+	/**
+	 * @param string $identification
+	 * @param $localValue
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function count(string $identification, $localValue): mixed
+	{
+		$_identification = $identification . '_count_' . $localValue;
+		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+			return $this->_relations[$_identification];
+		}
+
+		$activeModel = $this->_query[$identification]->count();
+		if (empty($activeModel)) {
+			return null;
+		}
+
+		return $this->_relations[$_identification] = $activeModel;
+	}
+
+
+	/**
+	 * @param string $identification
+	 * @param $localValue
+	 * @return mixed
+	 */
+	public function get(string $identification, $localValue): mixed
+	{
+		if (is_array($localValue)) {
+			$_identification = $identification . '_get_' . implode('_', $localValue);
+		} else {
+			$_identification = $identification . '_get_' . $localValue;
+		}
+		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+			return $this->_relations[$_identification];
+		}
+
+		$activeModel = $this->_query[$identification]->get();
+		if (empty($activeModel)) {
+			return null;
+		}
+
+		return $this->_relations[$_identification] = $activeModel;
+	}
+
+}

src/SqlBuilder.php

@@ -0,0 +1,369 @@
+<?php
+
+
+namespace Database;
+
+
+use Database\Traits\Builder;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+use Kiri\Abstracts\Component;
+
+
+/**
+ * Class SqlBuilder
+ * @package Database
+ */
+class SqlBuilder extends Component
+{
+
+	use Builder;
+
+
+	public ActiveQuery|Query|null $query;
+
+
+	/**
+	 * @param ISqlBuilder|null $query
+	 * @return $this
+	 * @throws Exception
+	 */
+	public static function builder(ISqlBuilder|null $query): static
+	{
+		return new static(['query' => $query]);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getCondition(): string
+	{
+		return $this->conditionToString();
+	}
+
+
+	/**
+	 * @param array $compiler
+	 * @return string
+	 * @throws Exception
+	 */
+	public function hashCompiler(array $compiler): string
+	{
+		return $this->where($compiler);
+	}
+
+
+	/**
+	 * @param array $attributes
+	 * @return bool|array
+	 * @throws Exception
+	 */
+	public function update(array $attributes): bool|array
+	{
+		[$string, $array] = $this->builderParams($attributes);
+
+		return $this->__updateBuilder($string, $array);
+	}
+
+
+	/**
+	 * @param array $attributes
+	 * @param string $opera
+	 * @return bool|array
+	 * @throws Exception
+	 */
+	public function mathematics(array $attributes, string $opera = '+'): bool|array
+	{
+		$string = [];
+		foreach ($attributes as $attribute => $value) {
+			$string[] = $attribute . '=' . $attribute . $opera . $value;
+		}
+		return $this->__updateBuilder($string, []);
+	}
+
+
+	/**
+	 * @param array $string
+	 * @param array $params
+	 * @return array|bool
+	 * @throws Exception
+	 */
+	private function __updateBuilder(array $string, array $params): array|bool
+	{
+		if (empty($string)) {
+			return $this->addError('None data update.');
+		}
+
+		$condition = $this->conditionToString();
+		if (!empty($condition)) {
+			$condition = ' WHERE ' . $condition;
+		}
+
+		$update = 'UPDATE ' . $this->tableName() . ' SET ' . implode(',', $string) . $condition;
+		$update .= $this->builderLimit($this->query, false);
+
+		return [$update, $params];
+	}
+
+
+	/**
+	 * @param array $attributes
+	 * @param false $isBatch
+	 * @return array
+	 * @throws Exception
+	 */
+	public function insert(array $attributes, bool $isBatch = false): array
+	{
+		$update = sprintf('INSERT INTO %s', $this->tableName());
+		if ($isBatch === false) {
+			$attributes = [$attributes];
+		}
+		$update .= '(' . implode(',', $this->getFields($attributes)) . ') VALUES ';
+
+		$order = 0;
+		$keys = $params = [];
+		foreach ($attributes as $attribute) {
+			[$_keys, $params] = $this->builderParams($attribute, true, $params, $order);
+
+			$keys[] = implode(',', $_keys);
+			$order++;
+		}
+		return [$update . '(' . implode('),(', $keys) . ')', $params];
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function delete(): string
+	{
+		$delete = sprintf('DELETE FROM %s ', $this->query->modelClass::getTable());
+
+		$this->query->from = null;
+
+		return $delete . ' WHERE ' . $this->_prefix(true);
+	}
+
+
+	/**
+	 * @param $attributes
+	 * @return array
+	 */
+	#[Pure] private function getFields($attributes): array
+	{
+		return array_keys(current($attributes));
+	}
+
+
+	/**
+	 * @param array $attributes
+	 * @param bool $isInsert
+	 * @param array $params
+	 * @param int $order
+	 * @return array[]
+	 * a=:b,
+	 */
+	#[Pure] private function builderParams(array $attributes, bool $isInsert = false, array $params = [], int $order = 0): array
+	{
+		$keys = [];
+		foreach ($attributes as $key => $value) {
+			if ($isInsert === true) {
+				$keys[] = ':' . $key . $order;
+				$params[$key . $order] = $value;
+			} else {
+				[$keys, $params] = $this->resolveParams($key, $value, $order, $params, $keys);
+			}
+		}
+		return [$keys, $params];
+	}
+
+
+	/**
+	 * @param string $key
+	 * @param mixed $value
+	 * @param int $order
+	 * @param array $params
+	 * @param array $keys
+	 * @return array
+	 */
+	private function resolveParams(string $key, mixed $value, int $order, array $params, array $keys): array
+	{
+		if (
+			str_starts_with($value, '+ ') ||
+			str_starts_with($value, '- ')
+		) {
+			$keys[] = $key . '=' . $key . ' ' . $value;
+		} else {
+			$params[$key . $order] = $value;
+			$keys[] = $key . '=:' . $key . $order;
+		}
+		return [$keys, $params];
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function one(): string
+	{
+		$this->query->limit(0, 1);
+		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+			$this->query->from($this->query->getTable());
+		}
+		return $this->_prefix(true);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function all(): string
+	{
+		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+			$this->query->from($this->query->getTable());
+		}
+		return $this->_prefix(true);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function count(): string
+	{
+		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+			$this->query->from($this->query->getTable());
+		}
+		return $this->_prefix();
+	}
+
+
+	/**
+	 * @param $table
+	 * @return string
+	 */
+	public function columns($table): string
+	{
+		return 'SHOW FULL FIELDS FROM ' . $table;
+	}
+
+
+	/**
+	 * @param bool $hasOrder
+	 * @return string
+	 * @throws Exception
+	 */
+	private function _prefix(bool $hasOrder = false): string
+	{
+		$select = '';
+		if (!empty($this->query->from)) {
+			$select = $this->_selectPrefix();
+		}
+		$select = $this->_wherePrefix($select);
+		if (!empty($this->query->attributes) && is_array($this->query->attributes)) {
+			$select = strtr($select, $this->query->attributes);
+		}
+
+		if (!empty($this->query->group)) {
+			$select .= $this->builderGroup($this->query->group);
+		}
+		if ($hasOrder === true && !empty($this->query->order)) {
+			$select .= $this->builderOrder($this->query->order);
+		}
+		return $select . $this->builderLimit($this->query);
+	}
+
+
+	/**
+	 * @param $select
+	 * @return string
+	 * @throws Exception
+	 */
+	private function _wherePrefix($select): string
+	{
+		$condition = $this->conditionToString();
+		if (empty($condition)) {
+			return $select;
+		} else if (empty($select)) {
+			return $condition;
+		}
+		return sprintf('%s WHERE %s', $select, $condition);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	private function _selectPrefix(): string
+	{
+		$select = $this->builderSelect($this->query->select) . ' FROM ' . $this->tableName();
+		if (!empty($this->query->alias)) {
+			$select .= $this->builderAlias($this->query->alias);
+		}
+		if (!empty($this->query->join)) {
+			$select .= $this->builderJoin($this->query->join);
+		}
+		return $select;
+	}
+
+
+	/**
+	 * @param false $isCount
+	 * @return string
+	 * @throws Exception
+	 */
+	public function get(bool $isCount = false): string
+	{
+		if ($isCount === false) {
+			return $this->all();
+		}
+		return $this->count();
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function truncate(): string
+	{
+		return sprintf('TRUNCATE %s', $this->tableName());
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	private function conditionToString(): string
+	{
+		return $this->where($this->query->where);
+	}
+
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function tableName(): string
+	{
+		if ($this->query->from instanceof \Closure) {
+			$this->query->from = sprintf('(%s)', $this->query->makeClosureFunction($this->query->from));
+		}
+		if ($this->query->from instanceof ActiveQuery) {
+			$this->query->from = sprintf('%s', SqlBuilder::builder($this->query->from)->get($this->query->from));
+		}
+		if (empty($this->query->from)) {
+			return $this->query->modelClass::getTable();
+		}
+		return $this->query->from;
+	}
+
+}

src/Traits/Builder.php

@@ -0,0 +1,218 @@
+<?php
+
+
+namespace Database\Traits;
+
+
+use Database\ActiveQuery;
+use Database\Base\ConditionClassMap;
+use Database\Condition\HashCondition;
+use Database\Condition\OrCondition;
+use Database\Query;
+use Database\SqlBuilder;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+use ReflectionException;
+use Kiri\Exception\NotFindClassException;
+use Kiri\Kiri;
+
+
+/**
+ * Trait Builder
+ * @package Database\Traits
+ */
+trait Builder
+{
+
+
+	/**
+	 * @param $alias
+	 * @return string
+	 */
+	private function builderAlias($alias): string
+	{
+		return " AS " . $alias;
+	}
+
+	/**
+	 * @param $table
+	 * @return string
+	 * @throws Exception
+	 */
+	private function builderFrom($table): string
+	{
+		if ($table instanceof ActiveQuery) {
+			$table = '(' . $table->toSql() . ')';
+		}
+		return " FROM " . $table;
+	}
+
+	/**
+	 * @param $join
+	 * @return string
+	 */
+	#[Pure] private function builderJoin($join): string
+	{
+		if (!empty($join)) {
+			return ' ' . implode(' ', $join);
+		}
+		return '';
+	}
+
+
+	/**
+	 * @param null $select
+	 * @return string
+	 */
+	#[Pure] private function builderSelect($select = NULL): string
+	{
+		if (empty($select)) {
+			return "SELECT *";
+		}
+		if (is_array($select)) {
+			return "SELECT " . implode(',', $select);
+		} else {
+			return "SELECT " . $select;
+		}
+	}
+
+
+	/**
+	 * @param $group
+	 * @return string
+	 */
+	private function builderGroup($group): string
+	{
+		if (empty($group)) {
+			return '';
+		}
+		return ' GROUP BY ' . $group;
+	}
+
+	/**
+	 * @param $order
+	 * @return string
+	 */
+	#[Pure] private function builderOrder($order): string
+	{
+		if (!empty($order)) {
+			return ' ORDER BY ' . implode(',', $order);
+		} else {
+			return '';
+		}
+	}
+
+	/**
+	 * @param ActiveQuery|Query $query
+	 * @param bool $hasLimit
+	 * @return string
+	 */
+	#[Pure] private function builderLimit(ActiveQuery|Query $query, bool $hasLimit = true): string
+	{
+		if (!is_numeric($query->limit) || $query->limit < 1) {
+			return "";
+		}
+		if ($query->offset !== null && $hasLimit) {
+			return ' LIMIT ' . $query->offset . ',' . $query->limit;
+		}
+		return ' LIMIT ' . $query->limit;
+	}
+
+
+	/**
+	 * @param $where
+	 * @return string
+	 * @throws Exception
+	 */
+	private function where($where): string
+	{
+		$_tmp = [];
+		if (empty($where)) return '';
+		if (is_string($where)) return $where;
+		foreach ($where as $key => $value) {
+			$_value = $this->resolveCondition($key, $value, $_tmp);
+
+			if (empty($_value)) continue;
+			$_tmp[] = $_value;
+		}
+		if (!empty($_tmp)) {
+			return implode(' AND ', $_tmp);
+		}
+		return '';
+	}
+
+
+	/**
+	 * @param $field
+	 * @param $condition
+	 * @param $_tmp
+	 * @return string
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	private function resolveCondition($field, $condition, $_tmp): string
+	{
+		if (is_string($field)) {
+			$_value = sprintf('%s = \'%s\'', $field, $condition);
+		} else if (is_string($condition)) {
+			$_value = $condition;
+		} else {
+			$_value = $this->_arrayMap($condition, $_tmp);
+		}
+		return $_value;
+	}
+
+
+	/**
+	 * @param $condition
+	 * @param $array
+	 * @return string
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws ReflectionException
+	 */
+	private function _arrayMap($condition, $array): string
+	{
+		if (!isset($condition[0])) {
+			return implode(' AND ', $this->_hashMap($condition));
+		}
+		$stroppier = strtoupper($condition[0]);
+		if (str_contains($stroppier, 'OR')) {
+			if (!is_string($condition[2])) {
+				$condition[2] = $this->_hashMap($condition[2]);
+			}
+			$builder = Kiri::createObject(['class' => OrCondition::class, 'value' => $condition[2], 'column' => $condition[1], 'oldParams' => $array]);
+		} else if (isset(ConditionClassMap::$conditionMap[$stroppier])) {
+			$defaultConfig = ConditionClassMap::$conditionMap[$stroppier];
+			$create = array_merge($defaultConfig, ['column' => $condition[1], 'value' => $condition[2]]);
+			$builder = Kiri::createObject($create);
+		} else {
+			$builder = Kiri::createObject(['class' => HashCondition::class, 'value' => $condition]);
+		}
+
+		$array[] = $builder->builder();
+
+		return implode(' AND ', $array);
+	}
+
+
+	/**
+	 * @param $condition
+	 * @return array
+	 */
+	private function _hashMap($condition): array
+	{
+		$_array = [];
+		foreach ($condition as $key => $value) {
+			$value = is_numeric($value) ? $value : '\'' . $value . '\'';
+			if (!is_numeric($key)) {
+				$_array[] = sprintf('%s = %s', $key, $value);
+			} else {
+				$_array[] = $value;
+			}
+		}
+		return $_array;
+	}
+
+
+}

src/Traits/HasBase.php

@@ -0,0 +1,83 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/4 0004
+ * Time: 15:47
+ */
+declare(strict_types=1);
+
+namespace Database\Traits;
+
+use Database\ActiveRecord;
+use Database\Collection;
+use Database\IOrm;
+use Database\Relation;
+use Exception;
+
+/**
+ * Class HasBase
+ * @package Database
+ *
+ * @include Query
+ */
+abstract class HasBase
+{
+
+	/** @var ActiveRecord|Collection */
+	protected Collection|ActiveRecord $data;
+
+	/**
+	 * @var IOrm|ActiveRecord
+	 */
+	protected mixed $model;
+
+	protected mixed $value = [];
+
+
+	/** @var Relation $_relation */
+	protected Relation $_relation;
+
+    /**
+     * HasBase constructor.
+     * @param IOrm $model
+     * @param $primaryId
+     * @param $value
+     * @param Relation $relation
+     * @throws Exception
+     */
+	public function __construct(mixed $model, $primaryId, $value, Relation $relation)
+	{
+		if (!class_exists($model)) {
+			throw new Exception('Model must implement ' . ActiveRecord::class);
+		}
+		if (!in_array(IOrm::class, class_implements($model))) {
+			throw new Exception('Model must implement ' . ActiveRecord::class);
+		}
+		if (is_array($value)) {
+			if (empty($value)) $value = [];
+			$_model = $model::find()->whereIn($primaryId, $value);
+		} else {
+			$_model = $model::find()->where(['t1.' . $primaryId => $value]);
+		}
+
+		$this->_relation = $relation->bindIdentification($model, $_model);
+
+		$this->model = $model;
+		$this->value = $value;
+	}
+
+	abstract public function get();
+
+	/**
+	 * @param $name
+	 * @return mixed
+	 */
+	public function __get($name): mixed
+	{
+		if (empty($this->value)) {
+			return null;
+		}
+		return $this->get();
+	}
+}

src/Traits/QueryTrait.php

@@ -0,0 +1,938 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 14:56
+ */
+declare(strict_types=1);
+
+namespace Database\Traits;
+
+
+use Closure;
+use Database\ActiveQuery;
+use Database\ActiveRecord;
+use Database\Condition\MathematicsCondition;
+use Database\Query;
+use Database\SqlBuilder;
+use Exception;
+use ReflectionException;
+use Kiri\Exception\NotFindClassException;
+use Kiri\Kiri;
+
+/**
+ * Trait QueryTrait
+ * @package Database\Traits
+ */
+trait QueryTrait
+{
+	public array $where = [];
+	public array $select = [];
+	public array $join = [];
+	public array $order = [];
+	public ?int $offset = NULL;
+	public ?int $limit = NULL;
+	public string $group = '';
+	public string|Closure|ActiveQuery|null $from = '';
+	public string $alias = 't1';
+	public array $filter = [];
+
+	public bool $ifNotWhere = false;
+
+
+	private SqlBuilder $builder;
+
+	/**
+	 * @var ActiveRecord|string|null
+	 */
+	public ActiveRecord|string|null $modelClass;
+
+	/**
+	 * clear
+	 */
+	public function clear()
+	{
+		$this->where = [];
+		$this->select = [];
+		$this->join = [];
+		$this->order = [];
+		$this->offset = NULL;
+		$this->limit = NULL;
+		$this->group = '';
+		$this->from = '';
+		$this->alias = 't1';
+		$this->filter = [];
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param callable $callable
+	 * @return $this
+	 */
+	public function when(string $column, callable $callable): static
+	{
+		$caseWhen = new When($column, $this);
+
+		call_user_func($callable, $caseWhen);
+
+		$this->where[] = $caseWhen->end();
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $whereRaw
+	 * @return QueryTrait
+	 */
+	public function whereRaw(string $whereRaw): static
+	{
+		$this->where[] = $whereRaw;
+		return $this;
+	}
+
+
+	/**
+	 * @param string|array|Closure $condition
+	 * @param string|array|Closure $condition1
+	 * @param string|array|Closure $condition2
+	 * @return $this
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function whereIf(string|array|Closure $condition, string|array|Closure $condition1, string|array|Closure $condition2): static
+	{
+		if (!is_string($condition)) {
+			$condition = $this->makeClosureFunction($condition);
+		}
+
+		if (!is_string($condition1)) {
+			$condition1 = $this->makeClosureFunction($condition1);
+		}
+
+		if (!is_string($condition2)) {
+			$condition2 = $this->makeClosureFunction($condition2);
+		}
+
+		$this->where[] = 'IF(' . $condition . ', ' . $condition1 . ', ' . $condition2 . ')';
+		return $this;
+	}
+
+
+	/**
+	 * @param $bool
+	 * @return $this
+	 */
+	public function ifNotWhere($bool): static
+	{
+		$this->ifNotWhere = $bool;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public function getTable(): string
+	{
+		return $this->modelClass::getTable();
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param string $value
+	 * @return $this
+	 */
+	public function whereLocate(string $column, string $value): static
+	{
+		$this->where[] = 'LOCATE(' . $column . ',\'' . addslashes($value) . '\') > 0';
+		return $this;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @return $this
+	 */
+	public function whereNull(string $column): static
+	{
+		$this->where[] = $column . ' IS NULL';
+		return $this;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @return $this
+	 */
+	public function whereEmpty(string $column): static
+	{
+		$this->where[] = $column . ' = \'\'';
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @return $this
+	 */
+	public function whereNotEmpty(string $column): static
+	{
+		$this->where[] = $column . ' <> \'\'';
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @return $this
+	 */
+	public function whereNotNull(string $column): static
+	{
+		$this->where[] = $column . ' IS NOT NULL';
+		return $this;
+	}
+
+	/**
+	 * @param array|Closure|string $columns
+	 * @return $this
+	 */
+	public function filter(array|Closure|string $columns): static
+	{
+		if (!$columns) {
+			return $this;
+		}
+		if (is_callable($columns, TRUE)) {
+			return call_user_func($columns, $this);
+		}
+		if (is_string($columns)) {
+			$columns = explode(',', $columns);
+		}
+		if (!is_array($columns)) {
+			return $this;
+		}
+		$this->filter = $columns;
+		return $this;
+	}
+
+	/**
+	 * @param string $alias
+	 *
+	 * @return $this
+	 *
+	 * select * from tableName as t1
+	 */
+	public function alias(string $alias = 't1'): static
+	{
+		$this->alias = $alias;
+		return $this;
+	}
+
+	/**
+	 * @param string|Closure $tableName
+	 *
+	 * @return $this
+	 */
+	public function from(string|Closure $tableName): static
+	{
+		$this->from = $tableName;
+		return $this;
+	}
+
+	/**
+	 * @param string $tableName
+	 * @param string $alias
+	 * @param null $on
+	 * @param array|null $param
+	 * @return $this
+	 * $query->join([$tableName, ['userId'=>'uuvOd']], $param)
+	 * $query->join([$tableName, ['userId'=>'uuvOd'], $param])
+	 * $query->join($tableName, ['userId'=>'uuvOd',$param])
+	 */
+	private function join(string $tableName, string $alias, $on = NULL, array $param = NULL): static
+	{
+		if (empty($on)) {
+			return $this;
+		}
+		$join[] = $tableName . ' AS ' . $alias;
+		$join[] = 'ON ' . $this->onCondition($alias, $on);
+		if (empty($join)) {
+			return $this;
+		}
+
+		$this->join[] = implode(' ', $join);
+		if (!empty($param)) {
+			$this->addParams($param);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param $alias
+	 * @param $on
+	 * @return string
+	 */
+	private function onCondition($alias, $on): string
+	{
+		$array = [];
+		foreach ($on as $key => $item) {
+			if (!str_contains($item, '.')) {
+				$this->addParam($key, $item);
+			} else {
+				$explode = explode('.', $item);
+				if (isset($explode[1]) && ($explode[0] == $alias || $this->alias == $explode[0])) {
+					$array[] = $key . '=' . $item;
+				} else {
+					$this->addParam($key, $item);
+				}
+			}
+		}
+		return implode(' AND ', $array);
+	}
+
+	/**
+	 * @param string $tableName
+	 * @param string $alias
+	 * @param $onCondition
+	 * @param null $param
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function leftJoin(string $tableName, string $alias, $onCondition, $param = NULL): static
+	{
+		if (class_exists($tableName)) {
+			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+				throw new Exception('Model must implement ' . $tableName);
+			}
+			$tableName = $tableName::getTable();
+		}
+		return $this->join(...["LEFT JOIN " . $tableName, $alias, $onCondition, $param]);
+	}
+
+	/**
+	 * @param $tableName
+	 * @param $alias
+	 * @param $onCondition
+	 * @param null $param
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function rightJoin($tableName, $alias, $onCondition, $param = NULL): static
+	{
+		if (class_exists($tableName)) {
+			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+				throw new Exception('Model must implement ' . $tableName);
+			}
+			$tableName = $tableName::getTable();
+		}
+		return $this->join(...["RIGHT JOIN " . $tableName, $alias, $onCondition, $param]);
+	}
+
+	/**
+	 * @param $tableName
+	 * @param $alias
+	 * @param $onCondition
+	 * @param null $param
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function innerJoin($tableName, $alias, $onCondition, $param = NULL): static
+	{
+		if (class_exists($tableName)) {
+			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+				throw new Exception('Model must implement ' . $tableName);
+			}
+			$tableName = $tableName::getTable();
+		}
+		return $this->join(...["INNER JOIN " . $tableName, $alias, $onCondition, $param]);
+	}
+
+	/**
+	 * @param $array
+	 *
+	 * @return string
+	 */
+	private function toString($array): string
+	{
+		$tmp = [];
+		if (!is_array($array)) {
+			return $array;
+		}
+		foreach ($array as $key => $val) {
+			if (is_array($val)) {
+				$tmp[] = $this->toString($array);
+			} else {
+				$tmp[] = $key . '=:' . $key;
+				$this->attributes[':' . $key] = $val;
+			}
+		}
+		return implode(' AND ', $tmp);
+	}
+
+	/**
+	 * @param string $field
+	 *
+	 * @return $this
+	 */
+	public function sum(string $field): static
+	{
+		$this->select[] = 'SUM(' . $field . ') AS ' . $field;
+		return $this;
+	}
+
+	/**
+	 * @param string $field
+	 * @return $this
+	 */
+	public function max(string $field): static
+	{
+		$this->select[] = 'MAX(' . $field . ') AS ' . $field;
+		return $this;
+	}
+
+	/**
+	 * @param string $lngField
+	 * @param string $latField
+	 * @param int $lng1
+	 * @param int $lat1
+	 *
+	 * @return $this
+	 */
+	public function distance(string $lngField, string $latField, int $lng1, int $lat1): static
+	{
+		$sql = "ROUND(6378.138 * 2 * ASIN(SQRT(POW(SIN(($lat1 * PI() / 180 - $lat1 * PI() / 180) / 2),2) + COS($lat1 * PI() / 180) * COS($latField * PI() / 180) * POW(SIN(($lng1 * PI() / 180 - $lngField * PI() / 180) / 2),2))) * 1000) AS distance";
+		$this->select[] = $sql;
+		return $this;
+	}
+
+	/**
+	 * @param string|array $column
+	 * @param string $sort
+	 *
+	 * @return $this
+	 *
+	 * [
+	 *     'addTime',
+	 *     'descTime desc'
+	 * ]
+	 */
+	public function orderBy(string|array $column, string $sort = 'DESC'): static
+	{
+		if (empty($column)) {
+			return $this;
+		}
+		if (is_string($column)) {
+			return $this->addOrder(...func_get_args());
+		}
+
+		foreach ($column as $key => $val) {
+			$this->addOrder($val);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param string $sort
+	 *
+	 * @return $this
+	 *
+	 */
+	private function addOrder(string $column, string $sort = 'DESC'): static
+	{
+		$column = trim($column);
+
+		if (func_num_args() == 1 || str_contains($column, ' ')) {
+			$this->order[] = $column;
+		} else {
+			$this->order[] = "$column $sort";
+		}
+		return $this;
+	}
+
+	/**
+	 * @param array|string $column
+	 *
+	 * @return $this
+	 */
+	public function select(array|string $column = '*'): static
+	{
+		if ($column == '*') {
+			$this->select = $column;
+		} else {
+			if (!is_array($column)) {
+				$column = explode(',', $column);
+			}
+			foreach ($column as $val) {
+				$this->select[] = $val;
+			}
+		}
+		return $this;
+	}
+
+	/**
+	 * @return $this
+	 */
+	public function orderRand(): static
+	{
+		$this->order[] = 'RAND()';
+		return $this;
+	}
+
+	/**
+	 * @param array|Closure|string $conditionArray
+	 * @param string $opera
+	 * @param null $value
+	 * @return QueryTrait
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function whereOr(array|Closure|string $conditionArray = [], string $opera = '=', $value = null): static
+	{
+		if ($conditionArray instanceof Closure) {
+			$conditionArray = $this->makeClosureFunction($conditionArray);
+		}
+
+		if (func_num_args() > 1) {
+			[$conditionArray, $opera, $value] = $this->opera(...func_get_args());
+
+			$conditionArray = $this->sprintf($conditionArray, $value, $opera);
+		}
+
+		$this->where = ['(' . implode(' AND ', $this->where) . ') OR (' . $conditionArray . ')'];
+		return $this;
+	}
+
+	/**
+	 * @param string $columns
+	 * @param string|int|bool|null $value
+	 *
+	 * @param string $opera
+	 * @return QueryTrait
+	 */
+	public function whereAnd(string $columns, string $opera = '=', string|int|null|bool $value = NULL): static
+	{
+		[$columns, $opera, $value] = $this->opera(...func_get_args());
+
+		$this->where[] = $this->sprintf($columns, $value, $opera);
+		return $this;
+	}
+
+
+	/**
+	 * @param string $columns
+	 * @param string $value
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function whereLike(string $columns, string $value): static
+	{
+		if (empty($columns) || empty($value)) {
+			return $this;
+		}
+
+		if (is_array($columns)) {
+			$columns = 'CONCAT(' . implode(',^,', $columns) . ')';
+		}
+
+		$this->where[] = $columns . ' LIKE \'%' . addslashes($value) . '%\'';
+
+		return $this;
+	}
+
+	/**
+	 * @param string $columns
+	 * @param string $value
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function whereLeftLike(string $columns, string $value): static
+	{
+		if (empty($columns) || empty($value)) {
+			return $this;
+		}
+
+		if (is_array($columns)) {
+			$columns = 'CONCAT(' . implode(',^,', $columns) . ')';
+		}
+
+		$this->where[] = $columns . ' LLike \'%' . addslashes($value) . '\'';
+
+		return $this;
+	}
+
+	/**
+	 * @param string $columns
+	 * @param string $value
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function whereRightLike(string $columns, string $value): static
+	{
+		if (empty($columns) || empty($value)) {
+			return $this;
+		}
+
+		if (is_array($columns)) {
+			$columns = 'CONCAT(' . implode(',^,', $columns) . ')';
+		}
+
+		$this->where[] = $columns . ' RLike \'' . addslashes($value) . '%\'';
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $columns
+	 * @param string $value
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function whereNotLike(string $columns, string $value): static
+	{
+		if (empty($columns) || empty($value)) {
+			return $this;
+		}
+
+		if (is_array($columns)) {
+			$columns = 'CONCAT(' . implode(',^,', $columns) . ')';
+		}
+
+		$this->where[] = $columns . ' NOT LIKE \'%' . addslashes($value) . '%\'';
+
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereEq(string $column, int $value): static
+	{
+		$this->where[] = ['EQ', $column, $value];
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereNeq(string $column, int $value): static
+	{
+		$this->where[] = ['NEQ', $column, $value];
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereGt(string $column, int $value): static
+	{
+		$this->where[] = ['GT', $column, $value];
+
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereEgt(string $column, int $value): static
+	{
+		$this->where[] = ['EGT', $column, $value];
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereLt(string $column, int $value): static
+	{
+		$this->where[] = ['LT', $column, $value];
+
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $value
+	 * @return $this
+	 * @throws Exception
+	 * @see MathematicsCondition
+	 */
+	public function whereElt(string $column, int $value): static
+	{
+		$this->where[] = ['ELT', $column, $value];
+
+		return $this;
+	}
+
+	/**
+	 * @param string $columns
+	 * @param array|Closure $value
+	 * @return $this
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function whereIn(string $columns, array|Closure $value): static
+	{
+		if ($value instanceof Closure) {
+			$value = $this->makeClosureFunction($value);
+		}
+		if (empty($value)) {
+			$value = [-1];
+		}
+		$this->where[] = ['IN', $columns, $value];
+		return $this;
+	}
+
+
+	/**
+	 * @param $value
+	 * @return ActiveQuery
+	 * @throws Exception
+	 */
+	public function makeNewQuery($value): ActiveQuery
+	{
+		$activeQuery = new ActiveQuery($this->modelClass);
+		call_user_func($value, $activeQuery);
+		if (empty($activeQuery->from)) {
+			$activeQuery->from($activeQuery->modelClass::getTable());
+		}
+		return $activeQuery;
+	}
+
+
+	/**
+	 * @return Query
+	 * @throws ReflectionException
+	 * @throws NotFindClassException
+	 */
+	public function makeNewSqlGenerate(): Query
+	{
+		return Kiri::createObject(['class' => Query::class]);
+	}
+
+
+	/**
+	 * @param string $columns
+	 * @param array $value
+	 * @return $this
+	 */
+	public function whereNotIn(string $columns, array $value): static
+	{
+		if (empty($value) || !is_array($value)) {
+			$value = [-1];
+		}
+		$this->where[] = ['NOT IN', $columns, $value];
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $start
+	 * @param int $end
+	 * @return $this
+	 */
+	public function whereBetween(string $column, int $start, int $end): static
+	{
+		if (empty($column) || empty($start) || empty($end)) {
+			return $this;
+		}
+
+		$this->where[] = $column . ' BETWEEN ' . $start . ' AND ' . $end;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $column
+	 * @param int $start
+	 * @param int $end
+	 * @return $this
+	 */
+	public function whereNotBetween(string $column, int $start, int $end): static
+	{
+		if (empty($column) || empty($start) || empty($end)) {
+			return $this;
+		}
+
+		$this->where[] = $column . 'NOT BETWEEN' . $start . ' AND ' . $end;
+
+		return $this;
+	}
+
+	/**
+	 * @param array $params
+	 *
+	 * @return $this
+	 */
+	public function bindParams(array $params = []): static
+	{
+		if (empty($params)) {
+			return $this;
+		}
+		$this->attributes = $params;
+		return $this;
+	}
+
+	/**
+	 * @param Closure|array|string $column
+	 * @param string $opera
+	 * @param null $value
+	 * @return $this
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 */
+	public function where(Closure|array|string $column, string $opera = '=', $value = null): static
+	{
+		if (is_array($column)) {
+			return $this->addArray($column);
+		}
+		if ($column instanceof Closure) {
+			$this->where[] = $this->makeClosureFunction($column);
+			return $this;
+		}
+		[$column, $opera, $value] = $this->opera(...func_get_args());
+		$this->where[] = "$column $opera $value";
+		return $this;
+	}
+
+
+	/**
+	 * @param Closure|array $closure
+	 * @return string
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public function makeClosureFunction(Closure|array $closure): string
+	{
+		$generate = $this->makeNewSqlGenerate();
+		if ($closure instanceof Closure) {
+			call_user_func($closure, $generate);
+		} else {
+			$generate->where($closure);
+		}
+		return $generate->getSql();
+	}
+
+
+	/**
+	 * @param string $name
+	 * @param string|null $having
+	 *
+	 * @return $this
+	 */
+	public function groupBy(string $name, string $having = NULL): static
+	{
+		$this->group = $name;
+		if (empty($having)) {
+			return $this;
+		}
+		$this->group .= ' HAVING ' . $having;
+		return $this;
+	}
+
+	/**
+	 * @param int $offset
+	 * @param int $limit
+	 *
+	 * @return $this
+	 */
+	public function limit(int $offset, int $limit = 20): static
+	{
+		$this->offset = $offset;
+		$this->limit = $limit;
+		return $this;
+	}
+
+
+	/**
+	 * @return array
+	 */
+	private function opera(): array
+	{
+		if (func_num_args() == 3) {
+			[$column, $opera, $value] = func_get_args();
+		} else {
+			[$column, $value] = func_get_args();
+		}
+		if (!isset($opera)) {
+			$opera = '=';
+		}
+		return [$column, $opera, $value];
+	}
+
+
+	/**
+	 * @param array $array
+	 * @return $this
+	 */
+	private function addArray(array $array): static
+	{
+		foreach ($array as $key => $value) {
+			if (is_numeric($key)) {
+				[$column, $opera, $value] = $this->opera(...$value);
+
+				$this->where[] = $this->sprintf($column, $value, $opera);
+			} else {
+				$this->where[] = $this->sprintf($key, $value);
+			}
+		}
+		return $this;
+	}
+
+
+	/**
+	 * @param $column
+	 * @param $value
+	 * @param string $opera
+	 * @return string
+	 */
+	private function sprintf($column, $value, string $opera = '='): string
+	{
+		if (is_string($value)) {
+			$value = trim($value, '\'"');
+		}
+		return "$column $opera '$value'";
+	}
+
+
+	/**
+	 * @return $this
+	 */
+	public function oneLimit(): static
+	{
+		$this->limit = 1;
+		return $this;
+	}
+
+}

src/Traits/When.php

@@ -0,0 +1,77 @@
+<?php
+
+
+namespace Database\Traits;
+
+
+use Database\ActiveQuery;
+use Database\ISqlBuilder;
+use Exception;
+use JetBrains\PhpStorm\Pure;
+
+
+/**
+ * Class CaseWhen
+ * @package Database\Traits
+ */
+class When
+{
+
+	public ActiveQuery|ISqlBuilder $query;
+
+
+	private array $_condition = [];
+
+	private string $else = '';
+
+
+	/**
+	 * CaseWhen constructor.
+	 * @param string $column
+	 * @param ActiveQuery|ISqlBuilder $activeQuery
+	 */
+	public function __construct(public string $column, public ActiveQuery|ISqlBuilder $activeQuery)
+	{
+		$this->_condition[] = 'CASE ' . $column;
+	}
+
+
+	/**
+	 * @param string|int $condition
+	 * @param string $then
+	 * @return $this
+	 * @throws Exception
+	 */
+	public function when(string|int $condition, string $then): static
+	{
+		$this->_condition[] = sprintf('WHEN %s THEN %s', $condition, $then);
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $alias
+	 */
+	public function else(string $alias)
+	{
+		$this->else = $alias;
+	}
+
+
+	/**
+	 * @return string
+	 */
+	#[Pure] public function end(): string
+	{
+		if (empty($this->_condition)) {
+			return '';
+		}
+		$prefix = implode(' ', $this->_condition);
+		if (!empty($this->else)) {
+			$prefix .= ' ELSE ' . $this->else;
+		}
+		return '(' . $prefix . ' END)';
+	}
+
+}