1

.phpstorm.meta.php

@@ -4,9 +4,12 @@ namespace PHPSTORM_META {
 
     // Reflect
 	use Kiri\Di\Container;
+	use Psr\Container\ContainerInterface;
 
+	override(ContainerInterface::get(0), map('@'));
+	override(Container::make(0), map('@'));
 	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

@@ -11,6 +11,7 @@ namespace Database;
 
 use Database\Traits\QueryTrait;
 use Exception;
+use JetBrains\PhpStorm\ArrayShape;
 use Kiri\Abstracts\Component;
 
 /**
@@ -20,290 +21,320 @@ use Kiri\Abstracts\Component;
 class ActiveQuery extends Component implements ISqlBuilder
 {
 
-	use QueryTrait;
+    use QueryTrait;
 
-	/** @var array */
+    /** @var array */
-	public array $with = [];
+    public array $with = [];
 
-	/** @var bool */
+    /** @var bool */
-	public bool $asArray = FALSE;
+    public bool $asArray = FALSE;
 
-	/** @var bool */
+    /** @var bool */
-	public bool $useCache = FALSE;
+    public bool $useCache = FALSE;
 
-	/**
+    /**
-	 * @var Connection|null
+     * @var Connection|null
-	 */
+     */
-	public ?Connection $db = NULL;
+    public ?Connection $db = NULL;
 
-	/**
+    /**
-	 * @var array
+     * @var array
-	 * 参数绑定
+     * 参数绑定
-	 */
+     */
-	public array $attributes = [];
+    public array $attributes = [];
 
 
-	/**
+    /**
-	 * Comply constructor.
+     * Comply constructor.
-	 * @param $model
+     * @param $model
-	 * @param array $config
+     * @param array $config
-	 * @throws
+     * @throws
-	 */
+     */
-	public function __construct($model, array $config = [])
+    public function __construct($model, array $config = [])
-	{
+    {
-		$this->modelClass = $model;
+        $this->modelClass = $model;
 
-		$this->builder = SqlBuilder::builder($this);
+        $this->builder = SqlBuilder::builder($this);
-		parent::__construct($config);
+        parent::__construct($config);
-	}
+    }
 
 
-	/**
+    /**
-	 * 清除不完整数据
+     * 清除不完整数据
-	 */
+     */
-	public function clear()
+    public function clear()
-	{
+    {
-		$this->db = null;
+        $this->db = NULL;
-		$this->useCache = false;
+        $this->useCache = FALSE;
-		$this->with = [];
+        $this->with = [];
-	}
+    }
 
-	/**
+    /**
-	 * @param $key
+     * @param $key
-	 * @param $value
+     * @param $value
-	 * @return $this
+     * @return $this
-	 */
+     */
-	public function addParam($key, $value): static
+    public function addParam($key, $value): static
-	{
+    {
-		$this->attributes[$key] = $value;
+        $this->attributes[$key] = $value;
-		return $this;
+        return $this;
-	}
+    }
-
-	/**
-	 * @param array $values
-	 * @return $this
-	 */
-	public function addParams(array $values): static
-	{
-		foreach ($values as $key => $val) {
-			$this->addParam($key, $val);
-		}
-		return $this;
-	}
-
-	/**
-	 * @param $name
-	 * @return $this
-	 */
-	public function with($name): static
-	{
-		if (empty($name)) {
-			return $this;
-		}
-		if (is_string($name)) {
-			$name = explode(',', $name);
-		}
-		foreach ($name as $val) {
-			array_push($this->with, $val);
-		}
-		return $this;
-	}
 
 
-	/**
+    /**
-	 * @param $sql
+     * @param int $size
-	 * @param array $params
+     * @param int $page
-	 * @return mixed
+     * @return array
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function execute($sql, array $params = []): Command
+    #[ArrayShape(['code' => "int", 'message' => "string", 'size' => "mixed", 'page' => "mixed", 'count' => "int", 'next' => "mixed", 'prev' => "mixed", 'param' => "array"])]
-	{
+    public function pagination(int $size = 20, int $page = 1): array
-		return $this->modelClass::getDb()->createCommand($sql, $params);
+    {
-	}
+        $page = max(1, $page);
+        $size = max(1, $size);
+
+        $offset = ($page - 1) * $size;
+
+        $count = $this->count();
+        $lists = $this->limit($offset, $size)->get()->toArray();
+        return [
+            'code'   => 0,
+            'message'   => 'ok',
+            'size'   => $size,
+            'page'   => $page,
+            'count'  => $count,
+            'next'   => max($page + 1, 1),
+            'prev'   => max($page - 1, 1),
+            'param' => $lists,
+        ];
+    }
 
 
-	/**
+    /**
-	 * @return ActiveRecord|null
+     * @param array $values
-	 * @throws Exception
+     * @return $this
-	 */
+     */
-	public function first(): ActiveRecord|null
+    public function addParams(array $values): static
-	{
+    {
-		$data = $this->execute($this->builder->one())->one();
+        foreach ($values as $key => $val) {
-		if (empty($data)) {
+            $this->addParam($key, $val);
-			return NULL;
+        }
-		}
+        return $this;
-		return $this->modelClass::populate($data);
+    }
-	}
+
+    /**
+     * @param $name
+     * @return $this
+     */
+    public function with($name): static
+    {
+        if (empty($name)) {
+            return $this;
+        }
+        if (is_string($name)) {
+            $name = explode(',', $name);
+        }
+        foreach ($name as $val) {
+            array_push($this->with, $val);
+        }
+        return $this;
+    }
 
 
-	/**
+    /**
-	 * @return string
+     * @param $sql
-	 * @throws Exception
+     * @param array $params
-	 */
+     * @return mixed
-	public function toSql(): string
+     * @throws Exception
-	{
+     */
-		return $this->builder->get();
+    public function execute($sql, array $params = []): Command
-	}
+    {
+        return $this->modelClass->getConnection()->createCommand($sql, $params);
+    }
 
 
-	/**
+    /**
-	 * @return array|Collection
+     * @return ModelInterface|null
-	 */
+     * @throws Exception
-	public function get(): Collection|array
+     */
-	{
+    public function first(): ModelInterface|null
-		return $this->all();
+    {
-	}
+        $data = $this->execute($this->builder->one())->one();
+        if (empty($data)) {
+            return NULL;
+        }
+        return $this->populate($data);
+    }
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @return string
-	 */
+     * @throws Exception
-	public function flush(): array|bool|int|string|null
+     */
-	{
+    public function toSql(): string
-		return $this->execute($this->builder->truncate())->exec();
+    {
-	}
+        return $this->builder->get();
+    }
 
 
-	/**
+    /**
-	 * @param int $size
+     * @return array|Collection
-	 * @param callable $callback
+     */
-	 * @return Pagination
+    public function get(): Collection|array
-	 * @throws Exception
+    {
-	 */
+        return $this->all();
-	public function page(int $size, callable $callback): Pagination
+    }
-	{
-		$pagination = new Pagination($this);
-		$pagination->setOffset(0);
-		$pagination->setLimit($size);
-		$pagination->setCallback($callback);
-		return $pagination;
-	}
-
-	/**
-	 * @param string $field
-	 * @param string $setKey
-	 *
-	 * @return array|null
-	 * @throws Exception
-	 */
-	public function column(string $field, string $setKey = ''): ?array
-	{
-		return $this->all()->column($field, $setKey);
-	}
-
-	/**
-	 * @return array|Collection
-	 * @throws
-	 */
-	public function all(): Collection|array
-	{
-		$data = $this->execute($this->builder->all())->all();
-
-		$collect = new Collection($this, $data, $this->modelClass);
-		if ($this->asArray) {
-			return $collect->toArray();
-		}
-		return $collect;
-	}
-
-	/**
-	 * @param ActiveRecord $model
-	 * @param $data
-	 * @return ActiveRecord
-	 * @throws Exception
-	 */
-	public function populate(ActiveRecord $model, $data): ActiveRecord
-	{
-		return $this->getWith($model::populate($data));
-	}
 
 
-	/**
+    /**
-	 * @param ActiveRecord $model
+     * @throws Exception
-	 * @return ActiveRecord
+     */
-	 */
+    public function flush(): array|bool|int|string|null
-	public function getWith(ActiveRecord $model): ActiveRecord
+    {
-	{
+        return $this->execute($this->builder->truncate())->exec();
-		if (empty($this->with) || !is_array($this->with)) {
+    }
-			return $model;
-		}
-		return $model->setWith($this->with);
-	}
-
-	/**
-	 * @return int
-	 * @throws Exception
-	 */
-	public function count(): int
-	{
-		$this->select = ['COUNT(*)'];
-		$data = $this->execute($this->builder->count())->one();
-		if ($data && is_array($data)) {
-			return (int)array_shift($data);
-		}
-		return 0;
-	}
 
 
-	/**
+    /**
-	 * @param array $data
+     * @param int $size
-	 * @return array|Command|bool|int|string
+     * @param callable $callback
-	 * @throws Exception
+     * @return Pagination
-	 */
+     * @throws Exception
-	public function batchUpdate(array $data): Command|array|bool|int|string
+     */
-	{
+    public function page(int $size, callable $callback): Pagination
-		$generate = $this->builder->update($data);
+    {
-		if (is_bool($generate)) {
+        $pagination = new Pagination($this);
-			return $generate;
+        $pagination->setOffset(0);
-		}
+        $pagination->setLimit($size);
-		return $this->execute(...$generate)->exec();
+        $pagination->setCallback($callback);
-	}
+        return $pagination;
+    }
 
-	/**
+    /**
-	 * @param array $data
+     * @param string $field
-	 * @return bool
+     * @param string $setKey
-	 * @throws Exception
+     *
-	 */
+     * @return array|null
-	public function batchInsert(array $data): bool
+     * @throws Exception
-	{
+     */
-		[$sql, $params] = $this->builder->insert($data, true);
+    public function column(string $field, string $setKey = ''): ?array
+    {
+        return $this->all()->column($field, $setKey);
+    }
+
+    /**
+     * @return array|Collection
+     * @throws
+     */
+    public function all(): Collection|array
+    {
+        $data = $this->execute($this->builder->all())->all();
+        if (!empty($this->with)) {
+            $this->getWith($this->modelClass);
+        }
+        $collect = new Collection($this, $data, $this->modelClass);
+        if ($this->asArray) {
+            return $collect->toArray();
+        }
+        return $collect;
+    }
+
+    /**
+     * @param $data
+     * @return ModelInterface
+     * @throws Exception
+     */
+    public function populate($data): ModelInterface
+    {
+        return $this->getWith($this->modelClass::populate($data));
+    }
 
 
-		return $this->execute($sql, $params)->exec(null, true);
+    /**
-	}
+     * @param ModelInterface $model
+     * @return ModelInterface
+     */
+    public function getWith(ModelInterface $model): ModelInterface
+    {
+        if (empty($this->with) || !is_array($this->with)) {
+            return $model;
+        }
+        return $model->setWith($this->with);
+    }
 
-	/**
+    /**
-	 * @param $filed
+     * @return int
-	 *
+     * @throws Exception
-	 * @return null
+     */
-	 * @throws Exception
+    public function count(): int
-	 */
+    {
-	public function value($filed)
+        $data = $this->execute($this->builder->count())->one();
-	{
+        if ($data && is_array($data)) {
-		return $this->first()[$filed] ?? null;
+            return (int)array_shift($data);
-	}
+        }
-
+        return 0;
-	/**
+    }
-	 * @return bool
-	 * @throws Exception
-	 */
-	public function exists(): bool
-	{
-		return !empty($this->execute($this->builder->one())->fetchColumn());
-	}
 
 
-	/**
+    /**
-	 * @param bool $getSql
+     * @param array $data
-	 * @return string|bool
+     * @return array|Command|bool|int|string
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function delete(bool $getSql = false): string|bool
+    public function batchUpdate(array $data): Command|array|bool|int|string
-	{
+    {
-		$sql = $this->builder->delete();
+        $generate = $this->builder->update($data);
-		if ($getSql === false) {
+        if (is_bool($generate)) {
-			return $this->execute($sql)->delete();
+            return $generate;
-		}
+        }
-		return $sql;
+        return $this->execute(...$generate)->exec();
-	}
+    }
+
+    /**
+     * @param array $data
+     * @return bool
+     * @throws Exception
+     */
+    public function batchInsert(array $data): bool
+    {
+        [$sql, $params] = $this->builder->insert($data, TRUE);
+
+
+        return $this->execute($sql, $params)->exec();
+    }
+
+    /**
+     * @param $filed
+     *
+     * @return null
+     * @throws Exception
+     */
+    public function value($filed)
+    {
+        return $this->first()[$filed] ?? NULL;
+    }
+
+    /**
+     * @return bool
+     * @throws Exception
+     */
+    public function exists(): bool
+    {
+        return !empty($this->execute($this->builder->one())->fetchColumn());
+    }
+
+
+    /**
+     * @param bool $getSql
+     * @return int|bool|string|null
+     * @throws Exception
+     */
+    public function delete(bool $getSql = FALSE): int|bool|string|null
+    {
+        $sql = $this->builder->delete();
+        if ($getSql === FALSE) {
+            return $this->execute($sql)->delete();
+        }
+        return $sql;
+    }
 }

src/Annotation/Get.php

@@ -1,42 +0,0 @@
-<?php
-
-
-namespace Database\Annotation;
-
-
-use Attribute;
-use Database\Base\Getter;
-use Exception;
-
-
-/**
- * Class Get
- * @package Annotation\Model
- */
-#[Attribute(Attribute::TARGET_METHOD)] class Get extends \Annotation\Attribute
-{
-
-
-	/**
-	 * Get constructor.
-	 * @param string $name
-	 */
-	public function __construct(public string $name)
-	{
-	}
-
-
-	/**
-	 * @param mixed $class
-	 * @param mixed|null $method
-	 * @return bool
-	 * @throws Exception
-	 */
-	public function execute(mixed $class, mixed $method = null): bool
-	{
-		di(Getter::class)->addGetter($this->name, $class, $method);
-		return true;
-	}
-
-
-}

src/Base/AbstractCollection.php

@@ -12,27 +12,27 @@ 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 ReturnTypeWillChange;
 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 +43,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([]);
     }
@@ -92,7 +92,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
      */
     public function addItem($item)
     {
-        array_push($this->_item, $item);
+        $this->_item[] = $item;
     }
 
     /**
@@ -109,7 +109,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 +126,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];
     }
@@ -144,7 +144,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
      * @param mixed $offset
      * @param mixed $value
      */
-    public function offsetSet(mixed $offset, mixed $value)
+    #[ReturnTypeWillChange] public function offsetSet(mixed $offset, mixed $value)
     {
         $this->_item[$offset] = $value;
     }
@@ -153,7 +153,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param mixed $offset
      */
-    public function offsetUnset(mixed $offset)
+    #[ReturnTypeWillChange] public function offsetUnset(mixed $offset)
     {
         if ($this->offsetExists($offset)) {
             unset($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/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/Condition.php

@@ -5,14 +5,13 @@ namespace Database\Condition;
 
 
 use JetBrains\PhpStorm\Pure;
-use Kiri\Abstracts\BaseObject;
+use Kiri\Abstracts\Component;
-use Kiri\Core\Str;
 
 /**
  * Class Condition
  * @package Database\Condition
  */
-abstract class Condition extends BaseObject
+abstract class Condition extends Component
 {
 
 	protected string $column = '';

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

@@ -11,22 +11,21 @@ declare(strict_types=1);
 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 Note\Inject;
-use Database\Affair\Commit;
+use ReflectionException;
-use Database\Affair\Rollback;
+use Server\Events\OnWorkerExit;
+use Server\Events\OnWorkerStop;
 
 /**
  * Class Connection
@@ -44,7 +43,11 @@ class Connection extends Component
 
 	public string $database = '';
 
-	public int $timeout = 1900;
+	public int $connect_timeout = 30;
+
+	public int $read_timeout = 10;
+
+	public array $pool;
 
 	/**
 	 * @var bool
@@ -62,6 +65,7 @@ class Connection extends Component
 	 * @var array
 	 */
 	public array $slaveConfig = [];
+	public array $attributes = [];
 
 
 	/**
@@ -71,28 +75,22 @@ class Connection extends Component
 	public Schema $_schema;
 
 
-	/**
-	 * @var EventProvider
-	 */
-	#[Inject(EventProvider::class)]
-	public EventProvider $eventProvider;
-
-
 	/**
 	 * execute by __construct
 	 * @throws Exception
 	 */
 	public function init()
 	{
-		$this->eventProvider->on(OnWorkerStop::class, [$this, 'clear_connection'], 0);
+		$eventProvider = Kiri::getDi()->get(EventProvider::class);
-		$this->eventProvider->on(OnWorkerExit::class, [$this, 'clear_connection'], 0);
+		$eventProvider->on(OnWorkerStop::class, [$this, 'clear_connection'], 0);
-		$this->eventProvider->on(BeginTransaction::class, [$this, 'beginTransaction'], 0);
+		$eventProvider->on(OnWorkerExit::class, [$this, 'clear_connection'], 0);
-		$this->eventProvider->on(Rollback::class, [$this, 'rollback'], 0);
+		$eventProvider->on(BeginTransaction::class, [$this, 'beginTransaction'], 0);
-		$this->eventProvider->on(Commit::class, [$this, 'commit'], 0);
+		$eventProvider->on(Rollback::class, [$this, 'rollback'], 0);
+		$eventProvider->on(Commit::class, [$this, 'commit'], 0);
 
 		if (Db::transactionsActive()) {
-		    $this->beginTransaction();
+			$this->beginTransaction();
-        }
+		}
 
 		$this->_schema->db = $this;
 	}
@@ -109,6 +107,17 @@ class Connection extends Component
 	}
 
 
+	/**
+	 * @param $config
+	 * @return $this
+	 */
+	public function configure($config): static
+	{
+		Kiri::configure($this, $config);
+		return $this;
+	}
+
+
 	/**
 	 * @throws Exception
 	 */
@@ -142,6 +151,7 @@ class Connection extends Component
 	 * @return mixed
 	 * @throws ReflectionException
 	 * @throws NotFindClassException
+	 * @throws Exception
 	 */
 	public function getSchema(): Schema
 	{
@@ -158,7 +168,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')) {
@@ -186,10 +196,14 @@ class Connection extends Component
 	public function masterInstance(): PDO
 	{
 		return $this->connections()->get([
-			'cds'      => $this->cds,
+			'cds'             => $this->cds,
-			'username' => $this->username,
+			'username'        => $this->username,
-			'password' => $this->password,
+			'password'        => $this->password,
-			'database' => $this->database
+			'attributes'      => $this->attributes,
+			'connect_timeout' => $this->connect_timeout,
+			'read_timeout'    => $this->read_timeout,
+			'dbname'          => $this->database,
+			'pool'            => $this->pool
 		], true);
 	}
 

src/DatabasesProviders.php

@@ -4,15 +4,14 @@ declare(strict_types=1);
 namespace Database;
 
 
-use Annotation\Inject;
 use Exception;
-use Server\Events\OnWorkerStart;
 use Kiri\Abstracts\Config;
 use Kiri\Abstracts\Providers;
 use Kiri\Application;
 use Kiri\Events\EventProvider;
 use Kiri\Exception\ConfigException;
 use Kiri\Kiri;
+use Server\Events\OnWorkerStart;
 
 /**
  * Class DatabasesProviders
@@ -24,13 +23,6 @@ class DatabasesProviders extends Providers
 	private array $_pooLength = ['min' => 0, 'max' => 1];
 
 
-	/**
-	 * @var EventProvider
-	 */
-	#[Inject(EventProvider::class)]
-	public EventProvider $eventProvider;
-
-
 	/**
 	 * @param Application $application
 	 * @throws Exception
@@ -53,11 +45,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 +61,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();
 		}
 	}
 
@@ -86,18 +75,20 @@ class DatabasesProviders extends Providers
 	 */
 	private function _settings($database): array
 	{
+		$clientPool = $database['pool'] ?? ['min' => 1, 'max' => 5, 'tick' => 60];
 		return [
-			'class'       => Connection::class,
+			'id'              => $database['id'],
-			'id'          => $database['id'],
+			'cds'             => $database['cds'],
-			'cds'         => $database['cds'],
+			'username'        => $database['username'],
-			'username'    => $database['username'],
+			'password'        => $database['password'],
-			'password'    => $database['password'],
+			'tablePrefix'     => $database['tablePrefix'],
-			'tablePrefix' => $database['tablePrefix'],
+			'database'        => $database['database'],
-			'database'    => $database['database'],
+			'connect_timeout' => $database['connect_timeout'] ?? 30,
-			'maxNumber'   => $this->_pooLength['max'],
+			'read_timeout'    => $database['read_timeout'] ?? 10,
-			'minNumber'   => $this->_pooLength['min'],
+			'pool'            => $clientPool,
-			'charset'     => $database['charset'] ?? 'utf8mb4',
+			'attributes'      => $database['attributes'] ?? [],
-			'slaveConfig' => $database['slaveConfig']
+			'charset'         => $database['charset'] ?? 'utf8mb4',
+			'slaveConfig'     => $database['slaveConfig']
 		];
 	}
 

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,30 @@ 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;
+			$select->setIsNowExample(true);
+			if (!$select->save()) {
+				Db::rollback();
+				return $logger->addError($select->getLastError(), 'mysql');
+			}
 		}
+		Db::commit();
 		return $select;
 	}
 
@@ -147,14 +140,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 +165,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 +198,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 +237,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 +263,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 +275,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 +306,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 +335,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 +354,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 +373,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 +391,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 +406,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 +415,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\Config;
-use Kiri\Events\EventProvider;
+use Kiri\Abstracts\Logger;
 use Kiri\Kiri;
 use Kiri\Pool\StopHeartbeatCheck;
 use PDOStatement;
-use Server\Events\OnWorkerExit;
 use Swoole\Timer;
 
 /**
@@ -26,35 +25,41 @@ class PDO implements StopHeartbeatCheck
 	private int $_transaction = 0;
 
 
-	/**
-	 * @var EventProvider
-	 */
-	private EventProvider $eventProvider;
-
 	private int $_timer = -1;
 
 	private int $_last = 0;
 
+	public string $dbname;
+	public string $cds;
+	public string $username;
+	public string $password;
+	public string $charset;
+	public int $connect_timeout;
+	public int $read_timeout;
+
+
+	public array $attributes = [];
+
 
 	/**
-	 * @param string $dbname
+	 * @param array $config
-	 * @param string $cds
-	 * @param string $username
-	 * @param string $password
-	 * @param string $chatset
-	 * @throws
 	 */
-	public function __construct(public string $dbname, public string $cds,
+	public function __construct(array $config)
-	                            public string $username, public string $password, public string $chatset = 'utf8mb4')
 	{
-		$this->eventProvider = Kiri::getDi()->get(EventProvider::class);
+		$this->dbname = $config['dbname'];
+		$this->cds = $config['cds'];
+		$this->username = $config['username'];
+		$this->password = $config['password'];
+		$this->connect_timeout = $config['connect_timeout'] ?? 30;
+		$this->read_timeout = $config['read_timeout'] ?? 10;
+		$this->charset = $config['charset'] ?? 'utf8mb4';
+		$this->attributes = $config['attributes'] ?? [];
 	}
 
 
 	public function init()
 	{
 		$this->heartbeat_check();
-		$this->eventProvider->on(OnWorkerExit::class, [$this, 'stopHeartbeatCheck']);
 	}
 
 
@@ -72,23 +77,31 @@ 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()) {
+		if ($this->_timer === -1) {
-			$this->_timer = Timer::tick(1000, function () {
+			$this->_timer = Timer::tick(1000, fn() => $this->waite());
-				try {
+		}
-					if (env('state') == 'exit') {
+	}
-						echo 'timer end.' . PHP_EOL;
+
-					}
+
-					if (time() - $this->_last > 10 * 60) {
+	/**
-						$this->stopHeartbeatCheck();
+	 * @throws Exception
-						$this->pdo = null;
+	 */
-					}
+	private function waite(): void
-				} catch (\Throwable $throwable) {
+	{
-					error($throwable);
+		try {
-				}
+			if (env('state', 'start') == 'exit') {
-			});
+				Kiri::getDi()->get(Logger::class)->critical('timer end');
+				$this->stopHeartbeatCheck();
+			}
+			if (time() - $this->_last > (int)Config::get('databases.pool.tick', 60)) {
+				$this->stopHeartbeatCheck();
+				$this->pdo = null;
+			}
+		} catch (\Throwable $throwable) {
+			error($throwable);
 		}
 	}
 
@@ -144,48 +157,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 +212,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 +227,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 +260,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;
 	}
 
 
