1

.phpstorm.meta.php

@@ -6,7 +6,7 @@ namespace PHPSTORM_META {
 	use Kiri\Di\Container;
 
 	override(Container::get(0), map('@'));
-	override(Container::newObject(0), map('@'));
+	override(Container::create(0), map('@'));
 //    override(\Hyperf\Utils\Context::get(0), map('@'));
 //    override(\make(0), map('@'));
     override(\di(0), map('@'));

composer.json

@@ -1,5 +1,5 @@
 {
-  "name": "game-worker/db-connection",
+  "name": "game-worker/kiri-databases",
   "description": "db",
   "authors": [
     {
@@ -12,8 +12,8 @@
     "php": ">=8.0",
     "ext-json": "*",
     "ext-pdo": "*",
-    "game-worker/snowflake": "dev-master",
+    "game-worker/kiri-validator": "^v1.2",
-    "game-worker/validator": "dev-master"
+    "game-worker/kiri-event": "^v1.0"
   },
   "autoload": {
     "psr-4": {

src/ActiveQuery.php

@@ -118,21 +118,21 @@ class ActiveQuery extends Component implements ISqlBuilder
 	 */
 	public function execute($sql, array $params = []): Command
 	{
-		return $this->modelClass::getDb()->createCommand($sql, $params);
+		return $this->modelClass->getConnection()->createCommand($sql, $params);
 	}
 
 
 	/**
-	 * @return ActiveRecord|null
+	 * @return ModelInterface|null
 	 * @throws Exception
 	 */
-	public function first(): ActiveRecord|null
+	public function first(): ModelInterface|null
 	{
 		$data = $this->execute($this->builder->one())->one();
 		if (empty($data)) {
 			return NULL;
 		}
-		return $this->modelClass::populate($data);
+		return $this->populate($data);
 	}
 
 
@@ -198,7 +198,9 @@ class ActiveQuery extends Component implements ISqlBuilder
 	public function all(): Collection|array
 	{
 		$data = $this->execute($this->builder->all())->all();
-
+		if (!empty($this->with)){
+			$this->getWith($this->modelClass);
+		}
 		$collect = new Collection($this, $data, $this->modelClass);
 		if ($this->asArray) {
 			return $collect->toArray();
@@ -207,22 +209,21 @@ class ActiveQuery extends Component implements ISqlBuilder
 	}
 
 	/**
-	 * @param ActiveRecord $model
 	 * @param $data
-	 * @return ActiveRecord
+	 * @return ModelInterface
 	 * @throws Exception
 	 */
-	public function populate(ActiveRecord $model, $data): ActiveRecord
+	public function populate($data): ModelInterface
 	{
-		return $this->getWith($model::populate($data));
+		return $this->getWith($this->modelClass::populate($data));
 	}
 
 
 	/**
-	 * @param ActiveRecord $model
+	 * @param ModelInterface $model
-	 * @return ActiveRecord
+	 * @return ModelInterface
 	 */
-	public function getWith(ActiveRecord $model): ActiveRecord
+	public function getWith(ModelInterface $model): ModelInterface
 	{
 		if (empty($this->with) || !is_array($this->with)) {
 			return $model;
@@ -236,7 +237,6 @@ class ActiveQuery extends Component implements ISqlBuilder
 	 */
 	public function count(): int
 	{
-		$this->select = ['COUNT(*)'];
 		$data = $this->execute($this->builder->count())->one();
 		if ($data && is_array($data)) {
 			return (int)array_shift($data);
@@ -269,7 +269,7 @@ class ActiveQuery extends Component implements ISqlBuilder
 		[$sql, $params] = $this->builder->insert($data, true);
 
 
-		return $this->execute($sql, $params)->exec(null, true);
+		return $this->execute($sql, $params)->exec();
 	}
 
 	/**
@@ -295,10 +295,10 @@ class ActiveQuery extends Component implements ISqlBuilder
 
 	/**
 	 * @param bool $getSql
-	 * @return string|bool
+	 * @return int|bool|string|null
 	 * @throws Exception
 	 */
-	public function delete(bool $getSql = false): string|bool
+	public function delete(bool $getSql = false): int|bool|string|null
 	{
 		$sql = $this->builder->delete();
 		if ($getSql === false) {

src/Annotation/Get.php

@@ -26,13 +26,15 @@ use Exception;
 	}
 
 
-	/**
+    /**
-	 * @param mixed $class
+     * @param static $params
-	 * @param mixed|null $method
+     * @param mixed $class
-	 * @return bool
+     * @param mixed|null $method
-	 * @throws Exception
+     * @return bool
-	 */
+     * @throws \Kiri\Exception\NotFindClassException
-	public function execute(mixed $class, mixed $method = null): bool
+     * @throws \ReflectionException
+     */
+    public function execute(mixed $class, mixed $method = null): bool
 	{
 		di(Getter::class)->addGetter($this->name, $class, $method);
 		return true;

src/Annotation/Relation.php

@@ -5,11 +5,8 @@ namespace Database\Annotation;
 
 
 use Annotation\Attribute;
-use Database\ActiveRecord;
 use Database\Base\Relate;
 use Exception;
-use JetBrains\PhpStorm\Pure;
-use Kiri\Kiri;
 
 
 /**
@@ -35,10 +32,10 @@ use Kiri\Kiri;
 	 * @return bool
 	 * @throws Exception
 	 */
-    public function execute(mixed $class, mixed $method = null): bool
+	public function execute(mixed $class, mixed $method = null): bool
 	{
-        di(Relate::class)->addRelate($class, $this->name, $method);
+		di(Relate::class)->addRelate($this->name, $class, $method);
-        return true;
+		return true;
 	}
 
 }

src/Annotation/Set.php

@@ -22,10 +22,12 @@ use Exception;
 
 
     /**
+     * @param static $params
      * @param mixed $class
      * @param mixed|null $method
      * @return bool
-     * @throws Exception
+     * @throws \Kiri\Exception\NotFindClassException
+     * @throws \ReflectionException
      */
     public function execute(mixed $class, mixed $method = null): bool
 	{

src/Base/AbstractCollection.php

@@ -12,27 +12,26 @@ namespace Database\Base;
 
 use ArrayIterator;
 use Database\ActiveQuery;
-use Database\ActiveRecord;
+use Database\ModelInterface;
-use Database\ObjectToArray;
+use Kiri\ToArray;
 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, ObjectToArray
+abstract class AbstractCollection extends Component implements \IteratorAggregate, \ArrayAccess, ToArray
 {
 
     /**
-     * @var ActiveRecord[]
+     * @var ModelInterface[]
      */
     protected array $_item = [];
 
-    protected ActiveRecord|string|null $model;
+    protected ModelInterface|string|null $model;
 
     protected ActiveQuery $query;
 
@@ -43,19 +42,19 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     }
 
 
-    /**
+	/**
-     * Collection constructor.
+	 * Collection constructor.
-     *
+	 *
-     * @param $query
+	 * @param $query
-     * @param array $array
+	 * @param array $array
-     * @param string|ActiveRecord|null $model
+	 * @param ModelInterface|null $model
-     * @throws Exception
+	 * @throws Exception
-     */
+	 */
-    public function __construct($query, array $array = [], string|ActiveRecord $model = null)
+    public function __construct($query, array $array = [], ModelInterface $model = null)
     {
         $this->_item = $array;
         $this->query = $query;
-        $this->model = duplicate($model);
+        $this->model = $model;
 
         parent::__construct([]);
     }
@@ -109,7 +108,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
      * @return mixed
      * @throws Exception
      */
-    public function getModel(): ActiveRecord
+    public function getModel(): ModelInterface
     {
         return $this->model;
     }
@@ -126,16 +125,16 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
 
     /**
      * @param mixed $offset
-     * @return ActiveRecord|null
+     * @return ModelInterface|null
      * @throws Exception
      */
-    public function offsetGet(mixed $offset): ?ActiveRecord
+    public function offsetGet(mixed $offset): ?ModelInterface
     {
         if (!$this->offsetExists($offset)) {
             return NULL;
         }
-        if (!($this->_item[$offset] instanceof ActiveRecord)) {
+        if (!($this->_item[$offset] instanceof ModelInterface)) {
-            return $this->model->setAttributes($this->_item[$offset]);
+            return $this->model->populates($this->_item[$offset]);
         }
         return $this->_item[$offset];
     }

src/Base/CollectionIterator.php

@@ -6,7 +6,7 @@ namespace Database\Base;
 
 
 use Database\ActiveQuery;
-use Database\ActiveRecord;
+use Database\ModelInterface;
 use Exception;
 
 
@@ -17,14 +17,14 @@ use Exception;
 class CollectionIterator extends \ArrayIterator
 {
 
-	private ActiveRecord|string $model;
+	private ModelInterface|string $model;
 
 
 	/** @var ActiveQuery */
 	private ActiveQuery $query;
 
 
-	private ?ActiveRecord $_clone = null;
+	private ?ModelInterface $_clone = null;
 
 
 	public function clean()
@@ -51,24 +51,24 @@ class CollectionIterator extends \ArrayIterator
 
 	/**
 	 * @param $current
-	 * @return ActiveRecord
+	 * @return ModelInterface
 	 * @throws Exception
 	 */
-	protected function newModel($current): ActiveRecord
+	protected function newModel($current): ModelInterface
 	{
-		return $this->model->setAttributes($current);
+		return $this->model->populates($current);
 	}
 
 
 	/**
 	 * @throws Exception
 	 */
-	public function current(): ActiveRecord
+	public function current(): ModelInterface
 	{
 		if (is_array($current = parent::current())) {
 			$current = $this->newModel($current);
 		}
-		return $this->query->getWith($current);
+		return $current;
 	}
 
 

src/Base/Model.php

@@ -9,32 +9,29 @@ declare(strict_types=1);
 
 namespace Database\Base;
 
+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.');
+
 
-use Annotation\Event;
-use Annotation\Inject;
 use ArrayAccess;
 use Closure;
 use Database\ActiveQuery;
-use Database\ActiveRecord;
 use Database\Connection;
 use Database\HasMany;
 use Database\HasOne;
-use Database\IOrm;
+use Database\ModelInterface;
 use Database\Mysql\Columns;
-use Database\ObjectToArray;
 use Database\Relation;
 use Database\SqlBuilder;
 use Database\Traits\HasBase;
 use Exception;
 use JetBrains\PhpStorm\Pure;
 use Kiri\Abstracts\Component;
-use Kiri\Abstracts\Config;
-use Kiri\Abstracts\TraitApplication;
 use Kiri\Application;
 use Kiri\Events\EventDispatch;
-use Kiri\Exception\ConfigException;
 use Kiri\Exception\NotFindClassException;
 use Kiri\Kiri;
+use Kiri\ToArray;
 use ReflectionException;
 use validator\Validator;
 
@@ -44,25 +41,18 @@ use validator\Validator;
  * @package Kiri\Abstracts
  *
  * @property bool $isCreate
- * @method rules()
- * @method static tableName()
  * @property Application $container
  * @property EventDispatch $eventDispatch
+ * @property array $attributes
+ * @property array $oldAttributes
  */
-abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess, ObjectToArray
+abstract class Model extends Component implements ModelInterface, ArrayAccess, ToArray
 {
 
-
-	use TraitApplication;
-
-
-	const AFTER_SAVE = 'after::save';
-	const BEFORE_SAVE = 'before::save';
-
-
 	const GET = 'get';
+
+
 	const SET = 'set';
-	const RELATE = 'RELATE';
 
 	/** @var array */
 	protected array $_attributes = [];
@@ -94,15 +84,16 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	protected array $actions = [];
 
 
-	/** @var string */
+	/**
-	private static string $connection = 'db';
+	 * @var string
+	 */
+	protected string $table = '';
 
 
 	/**
-	 * @var Relation|null
+	 * @var string
 	 */
-	#[Inject(Relation::class)]
+	protected string $connection = 'db';
-	protected ?Relation $_relation;
 
 
 	/**
@@ -121,19 +112,26 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 
 	/**
-	 * @param string $name
+	 * @return array
-	 * @param mixed $value
-	 * @return mixed
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
 	 */
+	public function rules(): array
+	{
+		return [];
+	}
+
+
+    /**
+     * @param string $name
+     * @param mixed $value
+     * @return mixed
+     */
 	private function _setter(string $name, mixed $value): mixed
 	{
 		$method = di(Setter::class)->getSetter(static::class, $name);
 		if (!empty($method)) {
 			$value = $this->{$method}($value);
 		}
-		return $this->_attributes[$name] = $value;
+		return $value;
 	}
 
 
@@ -178,8 +176,6 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 	/**
 	 * @return EventDispatch
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
 	 */
 	protected function getEventDispatch(): EventDispatch
 	{
@@ -189,7 +185,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 	/**
 	 * @param $data
-	 * @return ActiveRecord
+	 * @return Model
 	 */
 	public function setWith($data): static
 	{
@@ -220,15 +216,6 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	}
 
 
-	/**
-	 * @param Relation $relation
-	 */
-	public function setRelation(Relation $relation)
-	{
-		$this->_relation = $relation;
-	}
-
-
 	/**
 	 * @throws Exception
 	 */
@@ -268,11 +255,11 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	}
 
 	/**
-	 * @return mixed
+	 * @return string
 	 * @throws Exception
 	 * get last exception or other error
 	 */
-	public function getLastError(): mixed
+	public function getLastError(): string
 	{
 		return Kiri::app()->getLogger()->getLastError('mysql');
 	}
@@ -287,7 +274,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if ($this->primary !== NULL) {
 			return true;
 		}
-		$primary = static::getColumns()->getPrimaryKeys();
+		$primary = $this->getColumns()->getPrimaryKeys();
 		if (!empty($primary)) {
 			return $this->primary = is_array($primary) ? current($primary) : $primary;
 		}
@@ -308,7 +295,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function getAutoIncrement(): int|string|null
 	{
-		return static::getColumns()->getAutoIncrement();
+		return $this->getColumns()->getAutoIncrement();
 	}
 
 	/**
@@ -338,7 +325,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	/**
 	 * @param $param
 	 * @param null $db
-	 * @return BaseActiveRecord|null
+	 * @return Model|null
 	 * @throws NotFindClassException
 	 * @throws ReflectionException
 	 * @throws Exception
@@ -351,7 +338,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (is_numeric($param)) {
 			$param = static::getPrimaryCondition($param);
 		}
-		return static::find()->where($param)->first();
+		return static::query()->where($param)->first();
 	}
 
 
@@ -362,7 +349,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	private static function getPrimaryCondition($param): array
 	{
-		$primary = static::getColumns()->getPrimaryKeys();
+		$primary = static::makeNewInstance()->getColumns()->getPrimaryKeys();
 		if (empty($primary)) {
 			throw new Exception('Primary key cannot be empty.');
 		}
@@ -375,13 +362,13 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 	/**
 	 * @param null $field
-	 * @return ActiveRecord|null
+	 * @return ModelInterface|null
 	 * @throws Exception
 	 * @throws Exception
 	 */
-	public static function max($field = null): ?ActiveRecord
+	public static function max($field = null): ?ModelInterface
 	{
-		$columns = static::getColumns();
+		$columns = static::makeNewInstance()->getColumns();
 		if (empty($field)) {
 			$field = $columns->getFirstPrimary();
 		}
@@ -389,7 +376,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (!isset($columns[$field])) {
 			return null;
 		}
-		$first = static::find()->max($field)->first();
+		$first = static::query()->max($field)->first();
 		if (empty($first)) {
 			return null;
 		}
@@ -398,11 +385,41 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 
 	/**
-	 * @return ActiveQuery
+	 * @param string|int $param
+	 * @return Model|null
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
 	 */
-	public static function find(): ActiveQuery
+	public static function find(string|int $param): ?static
 	{
-		return static::query();
+		$columns = duplicate(static::class)->getPrimary();
+		if (empty($columns)) {
+			$columns = static::makeNewInstance()->getColumns()->getFirstPrimary();
+		}
+		return static::query()->where([$columns => $param])->first();
+	}
+
+
+	/**
+	 * @return static
+	 */
+	private static function makeNewInstance(): static
+	{
+		return duplicate(static::class);
+	}
+
+
+	/**
+	 * @param $condition
+	 * @return static|null
+	 * @throws NotFindClassException
+	 * @throws ReflectionException
+	 * @throws Exception
+	 */
+	public static function first($condition): ?static
+	{
+		return static::query()->where($condition)->first();
 	}
 
 
@@ -411,16 +428,16 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public static function query(): ActiveQuery
 	{
-		return new ActiveQuery(get_called_class());
+		return new ActiveQuery(new static());
 	}
 
 
 	/**
-	 * @throws ConfigException
+	 * @return Connection
 	 */
-	protected function getConnection()
+	public function getConnection(): Connection
 	{
-		return Config::get('connections.' . static::$connection, null, true);
+		return Kiri::app()->get('db')->get($this->connection);
 	}
 
 
@@ -438,13 +455,13 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 			if (!$if_condition_is_null) {
 				return false;
 			}
-			return static::find()->delete();
+			return (bool)static::query()->delete();
 		}
-		$model = static::find()->ifNotWhere($if_condition_is_null)->where($condition);
+		$model = static::query()->ifNotWhere($if_condition_is_null)->where($condition);
 		if (!empty($attributes)) {
 			$model->bindParams($attributes);
 		}
-		return $model->delete();
+		return (bool)$model->delete();
 	}
 
 
@@ -472,7 +489,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function setAttribute($name, $value): mixed
 	{
-		return $this->_attributes[$name] = $value;
+		return $this->_attributes[$name] = $this->_setter($name, $value);
 	}
 
 	/**
@@ -482,7 +499,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function setOldAttribute($name, $value): mixed
 	{
-		return $this->_oldAttributes[$name] = $value;
+		return $this->_oldAttributes[$name] = $this->_setter($name, $value);
 	}
 
 	/**
@@ -495,7 +512,9 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (empty($param)) {
 			return $this;
 		}
-		$this->_attributes = array_merge($this->_attributes, $param);
+        foreach ($param as $key => $attribute) {
+            $this->setAttribute($key, $attribute);
+        }
 		return $this;
 	}
 
@@ -508,10 +527,10 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (empty($param) || !is_array($param)) {
 			return $this;
 		}
-		foreach ($param as $key => $val) {
+        foreach ($param as $key => $attribute) {
-			$this->setOldAttribute($key, $val);
+            $this->setOldAttribute($key, $attribute);
-		}
+        }
-		return $this;
+        return $this;
 	}
 
 	/**
@@ -522,12 +541,12 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	private function insert($param, $attributes): bool|static
 	{
-		[$sql, $param] = SqlBuilder::builder(static::find())->insert($param);
+		[$sql, $param] = SqlBuilder::builder(static::query())->insert($param);
-		$dbConnection = static::getDb()->createCommand($sql, $param);
+		$dbConnection = $this->getConnection()->createCommand($sql, $param);
-		if (!($lastId = (int)$dbConnection->save(true, $this))) {
+
-			throw new Exception('保存失败.');
+		$lastId = $dbConnection->save(true);
-		}
+
-		$lastId = $this->setPrimary($lastId, $param);
+		$lastId = $this->setPrimary((int)$lastId, $param);
 
 		$this->refresh()->afterSave($attributes, $param);
 
@@ -556,7 +575,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (!isset($param[$primary]) || empty($param[$primary])) {
 			$this->setAttribute($primary, (int)$lastId);
 		}
-		return $this->setAttributes($param);
+		return $this;
 	}
 
 
@@ -575,11 +594,11 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if ($this->hasPrimary()) {
 			$condition = [$this->getPrimary() => $this->getPrimaryValue()];
 		}
-		$generate = SqlBuilder::builder(static::find()->where($condition))->update($param);
+		$generate = SqlBuilder::builder(static::query()->where($condition))->update($param);
 		if (is_bool($generate)) {
 			return $generate;
 		}
-		$command = static::getDb()->createCommand($generate[0], $generate[1]);
+		$command = $this->getConnection()->createCommand($generate[0], $generate[1]);
 		if ($command->save(false, $this)) {
 			return $this->refresh()->afterSave($fields, $param);
 		}
@@ -593,7 +612,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function save($data = NULL): static|bool
 	{
-		if (!is_null($data)) {
+        if (!is_null($data)) {
 			$this->_attributes = merge($this->_attributes, $data);
 		}
 		if (!$this->validator($this->rules()) || !$this->beforeSave($this)) {
@@ -607,17 +626,30 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	}
 
 
+    /**
+     * @param $value
+     * @return $this
+     */
+    public function populates($value): static
+    {
+        $this->_attributes = $value;
+        $this->_oldAttributes = $value;
+        $this->setIsCreate(FALSE);
+        return $this;
+    }
+
+
 	/**
-	 * @param array $rule
+	 * @param array|null $rule
 	 * @return bool
 	 * @throws Exception
 	 */
-	public function validator(array $rule): bool
+	public function validator(?array $rule): bool
 	{
 		if (empty($rule)) return true;
 		$validate = $this->resolve($rule);
 		if (!$validate->validation()) {
-			return $this->addError($validate->getError(), 'mysql');
+			return $this->addError('$validate->getError()', 'mysql');
 		} else {
 			return TRUE;
 		}
@@ -752,7 +784,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function getRelation(): ?Relation
 	{
-		return $this->_relation;
+		return Kiri::getDi()->get(Relation::class);
 	}
 
 
@@ -774,26 +806,26 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function has($attribute): bool
 	{
-		return static::getColumns()->hasField($attribute);
+		return static::makeNewInstance()->getColumns()->hasField($attribute);
 	}
 
 	/**ƒ
 	 * @return string
 	 * @throws Exception
 	 */
-	public static function getTable(): string
+	public function getTable(): string
 	{
-		$tablePrefix = static::getDb()->tablePrefix;
+		$connection = static::getConnection();
 
-		$table = static::tableName();
+		$tablePrefix = $connection->tablePrefix;
-		if (empty($table)) {
+		if (empty($this->table)) {
 			throw new Exception('You need add static method `tableName` and return table name.');
 		}
-		$table = trim($table, '{{%}}');
+		$table = trim($this->table, '{{%}}');
-		if (!empty($tablePrefix) && !str_starts_with($table, $tablePrefix)) {
+		if (!empty($tablePrefix) && !str_starts_with($this->table, $tablePrefix)) {
-			$table = $tablePrefix . $table;
+			$table = $tablePrefix . $this->table;
 		}
-		return '`' . static::getDbName() . '`.' . $table;
+		return '`' . $connection->database . '`.' . $table;
 	}
 
 
@@ -803,7 +835,6 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 * @return bool
 	 * @throws Exception
 	 */
-	#[Event(self::AFTER_SAVE)]
 	public function afterSave($attributes, $changeAttributes): bool
 	{
 		return true;
@@ -814,25 +845,12 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 * @param $model
 	 * @return bool
 	 */
-	#[Event(self::BEFORE_SAVE)]
 	public function beforeSave($model): bool
 	{
 		return true;
 	}
 
 
-	private static string $ab_name = '';
-
-
-	/**
-	 * @return Connection
-	 * @throws Exception
-	 */
-	public static function getDb(): Connection
-	{
-		return static::setDatabaseConnect('db');
-	}
-
 	/**
 	 * @return static
 	 */
@@ -852,7 +870,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (method_exists($this, 'set' . ucfirst($name))) {
 			$this->{'set' . ucfirst($name)}($value);
 		} else {
-			$this->_setter($name, $value);
+			$this->_attributes[$name] = $this->_setter($name, $value);
 		}
 	}
 
@@ -882,7 +900,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	private function _decode($name, $value): mixed
 	{
-		return static::getColumns()->_decode($name, $value);
+		return $this->getColumns()->_decode($name, $value);
 	}
 
 
@@ -1024,36 +1042,14 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	}
 
 
-	/**
-	 * @param $dbName
-	 * @return mixed
-	 * @throws Exception
-	 */
-	public static function setDatabaseConnect($dbName): Connection
-	{
-		return Kiri::app()->get('db')->get(static::$connection = $dbName);
-	}
-
-
-	/**
-	 * @return string
-	 * @throws ConfigException
-	 */
-	public static function getDbName(): string
-	{
-		return Config::get('databases.connections.' . static::$connection . '.database');
-	}
-
-
 	/**
 	 * @return Columns
 	 * @throws Exception
 	 */
-	public static function getColumns(): Columns
+	public function getColumns(): Columns
 	{
-		return static::getDb()->getSchema()
+		return $this->getConnection()->getSchema()->getColumns()
-			->getColumns()
+			->table($this->getTable());
-			->table(static::getTable());
 	}
 
 	/**
@@ -1083,4 +1079,15 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		};
 	}
 
+
+	/**
+	 * @param string $name
+	 * @param array $arguments
+	 * @return mixed
+	 */
+	public static function __callStatic(string $name, array $arguments)
+	{
+		return (new static())->{$name}(...$arguments);
+	}
+
 }

src/Collection.php

@@ -44,7 +44,7 @@ class Collection extends AbstractCollection
 		$_tmp = [];
 		$data = $this->toArray();
 		foreach ($data as $val) {
-			/** @var ActiveRecord $val */
+			/** @var ModelInterface $val */
 			$_tmp[] = $val[$field];
 		}
 		return $_tmp;
@@ -93,7 +93,7 @@ class Collection extends AbstractCollection
 	}
 
 	/**
-	 * @param        $field
+	 * @param string $field
 	 * @param string $setKey
 	 *
 	 * @return array|null
@@ -126,9 +126,9 @@ class Collection extends AbstractCollection
 	}
 
 	/**
-	 * @return ActiveRecord|array
+	 * @return ModelInterface|array
 	 */
-	#[Pure] public function current(): ActiveRecord|array
+	#[Pure] public function current(): ModelInterface|array
 	{
 		return current($this->_item);
 	}
@@ -148,11 +148,12 @@ class Collection extends AbstractCollection
 	public function toArray(): array
 	{
 		$array = [];
+		/** @var Model $value */
 		foreach ($this as $value) {
 			if (!is_object($value)) {
 				continue;
 			}
-			$array[] = $value->toArray();
+			$array[] = $value->setWith($this->query->with)->toArray();
 		}
 		$this->_item = [];
 		return $array;
@@ -173,7 +174,7 @@ class Collection extends AbstractCollection
 				$ids[] = $id;
 			}
 		}
-		return $model::find()->whereIn($model->getPrimary(), $ids)->delete();
+		return $model::query()->whereIn($model->getPrimary(), $ids)->delete();
 	}
 
 	/**
@@ -206,7 +207,7 @@ class Collection extends AbstractCollection
 	private function filterCheck($value, $condition): bool
 	{
 		$_value = $value;
-		if ($_value instanceof ActiveRecord) {
+		if ($_value instanceof ModelInterface) {
 			$_value = $_value->toArray();
 		}
 		$_tmp = array_intersect_key($_value, $condition);

src/Command.php

@@ -60,7 +60,7 @@ class Command extends Component
 	 */
 	public function save(bool $isInsert = TRUE, mixed $hasAutoIncrement = null): int|bool|array|string|null
 	{
-		return $this->execute(static::EXECUTE, $isInsert, $hasAutoIncrement);
+		return $this->execute(static::EXECUTE);
 	}
 
 
@@ -111,17 +111,15 @@ class Command extends Component
 
 	/**
 	 * @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
+	private function execute($type): int|bool|array|string|null
 	{
 		try {
 			$time = microtime(true);
 			if ($type === static::EXECUTE) {
-				$result = $this->insert_or_change($isInsert, $hasAutoIncrement);
+				$result = $this->db->getConnect($this->sql)->execute($this->sql,$this->params);
 			} else {
 				$result = $this->search($type);
 			}
@@ -139,10 +137,10 @@ class Command extends Component
 
 	/**
 	 * @param $type
-	 * @return array|int
+	 * @return array|int|bool|null
 	 * @throws Exception
 	 */
-	private function search($type): array|int
+	private function search($type): array|int|bool|null
 	{
 		$pdo = $this->db->getConnect($this->sql);
 		if ($type === static::FETCH_COLUMN) {
@@ -158,22 +156,6 @@ class Command extends Component
 	}
 
 
-	/**
-	 * @param $isInsert
-	 * @param $hasAutoIncrement
-	 * @return bool|int
-	 * @throws Exception
-	 */
-	private function insert_or_change($isInsert, $hasAutoIncrement): bool|int
-	{
-		$pdo = $this->db->getConnect($this->sql);
-		$result = $pdo->execute($this->sql, $isInsert, $this->params);
-		if ($hasAutoIncrement && $result == 0) {
-			return false;
-		}
-		return $result;
-	}
-
 	/**
 	 * @return int|bool|array|string|null
 	 * @throws Exception
@@ -184,14 +166,12 @@ class Command extends Component
 	}
 
 	/**
-	 * @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
+	public function exec(): int|bool|array|string|null
 	{
-		return $this->execute(static::EXECUTE, $insert, $scope);
+		return $this->execute(static::EXECUTE);
 	}
 
 	/**

src/Condition/HashCondition.php

@@ -20,9 +20,8 @@ class HashCondition extends Condition
 			return '';
 		}
 		foreach ($this->value as $key => $value) {
-			if ($value === null) {
+			if (is_null($value)) continue;
-				continue;
+
-			}
 			$array[] = sprintf("%s = '%s'", $key, addslashes($value));
 		}
 		return implode(' AND ', $array);

src/Connection.php

@@ -12,21 +12,20 @@ namespace Database;
 
 
 use Annotation\Inject;
+use Database\Affair\BeginTransaction;
+use Database\Affair\Commit;
+use Database\Affair\Rollback;
+use Database\Mysql\PDO;
 use Database\Mysql\Schema;
 use Exception;
-use JetBrains\PhpStorm\Pure;
-use Database\Mysql\PDO;
-use ReflectionException;
-use Server\Events\OnWorkerExit;
-use Server\Events\OnWorkerStop;
 use Kiri\Abstracts\Component;
 use Kiri\Abstracts\Config;
 use Kiri\Events\EventProvider;
 use Kiri\Exception\NotFindClassException;
 use Kiri\Kiri;
-use Database\Affair\BeginTransaction;
+use ReflectionException;
-use Database\Affair\Commit;
+use Server\Events\OnWorkerExit;
-use Database\Affair\Rollback;
+use Server\Events\OnWorkerStop;
 
 /**
  * Class Connection
@@ -91,8 +90,8 @@ class Connection extends Component
 		$this->eventProvider->on(Commit::class, [$this, 'commit'], 0);
 
 		if (Db::transactionsActive()) {
-		    $this->beginTransaction();
+			$this->beginTransaction();
-        }
+		}
 
 		$this->_schema->db = $this;
 	}
@@ -109,6 +108,17 @@ class Connection extends Component
 	}
 
 
+	/**
+	 * @param $config
+	 * @return $this
+	 */
+	public function configure($config): static
+	{
+		Kiri::configure($this, $config);
+		return $this;
+	}
+
+
 	/**
 	 * @throws Exception
 	 */
@@ -142,6 +152,7 @@ class Connection extends Component
 	 * @return mixed
 	 * @throws ReflectionException
 	 * @throws NotFindClassException
+	 * @throws Exception
 	 */
 	public function getSchema(): Schema
 	{
@@ -158,7 +169,7 @@ class Connection extends Component
 	 * @param $sql
 	 * @return bool
 	 */
-	#[Pure] public function isWrite($sql): bool
+	public function isWrite($sql): bool
 	{
 		if (empty($sql)) return false;
 		if (str_starts_with(strtolower($sql), 'select')) {

src/DatabasesProviders.php

@@ -6,13 +6,13 @@ 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;
+use Server\Events\OnWorkerStart;
 
 /**
  * Class DatabasesProviders
@@ -53,11 +53,9 @@ class DatabasesProviders extends Providers
 	 */
 	public function get($name): Connection
 	{
-		$application = Kiri::app();
+		$config = $this->_settings($this->getConfig($name));
-		if (!$application->has('databases.' . $name)) {
+
-			$application->set('databases.' . $name, $this->_settings($this->getConfig($name)));
+		return Kiri::getDi()->get(Connection::class)->configure($config);
-		}
-		return $application->get('databases.' . $name);
 	}
 
 
@@ -71,11 +69,10 @@ class DatabasesProviders extends Providers
 		if (empty($databases)) {
 			return;
 		}
-		$application = Kiri::app();
+		$connection = Kiri::getDi()->get(Connection::class);
-		foreach ($databases as $name => $database) {
+		foreach ($databases as $database) {
 			/** @var Connection $connection */
-			$application->set('databases.' . $name, $this->_settings($database));
+			$connection->configure($database)->fill();
-			$application->get('databases.' . $name)->fill();
 		}
 	}
 

src/HasCount.php

@@ -28,10 +28,10 @@ class HasCount extends HasBase
 	}
 
 	/**
-	 * @return array|null|ActiveRecord
+	 * @return array|null|ModelInterface
 	 * @throws Exception
 	 */
-	public function get(): array|ActiveRecord|null
+	public function get(): array|ModelInterface|null
 	{
 		return $this->_relation->count($this->model::className(), $this->value);
 	}

src/HasMany.php

@@ -34,10 +34,10 @@ class HasMany extends HasBase
 	}
 
 	/**
-	 * @return array|null|ActiveRecord
+	 * @return array|null|ModelInterface
 	 * @throws Exception
 	 */
-	public function get(): array|ActiveRecord|null
+	public function get(): array|ModelInterface|null
 	{
 		return $this->_relation->get($this->model::className(), $this->value);
 	}

src/HasOne.php

@@ -35,10 +35,10 @@ class HasOne extends HasBase
 	}
 
 	/**
-	 * @return array|null|ActiveRecord
+	 * @return array|null|ModelInterface
 	 * @throws Exception
 	 */
-	public function get(): array|ActiveRecord|null
+	public function get(): array|ModelInterface|null
 	{
 		return $this->_relation->first($this->model::className(), $this->value);
 	}

src/IOrm.php

@@ -1,50 +0,0 @@
-<?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/Model.php

@@ -10,12 +10,12 @@ declare(strict_types=1);
 namespace Database;
 
 
-use Database\Base\BaseActiveRecord;
 use Database\Base\Getter;
 use Database\Traits\HasBase;
 use Exception;
 use Kiri\Exception\NotFindClassException;
 use Kiri\Kiri;
+use Kiri\ToArray;
 use ReflectionException;
 
 defined('SAVE_FAIL') or define('SAVE_FAIL', 3227);
@@ -27,29 +27,20 @@ defined('FIND_OR_CREATE_MESSAGE') or define('FIND_OR_CREATE_MESSAGE', 'Create a
  *
  * @property $attributes
  * @property-read $oldAttributes
- * @method beforeSearch($model)
  */
-class ActiveRecord extends BaseActiveRecord
+class Model extends Base\Model
 {
 
 
-	/**
-	 * @return array
-	 */
-	public function rules(): array
-	{
-		return [];
-	}
-
 	/**
 	 * @param string $column
 	 * @param int $value
-	 * @return ActiveRecord|false
+	 * @return ModelInterface|false
 	 * @throws Exception
 	 */
-	public function increment(string $column, int $value): bool|ActiveRecord
+	public function increment(string $column, int $value): bool|ModelInterface
 	{
-		if (!$this->mathematics([$column => $value], '+', null)) {
+		if (!$this->mathematics([$column => $value], '+')) {
 			return false;
 		}
 		$this->{$column} += $value;
@@ -60,12 +51,12 @@ class ActiveRecord extends BaseActiveRecord
 	/**
 	 * @param string $column
 	 * @param int $value
-	 * @return ActiveRecord|false
+	 * @return ModelInterface|false
 	 * @throws Exception
 	 */
-	public function decrement(string $column, int $value): bool|ActiveRecord
+	public function decrement(string $column, int $value): bool|ModelInterface
 	{
-		if (!$this->mathematics([$column => $value], '-', null)) {
+		if (!$this->mathematics([$column => $value], '-')) {
 			return false;
 		}
 		$this->{$column} -= $value;
@@ -75,12 +66,12 @@ class ActiveRecord extends BaseActiveRecord
 
 	/**
 	 * @param array $columns
-	 * @return ActiveRecord|false
+	 * @return ModelInterface|false
 	 * @throws Exception
 	 */
 	public function increments(array $columns): bool|static
 	{
-		if (!$this->mathematics($columns, '+', null)) {
+		if (!$this->mathematics($columns, '+')) {
 			return false;
 		}
 		foreach ($columns as $key => $attribute) {
@@ -92,12 +83,12 @@ class ActiveRecord extends BaseActiveRecord
 
 	/**
 	 * @param array $columns
-	 * @return ActiveRecord|false
+	 * @return ModelInterface|false
 	 * @throws Exception
 	 */
 	public function decrements(array $columns): bool|static
 	{
-		if (!$this->mathematics($columns, '-', null)) {
+		if (!$this->mathematics($columns, '-')) {
 			return false;
 		}
 		foreach ($columns as $key => $attribute) {
@@ -109,28 +100,29 @@ class ActiveRecord extends BaseActiveRecord
 	/**
 	 * @param array $condition
 	 * @param array $attributes
-	 * @return bool|ActiveRecord
+	 * @return bool|ModelInterface
 	 * @throws ReflectionException
 	 * @throws NotFindClassException
 	 * @throws Exception
 	 */
-	public static function findOrCreate(array $condition, array $attributes = []): bool|static
+	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);
+		Db::beginTransaction();
-		$select->attributes = $attributes;
+		/** @var static $select */
-		if (!$select->save()) {
+		$select = static::query()->where($condition)->first();
-			return $logger->addError($select->getLastError(), 'mysql');
+		if (empty($select)) {
+			$select = duplicate(static::class);
+			$select->attributes = $attributes;
+			if (!$select->save()) {
+				Db::rollback();
+				return $logger->addError($select->getLastError(), 'mysql');
+			}
 		}
+		Db::commit();
 		return $select;
 	}
 
@@ -147,14 +139,19 @@ class ActiveRecord extends BaseActiveRecord
 		if (empty($attributes)) {
 			return $logger->addError(FIND_OR_CREATE_MESSAGE, 'mysql');
 		}
+
+		Db::beginTransaction();
 		/** @var static $select */
-		$select = static::find()->where($condition)->first();
+		$select = static::query()->where($condition)->first();
 		if (empty($select)) {
 			$select = duplicate(static::class);
 		}
 		$select->attributes = $attributes;
 		if (!$select->save()) {
-			return $logger->addError($select->getLastError(), 'mysql');
+			Db::rollback();
+			$select = $logger->addError($select->getLastError(), 'mysql');
+		} else {
+			Db::commit();
 		}
 		return $select;
 	}
@@ -167,24 +164,24 @@ class ActiveRecord extends BaseActiveRecord
 	 * @return array|bool|int|string|null
 	 * @throws Exception
 	 */
-	private function mathematics($columns, $action, ?array $condition): int|bool|array|string|null
+	private function mathematics($columns, $action, ?array $condition = null): int|bool|array|string|null
 	{
 		if (empty($condition)) {
 			$condition = [$this->getPrimary() => $this->getPrimaryValue()];
 		}
 
-		$activeQuery = static::find()->where($condition);
+		$activeQuery = static::query()->where($condition);
 		$create = SqlBuilder::builder($activeQuery)->mathematics($columns, $action);
 		if (is_bool($create)) {
 			return false;
 		}
-		return static::getDb()->createCommand($create[0], $create[1])->exec();
+		return $this->getConnection()->createCommand($create[0], $create[1])->exec();
 	}
 
 
 	/**
 	 * @param array $fields
-	 * @return ActiveRecord|bool
+	 * @return ModelInterface|bool
 	 * @throws Exception
 	 */
 	public function update(array $fields): static|bool
@@ -200,12 +197,13 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public static function inserts(array $data): bool
 	{
-		/** @var static $class */
+		$result = false;
-		$class = Kiri::createObject(['class' => static::class]);
 		if (empty($data)) {
-			return $class->addError('Insert data empty.', 'mysql');
+			error('Insert data empty.', 'mysql');
+		} else {
+			$result = static::query()->batchInsert($data);
 		}
-		return $class::find()->batchInsert($data);
+		return $result;
 	}
 
 	/**
@@ -238,24 +236,11 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public static function updateAll(mixed $condition, array $attributes = []): bool
 	{
-		$condition = static::find()->where($condition);
+		$condition = static::query()->where($condition);
 		return $condition->batchUpdate($attributes);
 	}
 
 
-	/**
-	 * @param $condition
-	 * @return ActiveRecord|null
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
-	 * @throws Exception
-	 */
-	public static function first($condition): ?ActiveRecord
-	{
-		return static::query()->where($condition)->first();
-	}
-
-
 	/**
 	 * @param $condition
 	 * @return array|Collection
@@ -277,7 +262,7 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public static function findAll($condition, array $attributes = []): array|Collection
 	{
-		$query = static::find()->where($condition);
+		$query = static::query()->where($condition);
 		if (!empty($attributes)) {
 			$query->bindParams($attributes);
 		}
@@ -289,13 +274,17 @@ class ActiveRecord extends BaseActiveRecord
 	 * @return mixed
 	 * @throws Exception
 	 */
-	private function resolveObject($method): mixed
+	private function withRelation($method): mixed
 	{
-		$resolve = $this->{$this->getRelate($method)}();
+		$method = $this->getRelate($method);
+		if (empty($method)) {
+			return null;
+		}
+		$resolve = $this->{$method}();
 		if ($resolve instanceof HasBase) {
 			$resolve = $resolve->get();
 		}
-		if ($resolve instanceof ObjectToArray) {
+		if ($resolve instanceof ToArray) {
 			return $resolve->toArray();
 		} else if (is_object($resolve)) {
 			return get_object_vars($resolve);
@@ -316,21 +305,21 @@ class ActiveRecord extends BaseActiveRecord
 		foreach ($lists as $key => $item) {
 			$data[$key] = $this->{$item}($data[$key] ?? null);
 		}
-		return array_merge($data, $this->runRelate());
+		return $this->withRelates($data);
 	}
 
 	/**
+	 * @param $relates
 	 * @return array
 	 * @throws Exception
 	 */
-	private function runRelate(): array
+	private function withRelates($relates): array
 	{
-		$relates = [];
 		if (empty($with = $this->getWith())) {
 			return $relates;
 		}
 		foreach ($with as $val) {
-			$relates[$val] = $this->resolveObject($val);
+			$relates[$val] = $this->withRelation($val);
 		}
 		return $relates;
 	}
@@ -345,7 +334,7 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function hasOne(string $modelName, $foreignKey, $localKey): HasOne|ActiveQuery
 	{
-		if (($value = $this->getAttribute($localKey)) === null) {
+		if (($value = $this->{$localKey}) === null) {
 			throw new Exception("Need join table primary key.");
 		}
 
@@ -364,7 +353,7 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function hasCount($modelName, $foreignKey, $localKey): ActiveQuery|HasCount
 	{
-		if (($value = $this->getAttribute($localKey)) === null) {
+		if (($value = $this->{$localKey}) === null) {
 			throw new Exception("Need join table primary key.");
 		}
 
@@ -383,7 +372,7 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function hasMany($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
 	{
-		if (($value = $this->getAttribute($localKey)) === null) {
+		if (($value = $this->{$localKey}) === null) {
 			throw new Exception("Need join table primary key.");
 		}
 
@@ -401,7 +390,7 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function hasIn($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
 	{
-		if (($value = $this->getAttribute($localKey)) === null) {
+		if (($value = $this->{$localKey}) === null) {
 			throw new Exception("Need join table primary key.");
 		}
 
@@ -416,13 +405,6 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function afterDelete(): bool
 	{
-		if (!$this->hasPrimary()) {
-			return TRUE;
-		}
-		$value = $this->getPrimaryValue();
-		if (empty($value)) {
-			return TRUE;
-		}
 		return TRUE;
 	}
 
@@ -432,13 +414,6 @@ class ActiveRecord extends BaseActiveRecord
 	 */
 	public function beforeDelete(): bool
 	{
-		if (!$this->hasPrimary()) {
-			return TRUE;
-		}
-		$value = $this->getPrimaryValue();
-		if (empty($value)) {
-			return TRUE;
-		}
 		return TRUE;
 	}
 }

src/ModelInterface.php

@@ -0,0 +1,61 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/3/30 0030
+ * Time: 14:39
+ */
+declare(strict_types=1);
+
+namespace Database;
+
+
+/**
+ * Interface ModelInterface
+ * @package Database
+ */
+interface ModelInterface
+{
+
+	/**
+	 * @param $param
+	 * @param null $db
+	 * @return ModelInterface
+	 */
+	public static function findOne($param, $db = NULL): mixed;
+
+
+	/**
+	 * @param string|int $param
+	 * @return ModelInterface
+	 */
+	public static function find(string|int $param): mixed;
+
+
+    /**
+     * @param array $data
+     * @return static
+     */
+    public static function populate(array $data): static;
+
+
+	/**
+	 * @return ActiveQuery
+	 * return a sql queryBuilder
+	 */
+	public static function query(): ActiveQuery;
+
+
+	/**
+	 * @return string
+	 */
+	public function getTable(): string;
+
+
+	/**
+	 * @return Connection
+	 */
+	public function getConnection(): Connection;
+
+
+}

src/Mysql/Columns.php

@@ -316,7 +316,7 @@ class Columns extends Component
 
 
 	/**
-	 * @param $column
+	 * @param array $column
 	 * @param $table
 	 * @return array
 	 */

src/Mysql/PDO.php

@@ -3,12 +3,11 @@
 namespace Database\Mysql;
 
 use Exception;
-use Http\Context\Context;
+use Kiri\Abstracts\Logger;
-use Kiri\Events\EventProvider;
+use Kiri\Context;
 use Kiri\Kiri;
 use Kiri\Pool\StopHeartbeatCheck;
 use PDOStatement;
-use Server\Events\OnWorkerExit;
 use Swoole\Timer;
 
 /**
@@ -26,11 +25,6 @@ class PDO implements StopHeartbeatCheck
 	private int $_transaction = 0;
 
 
-	/**
-	 * @var EventProvider
-	 */
-	private EventProvider $eventProvider;
-
 	private int $_timer = -1;
 
 	private int $_last = 0;
@@ -47,14 +41,12 @@ class PDO implements StopHeartbeatCheck
 	public function __construct(public string $dbname, public string $cds,
 	                            public string $username, public string $password, public string $chatset = 'utf8mb4')
 	{
-		$this->eventProvider = Kiri::getDi()->get(EventProvider::class);
 	}
 
 
 	public function init()
 	{
 		$this->heartbeat_check();
-		$this->eventProvider->on(OnWorkerExit::class, [$this, 'stopHeartbeatCheck']);
 	}
 
 
@@ -72,14 +64,15 @@ class PDO implements StopHeartbeatCheck
 	 */
 	public function heartbeat_check(): void
 	{
-		if (env('state') == 'exit') {
+		if (env('state', 'start') == 'exit') {
 			return;
 		}
 		if ($this->_timer === -1 && Context::inCoroutine()) {
 			$this->_timer = Timer::tick(1000, function () {
 				try {
-					if (env('state') == 'exit') {
+					if (env('state', 'start') == 'exit') {
-						echo 'timer end.' . PHP_EOL;
+						Kiri::getDi()->get(Logger::class)->critical('timer end');
+						$this->stopHeartbeatCheck();
 					}
 					if (time() - $this->_last > 10 * 60) {
 						$this->stopHeartbeatCheck();
@@ -144,48 +137,48 @@ class PDO implements StopHeartbeatCheck
 	/**
 	 * @param string $sql
 	 * @param array $params
-	 * @return array
+	 * @return bool|array|null
 	 * @throws Exception
 	 */
-	public function fetchAll(string $sql, array $params = []): array
+	public function fetchAll(string $sql, array $params = []): bool|null|array
 	{
 		$pdo = $this->queryPrev($sql, $params);
 
-		defer(fn() => $pdo->closeCursor());
+		$result = $pdo->fetchAll(\PDO::FETCH_ASSOC);
-
+		$pdo->closeCursor();
-		return $pdo->fetchAll(\PDO::FETCH_ASSOC);
+		return $result;
 	}
 
 
 	/**
 	 * @param string $sql
 	 * @param array $params
-	 * @return array
+	 * @return bool|array|null
 	 * @throws Exception
 	 */
-	public function fetch(string $sql, array $params = []): array
+	public function fetch(string $sql, array $params = []): bool|null|array
 	{
 		$pdo = $this->queryPrev($sql, $params);
 
-		defer(fn() => $pdo->closeCursor());
+		$result = $pdo->fetch(\PDO::FETCH_ASSOC);
-
+		$pdo->closeCursor();
-		return $pdo->fetch(\PDO::FETCH_ASSOC);
+		return $result;
 	}
 
 
 	/**
 	 * @param string $sql
 	 * @param array $params
-	 * @return array
+	 * @return bool|array|null
-	 * @throws Exception
+	 * @throws \Exception
 	 */
-	public function fetchColumn(string $sql, array $params = []): array
+	public function fetchColumn(string $sql, array $params = []): bool|null|array
 	{
 		$pdo = $this->queryPrev($sql, $params);
 
-		defer(fn() => $pdo->closeCursor());
+		$result = $pdo->fetchColumn(\PDO::FETCH_ASSOC);
-
+		$pdo->closeCursor();
-		return $pdo->fetchColumn(\PDO::FETCH_ASSOC);
+		return $result;
 	}
 
 
@@ -199,9 +192,9 @@ class PDO implements StopHeartbeatCheck
 	{
 		$pdo = $this->queryPrev($sql, $params);
 
-		defer(fn() => $pdo->closeCursor());
+		$result = $pdo->rowCount();
-
+		$pdo->closeCursor();
-		return $pdo->rowCount();
+		return $result;
 	}
 
 
@@ -214,10 +207,19 @@ class PDO implements StopHeartbeatCheck
 	private function queryPrev(string $sql, array $params = []): PDOStatement
 	{
 		$this->_last = time();
-		if (($statement = $this->_pdo()->query($sql)) === false) {
+		try {
-			throw new Exception($this->_pdo()->errorInfo()[1]);
+			if (($statement = $this->_pdo()->query($sql)) === false) {
+				throw new Exception($this->_pdo()->errorInfo()[1]);
+			}
+			return $this->bindValue($statement, $params);
+		} catch (\PDOException | \Throwable $throwable) {
+			if (str_contains($throwable->getMessage(), 'MySQL server has gone away')) {
+				$this->pdo = null;
+
+				return $this->queryPrev($sql, $params);
+			}
+			throw new Exception($throwable->getMessage());
 		}
-		return $this->bindValue($statement, $params);
 	}
 
 
@@ -238,25 +240,26 @@ class PDO implements StopHeartbeatCheck
 
 	/**
 	 * @param string $sql
-	 * @param $isInsert
 	 * @param array $params
 	 * @return int
 	 * @throws Exception
 	 */
-	public function execute(string $sql, $isInsert, array $params = []): int
+	public function execute(string $sql, array $params = []): int
 	{
 		$this->_last = time();
-		if (!(($prepare = $this->_pdo()->prepare($sql)) instanceof PDOStatement)) {
+		$pdo = $this->_pdo();
+		if (!(($prepare = $pdo->prepare($sql)) instanceof PDOStatement)) {
 			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
 		}
-		defer(fn() => $prepare->closeCursor());
 		if ($prepare->execute($params) === false) {
 			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
 		}
-		if ($isInsert) {
+		$result = (int)$pdo->lastInsertId();
-			return (int)$this->_pdo()->lastInsertId();
+		$prepare->closeCursor();
+		if ($result == 0) {
+			return true;
 		}
-		return 1;
+		return $result;
 	}
 
 

src/ObjectToArray.php

@@ -1,11 +0,0 @@
-<?php
-
-namespace Database;
-
-interface ObjectToArray
-{
-
-
-	public function toArray();
-
-}

src/Pagination.php

@@ -128,7 +128,7 @@ class Pagination extends Component
 	 * @return void
 	 * @throws Exception
 	 */
-	public function plunk($param = [])
+	public function plunk(array $param = [])
 	{
 		$this->loop($param);
 	}
@@ -191,8 +191,14 @@ class Pagination extends Component
 		}
 		$data = $this->activeQuery->limit($this->_offset, $this->_limit)->get();
 		$this->_offset += $this->_limit;
-		$this->_length += $data->size();
+
-		return [$data->size(), $data];
+		if (is_array($data)) {
+			$size = count($data);
+		} else {
+			$size = $data->size();
+		}
+		$this->_length += $size;
+		return [$size, $data];
 	}
 
 }

src/Relation.php

@@ -31,7 +31,7 @@ class Relation extends Component
 	}
 
 	/**
-	 * @param $name
+	 * @param string $name
 	 * @return ActiveQuery|null
 	 */
 	public function getQuery(string $name): ?ActiveQuery

src/SqlBuilder.php

@@ -116,7 +116,7 @@ class SqlBuilder extends Component
 	 */
 	public function insert(array $attributes, bool $isBatch = false): array
 	{
-		$update = sprintf('INSERT INTO %s', $this->tableName());
+		$update = 'INSERT INTO ' . $this->tableName();
 		if ($isBatch === false) {
 			$attributes = [$attributes];
 		}
@@ -140,7 +140,7 @@ class SqlBuilder extends Component
 	 */
 	public function delete(): string
 	{
-		$delete = sprintf('DELETE FROM %s ', $this->query->modelClass::getTable());
+		$delete = sprintf('DELETE FROM %s ', $this->query->modelClass->getTable());
 
 		$this->query->from = null;
 
@@ -240,7 +240,7 @@ class SqlBuilder extends Component
 		if (empty($this->query->from) && !empty($this->query->modelClass)) {
 			$this->query->from($this->query->getTable());
 		}
-		return $this->_prefix();
+		return $this->_prefix(false, true);
 	}
 
 
@@ -256,14 +256,15 @@ class SqlBuilder extends Component
 
 	/**
 	 * @param bool $hasOrder
+	 * @param bool $isCount
 	 * @return string
 	 * @throws Exception
 	 */
-	private function _prefix(bool $hasOrder = false): string
+	private function _prefix(bool $hasOrder = false, bool $isCount = false): string
 	{
 		$select = '';
 		if (!empty($this->query->from)) {
-			$select = $this->_selectPrefix();
+			$select = $this->_selectPrefix($isCount);
 		}
 		$select = $this->_wherePrefix($select);
 		if (!empty($this->query->attributes) && is_array($this->query->attributes)) {
@@ -276,7 +277,11 @@ class SqlBuilder extends Component
 		if ($hasOrder === true && !empty($this->query->order)) {
 			$select .= $this->builderOrder($this->query->order);
 		}
-		return $select . $this->builderLimit($this->query);
+		$sql = $select . $this->builderLimit($this->query);
+		if ($this->query->lock) {
+			$sql .= ' FOR UPDATE';
+		}
+		return $sql;
 	}
 
 
@@ -298,12 +303,13 @@ class SqlBuilder extends Component
 
 
 	/**
+	 * @param bool $isCount
 	 * @return string
 	 * @throws Exception
 	 */
-	private function _selectPrefix(): string
+	private function _selectPrefix(bool $isCount): string
 	{
-		$select = $this->builderSelect($this->query->select) . ' FROM ' . $this->tableName();
+		$select = $this->builderSelect($this->query->select, $isCount) . ' FROM ' . $this->tableName();
 		if (!empty($this->query->alias)) {
 			$select .= $this->builderAlias($this->query->alias);
 		}
@@ -361,7 +367,7 @@ class SqlBuilder extends Component
 			$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->modelClass->getTable();
 		}
 		return $this->query->from;
 	}

src/TestModel.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Database;
+
+
+use Database\Model;
+
+/**
+ *
+ */
+class TestModel extends Model
+{
+
+
+	protected string $connection = '';
+
+
+	protected string $table = '';
+
+
+	public ?string $primary = '';
+
+}
+
+
+TestModel::query()->get();

src/Traits/Builder.php

@@ -9,12 +9,11 @@ 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;
+use ReflectionException;
 
 
 /**
@@ -62,10 +61,14 @@ trait Builder
 
 	/**
 	 * @param null $select
+	 * @param bool $isCount
 	 * @return string
 	 */
-	#[Pure] private function builderSelect($select = NULL): string
+	#[Pure] private function builderSelect($select = NULL, bool $isCount = false): string
 	{
+		if ($isCount) {
+			return "SELECT COUNT(*)";
+		}
 		if (empty($select)) {
 			return "SELECT *";
 		}
@@ -130,6 +133,8 @@ trait Builder
 		if (empty($where)) return '';
 		if (is_string($where)) return $where;
 		foreach ($where as $key => $value) {
+			if (is_null($value)) continue;
+
 			$_value = $this->resolveCondition($key, $value, $_tmp);
 
 			if (empty($_value)) continue;
@@ -148,7 +153,7 @@ trait Builder
 	 * @param $_tmp
 	 * @return string
 	 * @throws NotFindClassException
-	 * @throws ReflectionException
+	 * @throws ReflectionException|Exception
 	 */
 	private function resolveCondition($field, $condition, $_tmp): string
 	{
@@ -167,9 +172,7 @@ trait Builder
 	 * @param $condition
 	 * @param $array
 	 * @return string
-	 * @throws NotFindClassException
+	 * @throws Exception
-	 * @throws ReflectionException
-	 * @throws ReflectionException
 	 */
 	private function _arrayMap($condition, $array): string
 	{
@@ -181,13 +184,22 @@ trait Builder
 			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]);
+			$builder = Kiri::getDi()->get(OrCondition::class);
+			$builder->setValue($condition[2]);
+			$builder->setColumn($condition[1]);
+			$builder->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);
+			$class = $defaultConfig['class'];
+			unset($defaultConfig['class']);
+
+			$builder = Kiri::getDi()->get($class, [], $defaultConfig);
+			$builder->setValue($condition[2]);
+			$builder->setColumn($condition[1]);
 		} else {
-			$builder = Kiri::createObject(['class' => HashCondition::class, 'value' => $condition]);
+			$builder = Kiri::getDi()->get(HashCondition::class);
+			$builder->setValue($condition);
 		}
 
 		$array[] = $builder->builder();
@@ -204,6 +216,8 @@ trait Builder
 	{
 		$_array = [];
 		foreach ($condition as $key => $value) {
+			if (is_null($value)) continue;
+
 			$value = is_numeric($value) ? $value : '\'' . $value . '\'';
 			if (!is_numeric($key)) {
 				$_array[] = sprintf('%s = %s', $key, $value);

src/Traits/HasBase.php

@@ -9,9 +9,8 @@ declare(strict_types=1);
 
 namespace Database\Traits;
 
-use Database\ActiveRecord;
+use Database\ModelInterface;
 use Database\Collection;
-use Database\IOrm;
 use Database\Relation;
 use Exception;
 
@@ -24,11 +23,11 @@ use Exception;
 abstract class HasBase implements \Database\Traits\Relation
 {
 
-	/** @var ActiveRecord|Collection */
+	/** @var ModelInterface|Collection */
-	protected Collection|ActiveRecord $data;
+	protected Collection|ModelInterface $data;
 
 	/**
-	 * @var IOrm|ActiveRecord
+	 * @var ModelInterface
 	 */
 	protected mixed $model;
 
@@ -40,7 +39,7 @@ abstract class HasBase implements \Database\Traits\Relation
 
     /**
      * HasBase constructor.
-     * @param IOrm $model
+     * @param ModelInterface $model
      * @param $primaryId
      * @param $value
      * @param Relation $relation
@@ -49,16 +48,16 @@ abstract class HasBase implements \Database\Traits\Relation
 	public function __construct(mixed $model, $primaryId, $value, Relation $relation)
 	{
 		if (!class_exists($model)) {
-			throw new Exception('Model must implement ' . ActiveRecord::class);
+			throw new Exception('Model must implement ' . $model);
 		}
-		if (!in_array(IOrm::class, class_implements($model))) {
+		if (!in_array(ModelInterface::class, class_implements($model))) {
-			throw new Exception('Model must implement ' . ActiveRecord::class);
+			throw new Exception('Model must implement ' . $model);
 		}
 		if (is_array($value)) {
 			if (empty($value)) $value = [];
-			$_model = $model::find()->whereIn($primaryId, $value);
+			$_model = $model::query()->whereIn($primaryId, $value);
 		} else {
-			$_model = $model::find()->where(['t1.' . $primaryId => $value]);
+			$_model = $model::query()->where(['t1.' . $primaryId => $value]);
 		}
 
 		$this->_relation = $relation->bindIdentification($model, $_model);

src/Traits/QueryTrait.php

@@ -12,8 +12,8 @@ namespace Database\Traits;
 
 use Closure;
 use Database\ActiveQuery;
-use Database\ActiveRecord;
 use Database\Condition\MathematicsCondition;
+use Database\ModelInterface;
 use Database\Query;
 use Database\SqlBuilder;
 use Exception;
@@ -38,15 +38,18 @@ trait QueryTrait
 	public string $alias = 't1';
 	public array $filter = [];
 
+
+	public bool $lock = false;
+
 	public bool $ifNotWhere = false;
 
 
 	private SqlBuilder $builder;
 
 	/**
-	 * @var ActiveRecord|string|null
+	 * @var ModelInterface|string|null
 	 */
-	public ActiveRecord|string|null $modelClass;
+	public ModelInterface|string|null $modelClass;
 
 	/**
 	 * clear
@@ -83,6 +86,17 @@ trait QueryTrait
 	}
 
 
+	/**
+	 * @param bool $lock
+	 * @return $this
+	 */
+	public function lock(bool $lock): static
+	{
+		$this->lock = $lock;
+		return $this;
+	}
+
+
 	/**
 	 * @param string $whereRaw
 	 * @return QueryTrait
@@ -140,7 +154,7 @@ trait QueryTrait
 	 */
 	public function getTable(): string
 	{
-		return $this->modelClass::getTable();
+		return $this->modelClass->getTable();
 	}
 
 
@@ -306,10 +320,11 @@ trait QueryTrait
 	public function leftJoin(string $tableName, string $alias, $onCondition, $param = NULL): static
 	{
 		if (class_exists($tableName)) {
-			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+			$model = Kiri::getDi()->get($tableName);
-				throw new Exception('Model must implement ' . $tableName);
+			if (!($model instanceof ModelInterface)) {
+				throw new Exception('Model must implement ' . ModelInterface::class);
 			}
-			$tableName = $tableName::getTable();
+			$tableName = $model->getTable();
 		}
 		return $this->join(...["LEFT JOIN " . $tableName, $alias, $onCondition, $param]);
 	}
@@ -325,10 +340,11 @@ trait QueryTrait
 	public function rightJoin($tableName, $alias, $onCondition, $param = NULL): static
 	{
 		if (class_exists($tableName)) {
-			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+			$model = Kiri::getDi()->get($tableName);
-				throw new Exception('Model must implement ' . $tableName);
+			if (!($model instanceof ModelInterface)) {
+				throw new Exception('Model must implement ' . ModelInterface::class);
 			}
-			$tableName = $tableName::getTable();
+			$tableName = $model->getTable();
 		}
 		return $this->join(...["RIGHT JOIN " . $tableName, $alias, $onCondition, $param]);
 	}
@@ -344,10 +360,11 @@ trait QueryTrait
 	public function innerJoin($tableName, $alias, $onCondition, $param = NULL): static
 	{
 		if (class_exists($tableName)) {
-			if (!in_array(ActiveRecord::class, class_implements($tableName))) {
+			$model = Kiri::getDi()->get($tableName);
-				throw new Exception('Model must implement ' . $tableName);
+			if (!($model instanceof ModelInterface)) {
+				throw new Exception('Model must implement ' . ModelInterface::class);
 			}
-			$tableName = $tableName::getTable();
+			$tableName = $model->getTable();
 		}
 		return $this->join(...["INNER JOIN " . $tableName, $alias, $onCondition, $param]);
 	}
@@ -727,7 +744,7 @@ trait QueryTrait
 		$activeQuery = new ActiveQuery($this->modelClass);
 		call_user_func($value, $activeQuery);
 		if (empty($activeQuery->from)) {
-			$activeQuery->from($activeQuery->modelClass::getTable());
+			$activeQuery->from($activeQuery->modelClass->getTable());
 		}
 		return $activeQuery;
 	}
@@ -823,8 +840,12 @@ trait QueryTrait
 			$this->where[] = $this->makeClosureFunction($column);
 			return $this;
 		}
-		[$column, $opera, $value] = $this->opera(...func_get_args());
+		if (is_string($column)) {
-		$this->where[] = "$column $opera $value";
+			$this->where[] = $column;
+		} else {
+			[$column, $opera, $value] = $this->opera(...func_get_args());
+			$this->where[] = "$column $opera $value";
+		}
 		return $this;
 	}
 
@@ -902,6 +923,7 @@ trait QueryTrait
 	private function addArray(array $array): static
 	{
 		foreach ($array as $key => $value) {
+			if (is_null($value)) continue;
 			if (is_numeric($key)) {
 				[$column, $opera, $value] = $this->opera(...$value);