改名

.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;

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,15 +125,15 @@ 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->_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,10 +51,10 @@ 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);
 	}
@@ -63,12 +63,12 @@ class CollectionIterator extends \ArrayIterator
 	/**
 	 * @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,31 @@ 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\HasCount;
 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 +43,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 +86,22 @@ 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;
+
+
+	/**
+	 * @var array
+	 */
+	protected array $rules = [];
 
 
 	/**
@@ -123,17 +122,14 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	/**
 	 * @param string $name
 	 * @param mixed $value
-	 * @return mixed
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
 	 */
-	private function _setter(string $name, mixed $value): mixed
+	private function _setter(string $name, mixed $value): void
 	{
 		$method = di(Setter::class)->getSetter(static::class, $name);
 		if (!empty($method)) {
 			$value = $this->{$method}($value);
 		}
-		return $this->_attributes[$name] = $value;
+		$this->_attributes[$name] = $value;
 	}
 
 
@@ -178,8 +174,6 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 	/**
 	 * @return EventDispatch
-	 * @throws NotFindClassException
-	 * @throws ReflectionException
 	 */
 	protected function getEventDispatch(): EventDispatch
 	{
@@ -189,7 +183,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 	/**
 	 * @param $data
-	 * @return ActiveRecord
+	 * @return Model
 	 */
 	public function setWith($data): static
 	{
@@ -220,15 +214,6 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	}
 
 
-	/**
-	 * @param Relation $relation
-	 */
-	public function setRelation(Relation $relation)
-	{
-		$this->_relation = $relation;
-	}
-
-
 	/**
 	 * @throws Exception
 	 */
@@ -268,11 +253,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 +272,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 +293,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 +323,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 +336,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 +347,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 +360,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 +374,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 +383,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 +426,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,9 +453,9 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 			if (!$if_condition_is_null) {
 				return false;
 			}
-			return static::find()->delete();
+			return 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);
 		}
@@ -522,8 +537,8 @@ 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('保存失败.');
 		}
@@ -575,11 +590,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);
 		}
@@ -596,7 +611,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 		if (!is_null($data)) {
 			$this->_attributes = merge($this->_attributes, $data);
 		}
-		if (!$this->validator($this->rules()) || !$this->beforeSave($this)) {
+		if (!$this->validator($this->rules) || !$this->beforeSave($this)) {
 			return false;
 		}
 		[$change, $condition, $fields] = $this->separation();
@@ -608,11 +623,11 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 
 
 	/**
-	 * @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);
@@ -752,7 +767,7 @@ abstract class BaseActiveRecord extends Component implements IOrm, ArrayAccess,
 	 */
 	public function getRelation(): ?Relation
 	{
-		return $this->_relation;
+		return Kiri::getDi()->get(Relation::class);
 	}
 
 
@@ -774,26 +789,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 +818,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 +828,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
 	 */
@@ -882,7 +883,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 +1025,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 +1062,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

@@ -139,10 +139,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) {

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;
 	}
@@ -142,6 +141,7 @@ class Connection extends Component
 	 * @return mixed
 	 * @throws ReflectionException
 	 * @throws NotFindClassException
+	 * @throws \Exception
 	 */
 	public function getSchema(): Schema
 	{
@@ -158,7 +158,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/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;
 	}
@@ -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,60 @@
+<?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;
+
+
+	/**
+	 * @return string
+	 */
+	public static function className(): string;
+
+
+	/**
+	 * @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/PDO.php

@@ -3,12 +3,11 @@
 namespace Database\Mysql;
 
 use Exception;
-use Http\Context\Context;
+use Kiri\Context;
-use Kiri\Events\EventProvider;
+use Kiri\Abstracts\Logger;
 use Kiri\Kiri;
 use Kiri\Pool\StopHeartbeatCheck;
 use PDOStatement;
-use Server\Events\OnWorkerExit;
 use Swoole\Timer;
 
 /**
@@ -17,280 +16,286 @@ use Swoole\Timer;
 class PDO implements StopHeartbeatCheck
 {
 
-	const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
+    const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
 
 
-	private ?\PDO $pdo = null;
+    private ?\PDO $pdo = null;
 
 
-	private int $_transaction = 0;
+    private int $_transaction = 0;
 
 
-	/**
+    private int $_timer = -1;
-	 * @var EventProvider
-	 */
-	private EventProvider $eventProvider;
 