@@ -283,13 +306,18 @@ class PDO implements StopHeartbeatCheck
 		$link = new \PDO('mysql:dbname=' . $this->dbname . ';host=' . $this->cds, $this->username, $this->password, [
 			\PDO::ATTR_EMULATE_PREPARES         => false,
 			\PDO::ATTR_CASE                     => \PDO::CASE_NATURAL,
-			\PDO::ATTR_TIMEOUT                  => 60,
+			\PDO::ATTR_TIMEOUT                  => $this->connect_timeout,
 			\PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
-			\PDO::MYSQL_ATTR_INIT_COMMAND       => 'SET NAMES ' . $this->chatset
+			\PDO::MYSQL_ATTR_INIT_COMMAND       => 'SET NAMES ' . $this->charset
 		]);
 		$link->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 		$link->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
 		$link->setAttribute(\PDO::ATTR_ORACLE_NULLS, \PDO::NULL_EMPTY_STRING);
+		if (!empty($this->attributes) && is_array($this->attributes)) {
+			foreach ($this->attributes as $key => $attribute) {
+				$link->setAttribute($key, $attribute);
+			}
+		}
 		return $link;
 	}
 

src/Note/Get.php

@@ -0,0 +1,44 @@
+<?php
+
+
+namespace Database\Note;
+
+
+use Attribute;
+use Database\Base\Getter;
+use Exception;
+
+
+/**
+ * Class Get
+ * @package Note\Model
+ */
+#[Attribute(Attribute::TARGET_METHOD)] class Get extends \Note\Attribute
+{
+
+
+	/**
+	 * Get constructor.
+	 * @param string $name
+	 */
+	public function __construct(public string $name)
+	{
+	}
+
+
+    /**
+     * @param static $params
+     * @param mixed $class
+     * @param mixed|null $method
+     * @return bool
+     * @throws \Kiri\Exception\NotFindClassException
+     * @throws \ReflectionException
+     */
+    public function execute(mixed $class, mixed $method = null): bool
+	{
+		di(Getter::class)->addGetter($this->name, $class, $method);
+		return true;
+	}
+
+
+}

src/Note/Relation.php

@@ -1,20 +1,17 @@
 <?php
 
 
-namespace Database\Annotation;
+namespace Database\Note;
 
 
-use Annotation\Attribute;
+use Note\Attribute;
-use Database\ActiveRecord;
 use Database\Base\Relate;
 use Exception;
-use JetBrains\PhpStorm\Pure;
-use Kiri\Kiri;
 
 
 /**
  * Class Relation
- * @package Annotation\Model
+ * @package Note\Model
  */
 #[\Attribute(\Attribute::TARGET_METHOD)] class Relation extends Attribute
 {
@@ -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/Note/Set.php

@@ -1,10 +1,10 @@
 <?php
 
 
-namespace Database\Annotation;
+namespace Database\Note;
 
 
-use Annotation\Attribute;
+use Note\Attribute;
 use Database\Base\Setter;
 use Exception;
 
@@ -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/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()->make($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]);
 	}
@@ -505,7 +522,7 @@ trait QueryTrait
 			$conditionArray = $this->sprintf($conditionArray, $value, $opera);
 		}
 
-		$this->where = ['(' . implode(' AND ', $this->where) . ') OR (' . $conditionArray . ')'];
+		$this->where = ['((' . implode(' AND ', $this->where) . ') OR (' . $conditionArray . '))'];
 		return $this;
 	}
 
@@ -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);