-	private int $_timer = -1;
+    private int $_last = 0;
-
-	private int $_last = 0;
 
 
-	/**
+    /**
-	 * @param string $dbname
+     * @param string $dbname
-	 * @param string $cds
+     * @param string $cds
-	 * @param string $username
+     * @param string $username
-	 * @param string $password
+     * @param string $password
-	 * @param string $chatset
+     * @param string $chatset
-	 * @throws
+     * @throws
-	 */
+     */
-	public function __construct(public string $dbname, public string $cds,
+    public function __construct(public string $dbname, public string $cds,
-	                            public string $username, public string $password, public string $chatset = 'utf8mb4')
+                                public string $username, public string $password, public string $chatset = 'utf8mb4')
-	{
+    {
-		$this->eventProvider = Kiri::getDi()->get(EventProvider::class);
+    }
-	}
 
 
-	public function init()
+    public function init()
-	{
+    {
-		$this->heartbeat_check();
+        $this->heartbeat_check();
-		$this->eventProvider->on(OnWorkerExit::class, [$this, 'stopHeartbeatCheck']);
+    }
-	}
 
 
-	/**
+    /**
-	 * @return bool
+     * @return bool
-	 */
+     */
-	public function inTransaction(): bool
+    public function inTransaction(): bool
-	{
+    {
-		return $this->_transaction > 0;
+        return $this->_transaction > 0;
-	}
+    }
 
 
-	/**
+    /**
-	 *
+     *
-	 */
+     */
-	public function heartbeat_check(): void
+    public function heartbeat_check(): void
-	{
+    {
-		if (env('state') == 'exit') {
+        if (env('state', 'start') == 'exit') {
-			return;
+            return;
-		}
+        }
-		if ($this->_timer === -1 && Context::inCoroutine()) {
+        if ($this->_timer === -1 && Context::inCoroutine()) {
-			$this->_timer = Timer::tick(1000, function () {
+            $this->_timer = Timer::tick(1000, function () {
-				try {
+                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();
+                    if (time() - $this->_last > 10 * 60) {
-						$this->pdo = null;
+                        $this->stopHeartbeatCheck();
-					}
+                        $this->pdo = null;
-				} catch (\Throwable $throwable) {
+                    }
-					error($throwable);
+                } catch (\Throwable $throwable) {
-				}
+                    error($throwable);
-			});
+                }
-		}
+            });
-	}
+        }
+    }
 
 
-	/**
+    /**
-	 *
+     *
-	 */
+     */
-	public function stopHeartbeatCheck(): void
+    public function stopHeartbeatCheck(): void
-	{
+    {
-		if ($this->_timer > -1) {
+        if ($this->_timer > -1) {
-			Timer::clear($this->_timer);
+            Timer::clear($this->_timer);
-		}
+        }
-		$this->_timer = -1;
+        $this->_timer = -1;
-	}
+    }
 
 
-	/**
+    /**
-	 *
+     *
-	 */
+     */
-	public function beginTransaction()
+    public function beginTransaction()
-	{
+    {
-		if ($this->_transaction == 0) {
+        if ($this->_transaction == 0) {
-			$this->_pdo()->beginTransaction();
+            $this->_pdo()->beginTransaction();
-		}
+        }
-		$this->_transaction++;
+        $this->_transaction++;
-	}
+    }
 
 
-	/**
+    /**
-	 *
+     *
-	 */
+     */
-	public function commit()
+    public function commit()
-	{
+    {
-		if ($this->_transaction == 0) {
+        if ($this->_transaction == 0) {
-			$this->_pdo()->commit();
+            $this->_pdo()->commit();
-		}
+        }
-		$this->_transaction--;
+        $this->_transaction--;
-	}
+    }
 
 
-	/**
+    /**
-	 *
+     *
-	 */
+     */
-	public function rollback()
+    public function rollback()
-	{
+    {
-		if ($this->_transaction == 0) {
+        if ($this->_transaction == 0) {
-			$this->_pdo()->rollBack();
+            $this->_pdo()->rollBack();
-		}
+        }
-		$this->_transaction--;
+        $this->_transaction--;
-	}
+    }
 
 
 	/**
 	 * @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);
+        $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);
+        $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 string $sql
-	 * @param array $params
+     * @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);
+        $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;
-	}
+    }
 
 
-	/**
+    /**
-	 * @param string $sql
+     * @param string $sql
-	 * @param array $params
+     * @param array $params
-	 * @return int
+     * @return int
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function count(string $sql, array $params = []): int
+    public function count(string $sql, array $params = []): int
-	{
+    {
-		$pdo = $this->queryPrev($sql, $params);
+        $pdo = $this->queryPrev($sql, $params);
 
-		defer(fn() => $pdo->closeCursor());
+        $result = $pdo->rowCount();
-
+        $pdo->closeCursor();
-		return $pdo->rowCount();
+        return $result;
-	}
+    }
 
 
-	/**
+    /**
-	 * @param string $sql
+     * @param string $sql
-	 * @param array $params
+     * @param array $params
-	 * @return PDOStatement
+     * @return PDOStatement
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	private function queryPrev(string $sql, array $params = []): PDOStatement
+    private function queryPrev(string $sql, array $params = []): PDOStatement
-	{
+    {
-		$this->_last = time();
+        $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);
+            }
-	}
+            return $this->bindValue($statement, $params);
+        } catch (\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());
+        }
+    }
 
 
-	/**
+    /**
-	 * @param PDOStatement $statement
+     * @param PDOStatement $statement
-	 * @param array $params
+     * @param array $params
-	 * @return PDOStatement
+     * @return PDOStatement
-	 */
+     */
-	private function bindValue(PDOStatement $statement, array $params = []): PDOStatement
+    private function bindValue(PDOStatement $statement, array $params = []): PDOStatement
-	{
+    {
-		if (empty($params)) return $statement;
+        if (empty($params)) return $statement;
-		foreach ($params as $key => $param) {
+        foreach ($params as $key => $param) {
-			$statement->bindValue($key, $param);
+            $statement->bindValue($key, $param);
-		}
+        }
-		return $statement;
+        return $statement;
-	}
+    }
 
 
-	/**
+    /**
-	 * @param string $sql
+     * @param string $sql
-	 * @param $isInsert
+     * @param $isInsert
-	 * @param array $params
+     * @param array $params
-	 * @return int
+     * @return int
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function execute(string $sql, $isInsert, array $params = []): int
+    public function execute(string $sql, $isInsert, array $params = []): int
-	{
+    {
-		$this->_last = time();
+        $this->_last = time();
-		if (!(($prepare = $this->_pdo()->prepare($sql)) instanceof PDOStatement)) {
+        if (!(($prepare = $this->_pdo()->prepare($sql)) instanceof PDOStatement)) {
-			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
+            throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
-		}
+        }
-		defer(fn() => $prepare->closeCursor());
+        if ($prepare->execute($params) === false) {
-		if ($prepare->execute($params) === false) {
+            throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
-			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
+        }
-		}
+        $result = 1;
-		if ($isInsert) {
+        if ($isInsert) {
-			return (int)$this->_pdo()->lastInsertId();
+            $result = (int)$this->_pdo()->lastInsertId();
-		}
+        }
-		return 1;
+        $prepare->closeCursor();
-	}
+        return $result;
+    }
 
 
-	/**
+    /**
-	 * @return \PDO
+     * @return \PDO
-	 */
+     */
-	public function _pdo(): \PDO
+    public function _pdo(): \PDO
-	{
+    {
-		if ($this->_timer === -1) {
+        if ($this->_timer === -1) {
-			$this->heartbeat_check();
+            $this->heartbeat_check();
-		}
+        }
-		if (!($this->pdo instanceof \PDO)) {
+        if (!($this->pdo instanceof \PDO)) {
-			$this->pdo = $this->newClient();
+            $this->pdo = $this->newClient();
-		}
+        }
-		return $this->pdo;
+        return $this->pdo;
-	}
+    }
 
 
-	/**
+    /**
-	 * @return \PDO
+     * @return \PDO
-	 */
+     */
-	private function newClient(): \PDO
+    private function newClient(): \PDO
-	{
+    {
-		$link = new \PDO('mysql:dbname=' . $this->dbname . ';host=' . $this->cds, $this->username, $this->password, [
+        $link = new \PDO('mysql:dbname=' . $this->dbname . ';host=' . $this->cds, $this->username, $this->password, [
-			\PDO::ATTR_EMULATE_PREPARES         => false,
+            \PDO::ATTR_EMULATE_PREPARES         => false,
-			\PDO::ATTR_CASE                     => \PDO::CASE_NATURAL,
+            \PDO::ATTR_CASE                     => \PDO::CASE_NATURAL,
-			\PDO::ATTR_TIMEOUT                  => 60,
+            \PDO::ATTR_TIMEOUT                  => 60,
-			\PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
+            \PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
-			\PDO::MYSQL_ATTR_INIT_COMMAND       => 'SET NAMES ' . $this->chatset
+            \PDO::MYSQL_ATTR_INIT_COMMAND       => 'SET NAMES ' . $this->chatset
-		]);
+        ]);
-		$link->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+        $link->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
-		$link->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
+        $link->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
-		$link->setAttribute(\PDO::ATTR_ORACLE_NULLS, \PDO::NULL_EMPTY_STRING);
+        $link->setAttribute(\PDO::ATTR_ORACLE_NULLS, \PDO::NULL_EMPTY_STRING);
-		return $link;
+        return $link;
-	}
+    }
 
 }

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;
 
@@ -276,7 +276,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;
 	}
 
 
@@ -361,7 +365,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;
 
 
 /**
@@ -148,7 +147,7 @@ trait Builder
 	 * @param $_tmp
 	 * @return string
 	 * @throws NotFindClassException
-	 * @throws ReflectionException
+	 * @throws ReflectionException|Exception
 	 */
 	private function resolveCondition($field, $condition, $_tmp): string
 	{
@@ -167,9 +166,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 +178,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();

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;
 	}