eee

This reverts commit fdf58326

ActiveQuery.php

@@ -9,332 +9,221 @@ declare(strict_types=1);
 
 namespace Database;
 
+use Closure;
 use Database\Traits\QueryTrait;
-use Exception;
+use Kiri\Di\Context;
-use JetBrains\PhpStorm\ArrayShape;
+use Swoole\Coroutine;
-use Kiri\Abstracts\Component;
 
 /**
  * Class ActiveQuery
  * @package Database
  */
-class ActiveQuery extends Component implements ISqlBuilder
+class ActiveQuery extends QueryTrait implements ISqlBuilder
 {
 
-    use QueryTrait;
 
-    /** @var array */
+    public bool     $asArray = FALSE;
-    public array $with = [];
+    protected mixed $_mock   = null;
 
-    /** @var bool */
-    public bool $asArray = FALSE;
-
-    /** @var bool */
-    public bool $useCache = FALSE;
 
     /**
-     * @var Connection|null
+     * @param bool $asArray
+     * @return static
      */
-    public ?Connection $db = NULL;
+    public function asArray(bool $asArray = true): static
+    {
+        $this->asArray = $asArray;
+        return $this;
+    }
 
     /**
-     * @var array
+     * @param array $methods
-     * 参数绑定
+     * @return $this
      */
-    public array $attributes = [];
+    public function with(array $methods): static
+    {
+        $this->modelClass->setWith($methods);
+        return $this;
+    }
 
 
     /**
-     * Comply constructor.
+     * @return ModelInterface|array|null|bool
-     * @param $model
-     * @param array $config
      * @throws
      */
-    public function __construct($model, array $config = [])
+    public function first(): ModelInterface|null|array|bool
     {
-        $this->modelClass = $model;
+        $data = $this->buildCommand($this->builder->one())->one();
+        if (is_array($data)) {
+            return $this->populate($data);
+        }
+        return null;
+    }
 
-        $this->builder = SqlBuilder::builder($this);
+    /**
-        parent::__construct($config);
+     * @return bool|Collection
+     */
+    public function get(): bool|Collection
+    {
+        $data = $this->buildCommand($this->builder->all())->all();
+        if (is_array($data)) {
+            return new Collection($this, $this->modelClass, $data);
+        }
+        return false;
     }
 
 
     /**
-     * 清除不完整数据
+     * @throws
      */
-    public function clear()
+    public function flush(): bool
     {
-        $this->db = NULL;
+        return (bool)$this->buildCommand($this->builder->truncate())->exec();
-        $this->useCache = FALSE;
-        $this->with = [];
-    }
-
-    /**
-     * @param $key
-     * @param $value
-     * @return $this
-     */
-    public function addParam($key, $value): static
-    {
-        $this->attributes[$key] = $value;
-        return $this;
     }
 
 
     /**
      * @param int $size
-     * @param int $page
+     * @param Closure $closure
-     * @return array
+     * @return void
-     * @throws Exception
      */
-    #[ArrayShape(['code' => "int", 'message' => "string", 'size' => "mixed", 'page' => "mixed", 'count' => "int", 'next' => "mixed", 'prev' => "mixed", 'param' => "array"])]
+    public function chunk(int $size, Closure $closure): void
-    public function pagination(int $size = 20, int $page = 1): array
     {
-        $page = max(1, $page);
+        if ($this->offset === -1) $this->offset = 0;
-        $size = max(1, $size);
+        $data = $this->offset($this->offset)->limit($size)->get();
-
+        if (!$data || $data->isEmpty()) {
-        $offset = ($page - 1) * $size;
+            return;
-
-        $count = $this->count();
-        $lists = $this->limit($offset, $size)->get()->toArray();
-        return [
-            'code'   => 0,
-            'message'   => 'ok',
-            'size'   => $size,
-            'page'   => $page,
-            'count'  => $count,
-            'next'   => max($page + 1, 1),
-            'prev'   => max($page - 1, 1),
-            'param' => $lists,
-        ];
-    }
-
-
-    /**
-     * @param array $values
-     * @return $this
-     */
-    public function addParams(array $values): static
-    {
-        foreach ($values as $key => $val) {
-            $this->addParam($key, $val);
         }
-        return $this;
+        if (Context::inCoroutine()) {
-    }
+            Coroutine::create(fn() => $closure($data));
-
+        } else {
-    /**
+            call_user_func($closure, $data);
-     * @param $name
-     * @return $this
-     */
-    public function with($name): static
-    {
-        if (empty($name)) {
-            return $this;
         }
-        if (is_string($name)) {
+        $this->offset += $size;
-            $name = explode(',', $name);
+        $this->chunk($size, $closure);
-        }
-        foreach ($name as $val) {
-            array_push($this->with, $val);
-        }
-        return $this;
-    }
-
-
-    /**
-     * @param $sql
-     * @param array $params
-     * @return mixed
-     * @throws Exception
-     */
-    public function execute($sql, array $params = []): Command
-    {
-        return $this->modelClass->getConnection()->createCommand($sql, $params);
-    }
-
-
-    /**
-     * @return ModelInterface|null
-     * @throws Exception
-     */
-    public function first(): ModelInterface|null
-    {
-        $data = $this->execute($this->builder->one())->one();
-        if (empty($data)) {
-            return NULL;
-        }
-        return $this->populate($data);
-    }
-
-
-    /**
-     * @return string
-     * @throws Exception
-     */
-    public function toSql(): string
-    {
-        return $this->builder->get();
-    }
-
-
-    /**
-     * @return array|Collection
-     */
-    public function get(): Collection|array
-    {
-        return $this->all();
-    }
-
-
-    /**
-     * @throws Exception
-     */
-    public function flush(): array|bool|int|string|null
-    {
-        return $this->execute($this->builder->truncate())->exec();
-    }
-
-
-    /**
-     * @param int $size
-     * @param callable $callback
-     * @return Pagination
-     * @throws Exception
-     */
-    public function page(int $size, callable $callback): Pagination
-    {
-        $pagination = new Pagination($this);
-        $pagination->setOffset(0);
-        $pagination->setLimit($size);
-        $pagination->setCallback($callback);
-        return $pagination;
     }
 
     /**
      * @param string $field
-     * @param string $setKey
+     * @param string|null $setKey
      *
      * @return array|null
-     * @throws Exception
      */
-    public function column(string $field, string $setKey = ''): ?array
+    public function column(string $field, ?string $setKey = null): ?array
     {
-        return $this->all()->column($field, $setKey);
+        return $this->get()->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));
     }
 
 
     /**
-     * @param ModelInterface $model
+     * @param mixed $value
-     * @return ModelInterface
+     * @return $this
      */
-    public function getWith(ModelInterface $model): ModelInterface
+    public function withMock(mixed $value): static
     {
-        if (empty($this->with) || !is_array($this->with)) {
+        $this->_mock = $value;
-            return $model;
+        return $this;
-        }
-        return $model->setWith($this->with);
     }
 
+
     /**
-     * @return int
+     * @return mixed
-     * @throws Exception
      */
-    public function count(): int
+    public function mock(): mixed
     {
-        $data = $this->execute($this->builder->count())->one();
+        return $this->_mock;
-        if ($data && is_array($data)) {
-            return (int)array_shift($data);
-        }
-        return 0;
     }
 
 
     /**
      * @param array $data
-     * @return array|Command|bool|int|string
+     * @return ModelInterface|array
-     * @throws Exception
+     * @throws
      */
-    public function batchUpdate(array $data): Command|array|bool|int|string
+    public function populate(array $data): ModelInterface|array
     {
+        $model = $this->modelClass->populates($data);
+
+        return $this->asArray ? $model->toArray() : $model;
+    }
+
+
+    /**
+     * @return int
+     * @throws
+     */
+    public function count(): int
+    {
+        return $this->buildCommand($this->builder->count())->rowCount();
+    }
+
+
+    /**
+     * @param array $data
+     * @return bool
+     * @throws
+     */
+    public function update(array $data): bool
+    {
+        if (count($data) < 1) {
+            return true;
+        }
         $generate = $this->builder->update($data);
-        if (is_bool($generate)) {
+        if (!is_bool($generate)) {
+            return (bool)$this->buildCommand($generate)->exec();
+        } else {
             return $generate;
         }
-        return $this->execute(...$generate)->exec();
     }
 
     /**
      * @param array $data
      * @return bool
-     * @throws Exception
      */
-    public function batchInsert(array $data): bool
+    public function insert(array $data): bool
     {
-        [$sql, $params] = $this->builder->insert($data, TRUE);
+        $sql = $this->builder->insert($data, isset($data[0]));
 
-
+        return (bool)$this->buildCommand($sql)->exec();
-        return $this->execute($sql, $params)->exec();
     }
 
     /**
-     * @param $filed
+     * @param string $filed
      *
-     * @return null
+     * @return mixed
-     * @throws Exception
+     * @throws
      */
-    public function value($filed)
+    public function value(string $filed): mixed
     {
         return $this->first()[$filed] ?? NULL;
     }
 
     /**
      * @return bool
-     * @throws Exception
+     * @throws
      */
     public function exists(): bool
     {
-        return !empty($this->execute($this->builder->one())->fetchColumn());
+        return $this->buildCommand($this->limit(1)->builder->exists())->exists();
     }
 
 
     /**
-     * @param bool $getSql
+     * @param string $sql
-     * @return int|bool|string|null
+     * @param array $params
-     * @throws Exception
+     * @return int|bool
      */
-    public function delete(bool $getSql = FALSE): int|bool|string|null
+    public function execute(string $sql, array $params = []): int|bool
     {
-        $sql = $this->builder->delete();
+        return $this->buildCommand($sql, $params)->exec();
-        if ($getSql === FALSE) {
+    }
-            return $this->execute($sql)->delete();
+
-        }
+
-        return $sql;
+    /**
+     * @return bool
+     */
+    public function delete(): bool
+    {
+        return $this->buildCommand($this->builder->delete())->delete();
     }
 }

Affair/Commit.php

@@ -2,8 +2,6 @@
 
 namespace Database\Affair;
 
-use Exception;
-
 class Commit
 {
 

Annotation/Get.php

@@ -1,44 +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 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;
-	}
-
-
-}

Annotation/Relation.php

@@ -1,41 +0,0 @@
-<?php
-
-
-namespace Database\Annotation;
-
-
-use Kiri\Annotation\Attribute;
-use Database\Base\Relate;
-use Exception;
-
-
-/**
- * Class Relation
- * @package Annotation\Model
- */
-#[\Attribute(\Attribute::TARGET_METHOD)] class Relation extends Attribute
-{
-
-
-	/**
-	 * Relation 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(Relate::class)->addRelate($this->name, $class, $method);
-		return true;
-	}
-
-}

Annotation/Set.php

@@ -1,39 +0,0 @@
-<?php
-
-
-namespace Database\Annotation;
-
-
-use Kiri\Annotation\Attribute;
-use Database\Base\Setter;
-use Exception;
-
-#[\Attribute(\Attribute::TARGET_METHOD)] class Set extends Attribute
-{
-
-
-	/**
-	 * Set 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(Setter::class)->addSetter($this->name, $class, $method);
-		return true;
-	}
-
-
-}

BackupCommand.php

@@ -0,0 +1,288 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+use Co\Channel;
+use Exception;
+use Swoole\Coroutine;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+
+/**
+ *
+ */
+class BackupCommand extends Command
+{
+
+    public string $command = 'db:backup';
+
+
+    public string $description = 'php kiri.php db:backup --database users --table u_user --data 1 /Users/admin/snowflake-bi/test.sql';
+
+
+
+    public array $percentStatus = [];
+
+
+    /**
+     *
+     */
+    protected function configure()
+    {
+        $this->setName('db:backup')
+             ->addOption('data', 'd', InputArgument::OPTIONAL)
+             ->addArgument('path', InputArgument::REQUIRED, "save to path", null)
+             ->addOption('table', 't', InputArgument::OPTIONAL)
+             ->addOption('database', 'db', InputArgument::OPTIONAL)
+             ->setDescription('php kiri.php db:backup --database users --table u_user --data 1 /Users/admin/snowflake-bi/test.sql');
+    }
+
+
+    /**
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @return int
+     * @throws Exception
+     */
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        try {
+            /** @var Connection $data */
+            $data = \Kiri::getDi()->get(DatabasesProviders::class)->get($input->getOption('database'));
+
+            $table = $input->getOption('table');
+            if ($table !== null) {
+                $table = explode(',', $table);
+            } else {
+                $tmp   = $data->createCommand('show tables from `' . $data->database . '`')->all();
+                $table = [];
+                foreach ($tmp as $value) {
+                    $table[] = current($value);
+                }
+            }
+
+            $path = $input->getArgument('path');
+            if (!str_starts_with($path, '/')) {
+                $path = APP_PATH . $path;
+            }
+
+            $isData = $input->getOption('data');
+            if (!is_dir($path)) {
+                mkdir($path);
+            }
+
+            $waite = new Coroutine\WaitGroup();
+            foreach ($table as $value) {
+                $tableInfo = $data->createCommand('show create table `' . $data->database . '`.`' . $value . '`')->one();
+
+                $tmp = rtrim($path, '/') . '/' . current($tableInfo) . '.sql';
+                if (!file_exists($tmp)) {
+                    touch($tmp);
+                }
+
+                file_put_contents($tmp, '');
+
+                $tableCreator = next($tableInfo);
+                if (preg_match('/AUTO_INCREMENT=\d+\s/', $tableCreator)) {
+                    $tableCreator = preg_replace('/AUTO_INCREMENT=\d+\s/', 'AUTO_INCREMENT=1 ', $tableCreator);
+                }
+
+                file_put_contents($tmp, $tableCreator . ';' . PHP_EOL . PHP_EOL, FILE_APPEND);
+
+                if ($isData == 1) {
+                    $waite->add(1);
+                    Coroutine::create(function () use ($waite, $input, $value, $tmp) {
+                        defer(function () use ($waite) {
+                            $waite->done();
+                        });
+                        $this->writeData($input->getOption('database'), $value, $tmp);
+                    });
+                }
+            }
+
+            $waite->wait();
+
+            $output->write('dump data success');
+        } catch (\Throwable $throwable) {
+            $output->writeln(throwable($throwable));
+        } finally {
+            return 1;
+        }
+    }
+
+
+    public bool $isEnd = false;
+
+
+    /**
+     * @param string $dbname
+     * @param string $tableName
+     * @param string $path
+     * @return void
+     * @throws Exception
+     */
+    public function writeData(string $dbname, string $tableName, string $path): void
+    {
+        $offset = 0;
+        $size   = 1000;
+
+        $channel = new Channel(200);
+        for ($i = 0; $i < 200; $i++) {
+            Coroutine::create(function () use ($channel, $path, $dbname, $tableName) {
+                while ($channel->errCode != SWOOLE_CHANNEL_CLOSED) {
+                    if (($data = $channel->pop()) === false) {
+                        break;
+                    }
+                    if (($value = json_decode($data, true)) === null) {
+                        continue;
+                    }
+
+                    $value = $this->toSql($dbname, $tableName, $value);
+
+                    file_put_contents($path, $value . PHP_EOL, FILE_APPEND);
+                }
+            });
+        }
+
+        $id = Coroutine::create(function () use ($channel) {
+            $data = Coroutine::waitSignal(SIGTERM | SIGINT);
+            if ($data) {
+                $this->isEnd = true;
+            }
+        });
+
+        /** @var Connection $database */
+        $database = \Kiri::getDi()->get(DatabasesProviders::class)->get($dbname);
+
+        $total = $database->createCommand("SELECT COUNT(*) as total FROM " . $tableName)->one()['total'];
+
+        $startTime = time();
+
+        $wait = new Coroutine\WaitGroup();
+        while ($this->isEnd === false && $offset < $total) {
+            $wait->add(1);
+            Coroutine::create(function () use ($wait, $offset, $size, $total, $dbname, $tableName, $channel) {
+                defer(function () use ($wait) {
+                    $wait->done();
+                });
+                /** @var Connection $database */
+                $database = \Kiri::getDi()->get(DatabasesProviders::class)->get($dbname);
+
+                $data = $database->createCommand("SELECT * FROM $tableName LIMIT $offset,$size")->all();
+                if (is_bool($data) || count($data) < 1) {
+                    return;
+                }
+                $channel->push(json_encode($data));
+
+                $this->percentStatus[$dbname . $tableName] = intval(round(($offset + $size) / $total, 2) * 100);
+
+                $this->outputProgress(true);
+            });
+            $offset += $size;
+        }
+
+        $wait->wait();
+
+        echo 'use time ' . (time() - $startTime) . 's' . PHP_EOL;
+
+        $channel->close();
+
+        Coroutine::cancel($id);
+    }
+
+
+    /**
+     * @param string $dbname
+     * @param string $value
+     * @param array $data
+     * @return string
+     */
+    public function toSql(string $dbname, string $value, array $data): string
+    {
+        $strings = ['INSERT INTO ' . $dbname . '.' . $value, '(' . implode(',', array_keys($data[0])) . ') VALUES'];
+        foreach ($data as $datum) {
+            $keys   = array_values($datum);
+            $encode = [];
+            foreach ($keys as $val) {
+                if (is_string($val)) {
+                    $encode[] = '\'' . addcslashes($val, "\\'") . '\'';
+                } else {
+                    $encode[] = $val === '' ? '\'\'' : $val;
+                }
+            }
+            $strings[] = '(' . implode(',', $encode) . '),';
+        }
+        return rtrim(implode('', $strings), ',') . ';';
+    }
+
+
+    /**
+     * @param $key
+     * @param $percent
+     * @return string
+     * 组合成进度条
+     */
+    public function buildLine($key, $percent): string
+    {
+        $repeatTimes = 100;
+        if ($percent > 100) $percent = 100;
+        if ($percent > 0) {
+            $hasColor = str_repeat('■', $percent);
+        } else {
+            $hasColor = '';
+        }
+        if ($repeatTimes - $percent > 0) {
+            $noColor = str_repeat(' ', $repeatTimes - $percent);
+        } else {
+            $noColor = '';
+        }
+        if ($percent !== 100) {
+            $percentString = sprintf("[  %s %-6s]", $key, $percent . '%');
+        } else {
+            $percentString = sprintf("[  %s %-5s]", $key, 'OK');;
+        }
+        return $percentString . "[{$hasColor}{$noColor}]" . "\r";
+    }
+
+    /**
+     * @param bool $clear
+     * @return void
+     * 输出进度条
+     */
+    public function outputProgress(bool $clear = false): void
+    {
+        if ($clear) {
+            $number = count($this->percentStatus);
+            for ($i = 0; $i < $number; $i++) {
+                system("tput cuu1");
+                system("tput el");
+            }
+        }
+        foreach ($this->percentStatus as $key => $value) {
+            echo $this->buildLine($key, $value) . "\n";
+        }
+    }
+
+    /**
+     * @param $k
+     * @param $value
+     * @return void
+     * 更新进度条值
+     */
+    public function updateProgressValue($k, $value): void
+    {
+        $this->percentStatus[$k] = $value;
+        if ($this->percentStatus[$k] >= 1000) {
+            $this->percentStatus[$k] = 1000;
+            $this->outputProgress(true);
+            return;
+        }
+        $this->outputProgress(true);
+        usleep(50000);
+    }
+
+}

Base/AbstractCollection.php

@@ -13,8 +13,6 @@ namespace Database\Base;
 use ArrayIterator;
 use Database\ActiveQuery;
 use Database\ModelInterface;
-use Kiri\ToArray;
-use Exception;
 use JetBrains\PhpStorm\Pure;
 use Kiri\Abstracts\Component;
 use ReturnTypeWillChange;
@@ -24,40 +22,36 @@ use Traversable;
  * Class AbstractCollection
  * @package Database\Base
  */
-abstract class AbstractCollection extends Component implements \IteratorAggregate, \ArrayAccess, ToArray
+abstract class AbstractCollection extends Component implements \IteratorAggregate, \ArrayAccess, \Arrayable
 {
 
     /**
      * @var ModelInterface[]
      */
-    protected array $_item = [];
+    private array $_item;
-
-    protected ModelInterface|string|null $model;
-
-    protected ActiveQuery $query;
 
 
-    public function clean()
+    /**
+     * @return array
+     */
+    public function getItems(): array
     {
-        unset($this->query, $this->model, $this->_item);
+        // TODO: Change the autogenerated stub
+        return $this->_item;
     }
 
 
-	/**
+    /**
-	 * Collection constructor.
+     * Collection constructor.
-	 *
+     *
-	 * @param $query
+     * @param ActiveQuery $query
-	 * @param array $array
+     * @param array $array
-	 * @param ModelInterface|null $model
+     * @param ModelInterface|null $model
-	 * @throws Exception
+     */
-	 */
+    public function __construct(public ActiveQuery $query, public ?ModelInterface $model = null, array $array = [])
-    public function __construct($query, array $array = [], ModelInterface $model = null)
     {
         $this->_item = $array;
-        $this->query = $query;
+        parent::__construct();
-        $this->model = $model;
-
-        parent::__construct([]);
     }
 
 
@@ -73,7 +67,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param $item
      */
-    public function setItems($item)
+    public function setItems($item): void
     {
         $this->_item = $item;
     }
@@ -82,7 +76,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param $model
      */
-    public function setModel($model)
+    public function setModel($model): void
     {
         $this->model = $model;
     }
@@ -90,14 +84,14 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param $item
      */
-    public function addItem($item)
+    public function addItem($item): void
     {
         $this->_item[] = $item;
     }
 
     /**
      * @return Traversable|CollectionIterator|ArrayIterator
-     * @throws Exception
+     * @throws
      */
     public function getIterator(): Traversable|CollectionIterator|ArrayIterator
     {
@@ -107,7 +101,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
 
     /**
      * @return mixed
-     * @throws Exception
+     * @throws
      */
     public function getModel(): ModelInterface
     {
@@ -115,6 +109,15 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     }
 
 
+    /**
+     * @return ActiveQuery
+     */
+    public function makeNewQuery(): ActiveQuery
+    {
+        return $this->model::query();
+    }
+
+
     /**
      * @param mixed $offset
      * @return bool
@@ -127,7 +130,7 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param mixed $offset
      * @return ModelInterface|null
-     * @throws Exception
+     * @throws
      */
     public function offsetGet(mixed $offset): ?ModelInterface
     {
@@ -144,7 +147,8 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
      * @param mixed $offset
      * @param mixed $value
      */
-    #[ReturnTypeWillChange] public function offsetSet(mixed $offset, mixed $value)
+    #[ReturnTypeWillChange]
+    public function offsetSet(mixed $offset, mixed $value): void
     {
         $this->_item[$offset] = $value;
     }
@@ -153,7 +157,8 @@ abstract class AbstractCollection extends Component implements \IteratorAggregat
     /**
      * @param mixed $offset
      */
-    #[ReturnTypeWillChange] public function offsetUnset(mixed $offset)
+    #[ReturnTypeWillChange]
+    public function offsetUnset(mixed $offset): void
     {
         if ($this->offsetExists($offset)) {
             unset($this->_item[$offset]);

Base/ActiveQueryInterface.php

@@ -0,0 +1,270 @@
+<?php
+
+namespace Database\Base;
+
+use Closure;
+use Database\Collection;
+use Database\Traits\QueryTrait;
+
+interface ActiveQueryInterface
+{
+
+
+    /**
+     * @param string $column
+     * @param callable $callable
+     * @return QueryTrait
+     */
+    public function when(string $column, callable $callable): QueryTrait;
+
+
+    /**
+     * @param string $whereRaw
+     * @return QueryTrait
+     */
+    public function whereRaw(string $whereRaw): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @param string $value
+     * @return QueryTrait
+     */
+    public function whereLocate(string $column, string $value): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @return QueryTrait
+     */
+    public function whereNull(string $column): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @return QueryTrait
+     */
+    public function whereEmpty(string $column): QueryTrait;
+
+    /**
+     * @param string $column
+     * @return QueryTrait
+     */
+    public function whereNotEmpty(string $column): QueryTrait;
+
+    /**
+     * @param string $column
+     * @return QueryTrait
+     */
+    public function whereNotNull(string $column): QueryTrait;
+
+
+    /**
+     * @param string $alias
+     *
+     * @return QueryTrait select * from tableName as t1
+     *
+     * select * from tableName as t1
+     */
+    public function alias(string $alias = 't1'): QueryTrait;
+
+    /**
+     * @param string|Closure $tableName
+     *
+     * @return QueryTrait
+     */
+    public function from(string|Closure $tableName): QueryTrait;
+
+    /**
+     * @param string $tableName
+     * @param string $alias
+     * @param array $onCondition
+     * @param array $param
+     * @return QueryTrait
+     */
+    public function leftJoin(string $tableName, string $alias, array $onCondition, array $param = []): QueryTrait;
+
+    /**
+     * @param string $tableName
+     * @param string $alias
+     * @param array $onCondition
+     * @param array $param
+     * @return QueryTrait
+     */
+    public function rightJoin(string $tableName, string $alias, array $onCondition, array $param = []): QueryTrait;
+
+    /**
+     * @param string $tableName
+     * @param string $alias
+     * @param array $onCondition
+     * @param array $param
+     * @return QueryTrait
+     */
+    public function innerJoin(string $tableName, string $alias, array $onCondition, array $param = []): QueryTrait;
+
+    /**
+     * @param string $field
+     *
+     * @return QueryTrait
+     */
+    public function sum(string $field): QueryTrait;
+
+    /**
+     * @param string $field
+     * @return QueryTrait
+     */
+    public function max(string $field): QueryTrait;
+
+    /**
+     * @param string $lngField
+     * @param string $latField
+     * @param int|float $lng1
+     * @param int|float $lat1
+     *
+     * @return QueryTrait
+     */
+    public function distance(string $lngField, string $latField, int|float $lng1, int|float $lat1): QueryTrait;
+
+    /**
+     * @param string|array $column
+     * @param string $sort
+     *
+     * @return QueryTrait [
+     *
+     * [
+     *     'addTime',
+     *     'descTime desc'
+     * ]
+     */
+    public function orderBy(string|array $column, string $sort = 'DESC'): QueryTrait;
+
+    /**
+     * @param array $column
+     *
+     * @return QueryTrait
+     */
+    public function select(array $column = ['*']): QueryTrait;
+
+    /**
+     * @return QueryTrait
+     */
+    public function rand(): QueryTrait;
+
+    /**
+     * @param array|Closure|string $conditionArray
+     * @param string $opera
+     * @param null $value
+     * @return QueryTrait
+     */
+    public function whereOr(array|Closure|string $conditionArray = [], string $opera = '=', $value = null): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @param string $value
+     * @return QueryTrait
+     */
+    public function whereLike(string $column, string $value): QueryTrait;
+
+    /**
+     * @param string $column
+     * @param string $value
+     * @return QueryTrait
+     */
+    public function whereLeftLike(string $column, string $value): QueryTrait;
+
+    /**
+     * @param string $column
+     * @param string $value
+     * @return QueryTrait
+     */
+    public function whereRightLike(string $column, string $value): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @param string $value
+     * @return QueryTrait
+     */
+    public function whereNotLike(string $column, string $value): QueryTrait;
+
+
+    /**
+     * @param string $columns
+     * @param array|Closure $value
+     * @return QueryTrait
+     */
+    public function whereIn(string $columns, array|Closure $value): QueryTrait;
+
+
+    /**
+     * @param string $columns
+     * @param array $value
+     * @return QueryTrait
+     */
+    public function whereNotIn(string $columns, array $value): QueryTrait;
+
+    /**
+     * @param string $column
+     * @param int|float $start
+     * @param int|float $end
+     * @return QueryTrait
+     */
+    public function whereBetween(string $column, int|float $start, int|float $end): QueryTrait;
+
+    /**
+     * @param string $column
+     * @param int|float $start
+     * @param int|float $end
+     * @return QueryTrait
+     */
+    public function whereNotBetween(string $column, int|float $start, int|float $end): QueryTrait;
+
+    /**
+     * @param array|string $column
+     * @param mixed|null $value
+     * @return QueryTrait
+     */
+    public function where(array|string $column, mixed $value = null): QueryTrait;
+
+
+    /**
+     * @param string $column
+     * @param string $opera
+     * @param mixed $value
+     * @return QueryTrait
+     */
+    public function whereMath(string $column, string $opera, mixed $value): QueryTrait;
+
+
+    /**
+     * @param Closure $closure
+     * @return QueryTrait
+     */
+    public function whereClosure(Closure $closure): QueryTrait;
+
+
+    /**
+     * @param string $name
+     * @param string|null $having
+     *
+     * @return QueryTrait
+     */
+    public function groupBy(string $name, string $having = NULL): QueryTrait;
+
+    /**
+     * @param int $limit
+     *
+     * @return QueryTrait
+     */
+    public function limit(int $limit = 20): QueryTrait;
+
+
+    /**
+     * @param int $offset
+     * @return QueryTrait
+     */
+    public function offset(int $offset): QueryTrait;
+
+
+}

Base/CollectionIterator.php

@@ -5,9 +5,7 @@ declare(strict_types=1);
 namespace Database\Base;
 
 
-use Database\ActiveQuery;
 use Database\ModelInterface;
-use Exception;
 
 
 /**
@@ -17,45 +15,48 @@ use Exception;
 class CollectionIterator extends \ArrayIterator
 {
 
-	private ModelInterface|string $model;
+
+    /**
+     * @var ModelInterface|string
+     */
+    private ModelInterface|string $model;
 
 
-
+    /**
-	/**
+     * CollectionIterator constructor.
-	 * CollectionIterator constructor.
+     * @param $model
-	 * @param $model
+     * @param array $array
-	 * @param array $array
+     * @param int $flags
-	 * @param int $flags
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    public function __construct($model, array $array = [], int $flags = 0)
-	public function __construct($model, array $array = [], int $flags = 0)
+    {
-	{
+        $this->model = $model;
-		$this->model = $model;
+        parent::__construct($array, $flags);
-		parent::__construct($array, $flags);
+    }
-	}
 
 
-	/**
+    /**
-	 * @param $current
+     * @param $current
-	 * @return ModelInterface
+     * @return ModelInterface
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	protected function newModel($current): ModelInterface
+    protected function newModel($current): ModelInterface
-	{
+    {
-		return $this->model->populates($current);
+        return $this->model->populates($current);
-	}
+    }
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function current(): ModelInterface
+    public function current(): ModelInterface
-	{
+    {
-		if (is_array($current = parent::current())) {
+        if (is_array($current = parent::current())) {
-			$current = $this->newModel($current);
+            $current = $this->newModel($current);
-		}
+        }
-		return $current;
+        return $current;
-	}
+    }
 
 
 }

Base/ConditionClassMap.php

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

Base/Getter.php

@@ -1,35 +0,0 @@
-<?php
-
-namespace Database\Base;
-
-class Getter
-{
-
-	private array $_classMapping = [];
-
-
-	/**
-	 * @param $name
-	 * @param $class
-	 * @param $method
-	 */
-	public function addGetter($name, $class, $method)
-	{
-		$this->_classMapping[$class][$name] = $method;
-	}
-
-
-	/**
-	 * @param $class
-	 * @param null $name
-	 * @return array|string|null
-	 */
-	public function getGetter($class, $name = null): null|array|string
-	{
-		if (!empty($name)) {
-			return $this->_classMapping[$class][$name] ?? null;
-		}
-		return $this->_classMapping[$class] ?? [];
-	}
-
-}

Base/PDO.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Database\Base;
+
+class PDO extends \PDO
+{
+
+
+    /**
+     * @param string $database
+     * @param string $host
+     * @param string $username
+     * @param string $password
+     * @param array $options
+     */
+    public function __construct(
+        readonly public string $database,
+        readonly public string $host,
+        readonly public string $username,
+        readonly public string $password,
+        readonly public array  $options,
+    )
+    {
+        parent::__construct('mysql:dbname=' . $this->database . ';host=' . $this->host, $this->username, $this->password, $this->options);
+    }
+
+
+}

Base/Relate.php

@@ -1,36 +0,0 @@
-<?php
-
-namespace Database\Base;
-
-class Relate
-{
-
-	private array $_classMapping = [];
-
-
-	/**
-	 * @param $name
-	 * @param $class
-	 * @param $method
-	 */
-	public function addRelate($name, $class, $method)
-	{
-		$this->_classMapping[$class][$name] = $method;
-	}
-
-
-	/**
-	 * @param $class
-	 * @param $name
-	 * @return null|array|string
-	 */
-	public function getRelate($class, $name = null): null|array|string
-	{
-		if (!empty($name)) {
-			return $this->_classMapping[$class][$name] ?? null;
-		}
-		return $this->_classMapping[$class] ?? [];
-	}
-
-
-}

Base/Setter.php

@@ -1,32 +0,0 @@
-<?php
-
-namespace Database\Base;
-
-class Setter
-{
-
-	private array $_classMapping = [];
-
-
-	/**
-	 * @param $name
-	 * @param $class
-	 * @param $method
-	 */
-	public function addSetter($name, $class, $method)
-	{
-		$this->_classMapping[$class][$name] = $method;
-	}
-
-
-	/**
-	 * @param $class
-	 * @param $name
-	 * @return null|array|string
-	 */
-	public function getSetter($class, $name): null|array|string
-	{
-		return $this->_classMapping[$class][$name] ?? null;
-	}
-
-}

Collection.php

@@ -21,223 +21,214 @@ use JetBrains\PhpStorm\Pure;
 class Collection extends AbstractCollection
 {
 
-	/**
-	 * @return array
-	 */
-	public function getItems(): array
-	{
-		// TODO: Change the autogenerated stub
-		return $this->_item;
-	}
 
-	/**
+    /**
-	 * @param $field
+     * @param string $field
-	 *
+     *
-	 * @return array|null
+     * @return array|null
-	 * @throws Exception
+     */
-	 */
+    public function values(string $field): ?array
-	public function values($field): ?array
+    {
-	{
+        return array_values($this->column($field));
-		if (empty($field) || !is_string($field)) {
+    }
-			return NULL;
-		}
-		$_tmp = [];
-		$data = $this->toArray();
-		foreach ($data as $val) {
-			/** @var ModelInterface $val */
-			$_tmp[] = $val[$field];
-		}
-		return $_tmp;
-	}
-
-	/**
-	 * @param string $field
-	 * @return array|null
-	 */
-	public function keyBy(string $field): ?array
-	{
-		$array = $this->toArray();
-		$column = array_flip(array_column($array, $field));
-		foreach ($column as $key => $value) {
-			$column[$key] = $array[$value];
-		}
-
-		return $column;
-	}
-
-	/**
-	 * @return $this
-	 */
-	public function orderRand(): static
-	{
-		shuffle($this->_item);
-		return $this;
-	}
-
-	/**
-	 * @param int $start
-	 * @param int $length
-	 *
-	 * @return array
-	 */
-	#[Pure] public function slice(int $start = 0, int $length = 20): array
-	{
-		if (empty($this->_item) || !is_array($this->_item)) {
-			return [];
-		}
-		if (count($this->_item) < $length) {
-			return $this->_item;
-		} else {
-			return array_slice($this->_item, $start, $length);
-		}
-	}
-
-	/**
-	 * @param string $field
-	 * @param string $setKey
-	 *
-	 * @return array|null
-	 */
-	public function column(string $field, string $setKey = ''): ?array
-	{
-		$data = $this->toArray();
-		if (empty($data)) {
-			return [];
-		}
-		if (!empty($setKey) && is_string($setKey)) {
-			return array_column($data, $field, $setKey);
-		} else {
-			return array_column($data, $field);
-		}
-	}
-
-	/**
-	 * @param string $field
-	 *
-	 * @return float|int|null
-	 */
-	public function sum(string $field): float|int|null
-	{
-		$array = $this->column($field);
-		if (empty($array)) {
-			return NULL;
-		}
-		return array_sum($array);
-	}
-
-	/**
-	 * @return ModelInterface|array
-	 */
-	#[Pure] public function current(): ModelInterface|array
-	{
-		return current($this->_item);
-	}
-
-	/**
-	 * @return int
-	 */
-	#[Pure] public function size(): int
-	{
-		return (int)count($this->_item);
-	}
-
-	/**
-	 * @return array
-	 * @throws
-	 */
-	public function toArray(): array
-	{
-		$array = [];
-		/** @var Model $value */
-		foreach ($this as $value) {
-			if (!is_object($value)) {
-				continue;
-			}
-			$array[] = $value->setWith($this->query->with)->toArray();
-		}
-		$this->_item = [];
-		return $array;
-	}
-
-	/**
-	 * @throws Exception
-	 * 批量删除
-	 */
-	public function delete(): bool
-	{
-		$model = $this->getModel();
-		if (!$model->hasPrimary()) return false;
-		$ids = [];
-		foreach ($this as $item) {
-			$id = $item->getPrimaryValue();
-			if (!empty($id)) {
-				$ids[] = $id;
-			}
-		}
-		return $model::query()->whereIn($model->getPrimary(), $ids)->delete();
-	}
-
-	/**
-	 * @param array $condition
-	 * @return Collection
-	 * @throws
-	 */
-	public function filter(array $condition): Collection|static
-	{
-		$_filters = [];
-		if (empty($condition)) {
-			return $this;
-		}
-		foreach ($this as $value) {
-			if (!$this->filterCheck($value, $condition)) {
-				continue;
-			}
-			$_filters[] = $value;
-		}
-		return new Collection($this->query, $_filters, $this->model);
-	}
 
 
-	/**
+    /**
-	 * @param $value
+     * @param array $attributes
-	 * @param $condition
+     * @return bool
-	 * @return bool
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    public function update(array $attributes): bool
-	private function filterCheck($value, $condition): bool
+    {
-	{
+        if ($this->isEmpty()) {
-		$_value = $value;
+            return $this->getLogger()->failure('No data by update', 'mysql');
-		if ($_value instanceof ModelInterface) {
+        }
-			$_value = $_value->toArray();
+        return $this->batch()->update($attributes);
-		}
+    }
-		$_tmp = array_intersect_key($_value, $condition);
+
-		if (count(array_diff_assoc($_tmp, $condition)) > 0) {
+    /**
-			return false;
+     * @param string $field
-		}
+     * @return array|null
-		return true;
+     */
-	}
+    public function keyBy(string $field): ?array
+    {
+        $array  = $this->toArray();
+        $column = array_flip(array_column($array, $field));
+        foreach ($column as $key => $value) {
+            $column[$key] = $array[$value];
+        }
+        return $column;
+    }
 
 
-	/**
+    /**
-	 * @param $key
+     * @param int $start
-	 * @param $value
+     * @param int $length
-	 * @return mixed
+     *
-	 */
+     * @return array
-	public function exists($key, $value): mixed
+     */
-	{
+    #[Pure] public function slice(int $start = 0, int $length = 20): array
-		foreach ($this as $item) {
+    {
-			if ($item->$key === $value) {
+        if (empty($this->getItems())) {
-				return $item;
+            return [];
-			}
+        }
-		}
+        if (\count($this->getItems()) < $length) {
-		return null;
+            return $this->getItems();
-	}
+        } else {
+            return array_slice($this->getItems(), $start, $length);
+        }
+    }
 
-	/**
+    /**
-	 * @return bool
+     * @param string $field
-	 */
+     * @param string $setKey
-	#[Pure] public function isEmpty(): bool
+     *
-	{
+     * @return array|null
-		return $this->size() < 1;
+     */
-	}
+    public function column(string $field, string $setKey = ''): ?array
+    {
+        $data = $this->toArray();
+        if (empty($data)) {
+            return [];
+        }
+        if (!empty($setKey) && is_string($setKey)) {
+            return array_column($data, $field, $setKey);
+        } else {
+            return array_column($data, $field);
+        }
+    }
+
+    /**
+     * @param string $field
+     *
+     * @return float|int|null
+     */
+    public function sum(string $field): float|int|null
+    {
+        $array = $this->column($field);
+        if (empty($array)) {
+            return NULL;
+        }
+        return array_sum($array);
+    }
+
+    /**
+     * @return ModelInterface|array
+     */
+    #[Pure] public function current(): ModelInterface|array
+    {
+        return current($this->getItems());
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function size(): int
+    {
+        return count($this->getItems());
+    }
+
+    /**
+     * @return array
+     * @throws
+     */
+    public function toArray(): array
+    {
+        $array = [];
+        /** @var Model $value */
+        foreach ($this as $value) {
+            $array[] = $value->toArray();
+        }
+        return $array;
+    }
+
+    /**
+     * @throws
+     * 批量删除
+     */
+    public function delete(): bool
+    {
+        $model = $this->getModel();
+        if ($this->isEmpty()) {
+            return $this->getLogger()->failure('No data by delete', 'mysql');
+        }
+        if (!$model->hasPrimary()) {
+            throw new Exception('Must set primary key. if you want to delete data');
+        }
+        return $this->batch()->delete();
+    }
+
+
+    /**
+     * @return ActiveQuery
+     * @throws Exception
+     */
+    private function batch(): ActiveQuery
+    {
+        return $this->makeNewQuery()->whereIn($this->getModel()->getPrimary(),
+            $this->column($this->getModel()->getPrimary()));
+    }
+
+    /**
+     * @param array $condition
+     * @return Collection
+     * @throws
+     */
+    public function filter(array $condition): Collection|static
+    {
+        $_filters = [];
+        if (empty($condition)) {
+            return $this;
+        }
+        foreach ($this as $value) {
+            if (!$this->filterCheck($value, $condition)) {
+                continue;
+            }
+            $_filters[] = $value;
+        }
+        return new Collection($this->query, $this->model, $_filters);
+    }
+
+
+    /**
+     * @param array|ModelInterface $value
+     * @param array $condition
+     * @return bool
+     */
+    private function filterCheck(array|ModelInterface $value, array $condition): bool
+    {
+        $_value = $value;
+        if ($_value instanceof ModelInterface) {
+            $_value = $_value->toArray();
+        }
+        $_tmp = array_intersect_key($_value, $condition);
+        if (count(array_diff_assoc($_tmp, $condition)) > 0) {
+            return false;
+        }
+        return true;
+    }
+
+
+    /**
+     * @param string $key
+     * @param mixed $value
+     * @return mixed
+     */
+    public function exists(string $key, mixed $value): mixed
+    {
+        foreach ($this as $item) {
+            if ($item->$key === $value) {
+                return $item;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * @return bool
+     */
+    #[Pure] public function isEmpty(): bool
+    {
+        return $this->size() < 1;
+    }
 }

Command.php

@@ -12,8 +12,9 @@ namespace Database;
 
 use Exception;
 use Kiri\Abstracts\Component;
-use Kiri\Core\Json;
+use Kiri\Di\Container;
-use PDOStatement;
+use PDO;
+use Throwable;
 
 /**
  * Class Command
@@ -21,175 +22,207 @@ use PDOStatement;
  */
 class Command extends Component
 {
-	const ROW_COUNT = 'ROW_COUNT';
-	const FETCH = 'FETCH';
-	const FETCH_ALL = 'FETCH_ALL';
-	const EXECUTE = 'EXECUTE';
-	const FETCH_COLUMN = 'FETCH_COLUMN';
 
-	/** @var Connection */
+    public Connection $connection;
-	public Connection $db;
+    public ?string    $sql    = '';
+    public array      $params = [];
 
-	/** @var ?string */
+    /**
-	public ?string $sql = '';
+     * @param array $params
-
+     * @throws
-	/** @var array */
+     */
-	public array $params = [];
+    public function __construct(array $params = [])
-
+    {
-	/** @var string */
+        parent::__construct();
-	public string $dbname = '';
+        Container::configure($this, $params);
+    }
 
 
-	/**
+    /**
-	 * @return array|bool|int|string|PDOStatement|null
+     * @return bool
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function incrOrDecr(): array|bool|int|string|PDOStatement|null
+    public function incrOrDecr(): bool
-	{
+    {
-		return $this->execute(static::EXECUTE);
+        return (bool)$this->_prepare();
-	}
+    }
-
-	/**
-	 * @return int|bool|array|string|null
-	 * @throws Exception
-	 */
-	public function save(): int|bool|array|string|null
-	{
-		return $this->execute(static::EXECUTE);
-	}
 
 
-	/**
+    /**
-	 * @return int|bool|array|string|null
+     * @return bool|array
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function all(): int|bool|array|string|null
+    public function all(): bool|array
-	{
+    {
-		return $this->execute(static::FETCH_ALL);
+        return $this->search('fetchAll');
-	}
+    }
 
-	/**
+    /**
-	 * @return array|bool|int|string|null
+     * @return array|bool|null
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function one(): null|array|bool|int|string
+    public function one(): array|null|bool
-	{
+    {
-		return $this->execute(static::FETCH);
+        return $this->search('fetch');
-	}
+    }
 
-	/**
+    /**
-	 * @return int|bool|array|string|null
+     * @return bool
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function fetchColumn(): int|bool|array|string|null
+    public function exists(): bool
-	{
+    {
-		return $this->execute(static::FETCH_COLUMN);
+        $data = $this->search('fetch');
-	}
+        if (!$data) {
+            return false;
+        }
+        return true;
+    }
 
-	/**
+    /**
-	 * @return int|bool|array|string|null
+     * @return mixed
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function rowCount(): int|bool|array|string|null
+    public function fetchColumn(): mixed
-	{
+    {
-		return $this->execute(static::ROW_COUNT);
+        return $this->search('fetchColumn');
-	}
+    }
 
-	/**
+    /**
-	 * @return int|bool|array|string|null
+     * @return mixed
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function flush(): int|bool|array|string|null
+    public function rowCount(): int
-	{
+    {
-		return $this->execute(static::EXECUTE);
+        $data = $this->search('fetch');
-	}
 
-	/**
+        return !$data ? 0 : +current($data);
-	 * @param string $type
+    }
-	 * @return int|bool|array|string|null
-	 * @throws Exception
-	 */
-	private function execute(string $type): int|bool|array|string|null
-	{
-		try {
-			$time = microtime(true);
-			if ($type === static::EXECUTE) {
-				$result = $this->db->getConnect($this->sql)->execute($this->sql,$this->params);
-			} else {
-				$result = $this->search($type);
-			}
-			if (microtime(true) - $time >= 0.02) {
-				$this->warning('Mysql:' . Json::encode([$this->sql, $this->params]) . (microtime(true) - $time));
-			}
-		} catch (\Throwable $exception) {
-			$result = $this->addError($this->sql . '. error: ' . $exception->getMessage(), 'mysql');
-		} finally {
-			$this->db->release();
-			return $result;
-		}
-	}
 
 
-	/**
+    /**
-	 * @param string $type
+     * @param string $method
-	 * @return array|int|bool|null
+     * @return mixed
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	private function search(string $type): array|int|bool|null
+    protected function search(string $method): mixed
-	{
+    {
-		$pdo = $this->db->getConnect($this->sql);
+        $client = $this->connection->getConnection();
-		if ($type === static::FETCH_COLUMN) {
+        try {
-			$data = $pdo->fetchColumn($this->sql, $this->params);
+            if (($prepare = $client->prepare($this->sql)) === false) {
-		} else if ($type === static::ROW_COUNT) {
+                throw new Exception('(' . $prepare->errorInfo()[0] . ')' . $client->errorInfo()[2]);
-			$data = $pdo->count($this->sql, $this->params);
+            }
-		} else if ($type === static::FETCH_ALL) {
+
-			$data = $pdo->fetchAll($this->sql, $this->params);
+            $prepare->execute($this->params);
-		} else {
+
-			$data = $pdo->fetch($this->sql, $this->params);
+            $result = $method == 'rowCount' ? $prepare->rowCount() : $prepare->{$method}(PDO::FETCH_ASSOC);
-		}
+            $prepare->closeCursor();
-		return $data;
+
-	}
+            $this->connection->println($this->sql, $this->params);
+
+            return $result;
+        } catch (Throwable $throwable) {
+            if ($this->isRefresh($throwable)) return $this->search($method);
+
+            $errorMsg = $throwable->getMessage() . PHP_EOL . '                 Sql: ' . $this->sql . '.' . json_encode($this->params);
+
+            return $this->getLogger()->failure($errorMsg . PHP_EOL, 'mysql');
+        } finally {
+            $this->connection->release($client);
+        }
+    }
 
 
-	/**
+    /**
-	 * @return int|bool|array|string|null
+     * @return bool
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function delete(): int|bool|array|string|null
+    public function flush(): bool
-	{
+    {
-		return $this->execute(static::EXECUTE);
+        return (bool)$this->_prepare();
-	}
+    }
 
-	/**
-	 * @return int|bool|array|string|null
-	 * @throws Exception
-	 */
-	public function exec(): int|bool|array|string|null
-	{
-		return $this->execute(static::EXECUTE);
-	}
 
-	/**
+    /**
-	 * @param array $data
+     * @return int|bool
-	 * @return $this
+     * @throws
-	 */
+     */
-	public function bindValues(array $data = []): static
+    private function _prepare(): int|bool
-	{
+    {
-		if (!empty($data)) {
+        $client = $this->connection->getConnection();
-			$this->params = array_merge($this->params, $data);
+        try {
-		}
+            if (($prepare = $client->prepare($this->sql)) === false) {
-		return $this;
+                throw new Exception('(' . $prepare->errorInfo()[0] . ')' . $prepare->errorInfo()[2]);
-	}
+            }
+            if ($prepare->execute($this->params) === false) {
+                throw new Exception('(' . $prepare->errorInfo()[0] . ')' . $prepare->errorInfo()[2]);
+            }
+            $prepare->closeCursor();
 
-	/**
+            $result = $client->lastInsertId();
-	 * @param $sql
+
-	 * @return $this
+            $this->connection->println($this->sql, $this->params);
-	 * @throws Exception
+
-	 */
+            return $result == 0 ? $prepare->rowCount() : (int)$result;
-	public function setSql($sql): static
+        } catch (Throwable $throwable) {
-	{
+            if ($this->isRefresh($throwable)) return $this->_prepare();
-		$this->sql = $sql;
+
-		return $this;
+            $errorMsg = $throwable->getMessage() . PHP_EOL . '                 Sql: ' . $this->sql . '.' . json_encode($this->params);
-	}
+
+            return $this->getLogger()->failure($errorMsg . PHP_EOL, 'mysql');
+        } finally {
+            $this->connection->release($client);
+        }
+    }
+
+
+    /**
+     * @param Throwable $throwable
+     * @return bool
+     */
+    protected function isRefresh(Throwable $throwable): bool
+    {
+        if (str_contains($throwable->getMessage(), 'MySQL server has gone away')) {
+            return true;
+        }
+        if (str_contains($throwable->getMessage(), 'Send of 14 bytes failed with errno=32 Broken pipe')) {
+            return true;
+        }
+        if (str_contains($throwable->getMessage(), 'Lost connection to MySQL server during query')) {
+            return true;
+        }
+        return false;
+    }
+
+
+    /**
+     * @return bool
+     * @throws
+     */
+    public function delete(): bool
+    {
+        return (bool)$this->_prepare();
+    }
+
+
+    /**
+     * @return int|bool
+     */
+    public function exec(): int|bool
+    {
+        return $this->_prepare();
+    }
+
+    /**
+     * @param array $data
+     * @return $this
+     */
+    public function bindValues(array $data = []): static
+    {
+        if (count($data) > 0) {
+            $this->params = array_merge($this->params, $data);
+        }
+        return $this;
+    }
 
 }

Condition/Condition.php

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

Condition/DefaultCondition.php

@@ -18,7 +18,7 @@ class DefaultCondition extends Condition
 	 */
 	#[Pure] public function builder(): string
 	{
-		return sprintf('%s %s %s', $this->column, $this->opera, addslashes($this->value));
+		return $this->column . ' ' . $this->opera . ' ' . addslashes($this->value);
 	}
 
 }

Condition/HashCondition.php

@@ -10,21 +10,20 @@ namespace Database\Condition;
 class HashCondition extends Condition
 {
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 */
+     * @throws
-	public function builder(): string
+     */
-	{
+    public function builder(): string
-		$array = [];
+    {
-		if (empty($this->value)) {
+        $array = [];
-			return '';
+        if (count($this->value) < 1) {
-		}
+            throw new \Exception('Builder data by a empty array.');
-		foreach ($this->value as $key => $value) {
+        }
-			if (is_null($value)) continue;
+        foreach ($this->value as $key => $value) {
-
+            $array[] = $key . '=' . addslashes($value);
-			$array[] = sprintf("%s = '%s'", $key, addslashes($value));
+        }
-		}
+        return implode(' AND ', $array);
-		return implode(' AND ', $array);
+    }
-	}
 
 }

Condition/InCondition.php

@@ -3,8 +3,6 @@ declare(strict_types=1);
 
 namespace Database\Condition;
 
-use Database\ActiveQuery;
-use Exception;
 use JetBrains\PhpStorm\Pure;
 
 /**
@@ -15,17 +13,17 @@ class InCondition extends Condition
 {
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	#[Pure] public function builder(): string
+    #[Pure] public function builder(): string
-	{
+    {
-		if (is_array($this->value)) {
+        if (is_array($this->value)) {
-			return sprintf('%s IN (%s)', $this->column, implode(',', $this->value));
+            return $this->column . ' IN (' . implode(',', $this->value) . ')';
-		} else {
+        } else {
-			return sprintf('%s IN (%s)', $this->column, $this->value);
+            return $this->column . ' IN (' . $this->value . ')';
-		}
+        }
-	}
+    }
 
 }

Condition/JsonCondition.php

@@ -12,9 +12,13 @@ class JsonCondition extends Condition
 {
 
 
-	public function builder()
+    /**
-	{
+     * @return bool
+     */
+	public function builder(): bool
+    {
 		// TODO: Implement builder() method.
+        return \json_validate($this->value);
 	}
 
 }

Condition/LLikeCondition.php

@@ -3,8 +3,6 @@ declare(strict_types=1);
 
 namespace Database\Condition;
 
-use Kiri\Core\Str;
-
 /**
  * Class LLikeCondition
  * @package Database\Condition

Condition/LikeCondition.php

@@ -3,8 +3,6 @@ declare(strict_types=1);
 
 namespace Database\Condition;
 
-use Kiri\Core\Str;
-
 /**
  * Class LikeCondition
  * @package Database\Condition

Condition/NotInCondition.php

@@ -13,16 +13,17 @@ class NotInCondition extends Condition
 {
 
 
-	/**
+    /**
-	 * @return string|null
+     * @return string|null
-	 */
+     * @throws
-	#[Pure] public function builder(): ?string
+     */
-	{
+    #[Pure] public function builder(): ?string
-		if (!is_array($this->value)) {
+    {
-			return null;
+        if (!is_array($this->value)) {
-		}
+            throw new \Exception('Builder data by a empty string. need array');
-		$value = '\'' . implode('\',\'', $this->value) . '\'';
+        }
-		return '`' . $this->column . '` not in(' . $value . ')';
+        $value = '\'' . implode('\',\'', $this->value) . '\'';
-	}
+        return '`' . $this->column . '` not in(' . $value . ')';
+    }
 
 }

Condition/NotLikeCondition.php

@@ -3,8 +3,6 @@ declare(strict_types=1);
 
 namespace Database\Condition;
 
-use Kiri\Core\Str;
-
 /**
  * Class NotLikeCondition
  * @package Database\Condition

Condition/OrCondition.php

@@ -21,7 +21,7 @@ class OrCondition extends Condition
 	 */
 	#[Pure] public function builder(): string
 	{
-		return sprintf('(%s) OR %s', implode(' AND ', $this->oldParams), addslashes($this->value));
+		return '(' . implode(' AND ', $this->oldParams) . ') OR ' . addslashes($this->value);
 	}
 
 }

Condition/RLikeCondition.php

@@ -3,8 +3,6 @@ declare(strict_types=1);
 
 namespace Database\Condition;
 
-use Kiri\Core\Str;
-
 /**
  * Class RLikeCondition
  * @package Database\Condition

Connection.php

@@ -14,18 +14,23 @@ namespace Database;
 use Database\Affair\BeginTransaction;
 use Database\Affair\Commit;
 use Database\Affair\Rollback;
-use Database\Mysql\PDO;
-use Database\Mysql\Schema;
 use Exception;
+use Kiri;
+use Kiri\Server\Events\OnWorkerExit;
 use Kiri\Abstracts\Component;
-use Kiri\Abstracts\Config;
+use Kiri\Di\Context;
+use Kiri\Pool\Pool;
 use Kiri\Events\EventProvider;
-use Kiri\Exception\NotFindClassException;
+use Kiri\Error\StdoutLogger;
-use Kiri\Kiri;
+use Psr\Log\LoggerInterface;
-use Kiri\Annotation\Inject;
+use Kiri\Server\Events\OnWorkerStart;
-use ReflectionException;
+use Kiri\Server\Events\OnTaskerStart;
-use Server\Events\OnWorkerExit;
+use Kiri\Server\Events\OnAfterRequest;
-use Server\Events\OnWorkerStop;
+use Kiri\Di\Inject\Container;
+use Swoole\Timer;
+use Database\Base\PDO;
+
+//use PDO;
 
 /**
  * Class Connection
@@ -34,300 +39,340 @@ use Server\Events\OnWorkerStop;
 class Connection extends Component
 {
 
-	public string $id = 'db';
+    public string       $id          = 'db';
-	public string $cds = '';
+    public string       $cds         = '';
-	public string $password = '';
+    public string       $password    = '';
-	public string $username = '';
+    public string       $username    = '';
-	public string $charset = 'utf-8';
+    public string       $charset     = 'utf-8';
-	public string $tablePrefix = '';
+    public string       $tablePrefix = '';
-
+    public string       $database    = '';
-	public string $database = '';
+    public int          $timeout     = 30;
-
+    public int          $waite_time  = 3;
-	public int $connect_timeout = 30;
+    public int          $tick_time   = 60;
-
+    public int          $idle_count  = 3;
-	public int $read_timeout = 10;
+    public int          $idle_time   = 60;
-
+    public array        $pool        = ['max' => 10, 'min' => 1];
-	public array $pool;
+    private int         $storey      = 0;
-
+    protected int       $timerId     = -1;
-	/**
+    public bool         $enableCache = false;
-	 * @var bool
+    public string       $cacheDriver = 'redis';
-	 * enable database cache
+    public array        $attributes  = [];
-	 */
+    public array        $slave       = [];
-	public bool $enableCache = false;
+    protected ?\Closure $_println    = null;
 
 
-	/**
+    /**
-	 * @var string
+     * @var StdoutLogger
-	 */
+     */
-	public string $cacheDriver = 'redis';
+    #[Container(LoggerInterface::class)]
+    public StdoutLogger $logger;
 
-	/**
+    /**
-	 * @var array
+     * @param Pool $connections
-	 */
+     */
-	public array $slaveConfig = [];
+    public function __construct(public Pool $connections)
-	public array $attributes = [];
+    {
+        parent::__construct();
+
+        $this->_println = \config('databases.logger', null);
+    }
 
 
-	private ?Schema $_schema = null;
+    /**
+     * @param string $sql
+     * @param array $params
+     * @return void
+     */
+    public function println(string $sql, array $params = []): void
+    {
+        if (is_callable($this->_println)) {
+            call_user_func($this->_println, $sql, $params);
+        }
+    }
 
 
-	/**
+    /**
-	 * execute by __construct
+     * @return void
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function init()
+    public function init(): void
-	{
+    {
-		$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(BeginTransaction::class, [$this, 'beginTransaction'], 0);
-		$this->eventProvider->on(BeginTransaction::class, [$this, 'beginTransaction'], 0);
+        $eventProvider->on(Rollback::class, [$this, 'rollback'], 0);
-		$this->eventProvider->on(Rollback::class, [$this, 'rollback'], 0);
+        $eventProvider->on(Commit::class, [$this, 'commit'], 0);
-		$this->eventProvider->on(Commit::class, [$this, 'commit'], 0);
+        $eventProvider->on(OnAfterRequest::class, [$this, 'clear']);
-	}
+        $eventProvider->on(OnWorkerExit::class, [$this, 'disconnect']);
+        $eventProvider->on(OnWorkerStart::class, [$this, 'tick']);
+        $eventProvider->on(OnTaskerStart::class, [$this, 'tick']);
+    }
 
 
-	/**
+    /**
-	 * @param null $sql
+     * @return void
-	 * @return PDO
+     */
-	 * @throws Exception
+    public function tick(): void
-	 */
+    {
-	public function getConnect($sql = NULL): PDO
+        $this->timerId = Timer::tick($this->tick_time, fn() => $this->checkClientHealth($this->pool()));
-	{
+    }
-		return $this->getPdo($sql);
-	}
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @param Pool $pool
-	 */
+     * @return void
-	public function fill()
+     * @throws
-	{
+     */
-		$connections = $this->connections();
+    protected function checkClientHealth(Pool $pool): void
-		$pool = Config::get('databases.pool.max', 10);
+    {
-
+        $pool->flush($this->getName(), $this->pool['min'] ?? 1);
-		$connections->initConnections('Mysql:' . $this->cds, true, $pool);
+        $length = $pool->size($this->getName());
-		if (!empty($this->slaveConfig) && $this->cds != $this->slaveConfig['cds']) {
+        for ($i = 0; $i < $length; $i++) {
-			$connections->initConnections('Mysql:' . $this->slaveConfig['cds'], false, $pool);
+            try {
-		}
+                if (($client = $this->validator($pool)) === false) {
-	}
+                    break;
+                }
+                $pool->push($this->getName(), $client);
+            } catch (\Throwable $exception) {
+                if (!str_contains($exception->getMessage(), 'Client timeout.')) {
+                    $this->logger->error(throwable($exception), [$this->cds]);
+                }
+            }
+        }
+    }
 
 
-	/**
+    /**
-	 * @param $sql
+     * @return string
-	 * @return PDO
+     */
-	 * @throws Exception
+    private function getName(): string
-	 */
+    {
-	private function getPdo($sql): PDO
+        return 'mysql.' . $this->cds;
-	{
+    }
-		if ($this->isWrite($sql)) {
-			return $this->masterInstance();
-		} else {
-			return $this->slaveInstance();
-		}
-	}
-
-	/**
-	 * @return mixed
-	 * @throws ReflectionException
-	 * @throws NotFindClassException
-	 * @throws Exception
-	 */
-	public function getSchema(): Schema
-	{
-		if ($this->_schema === null) {
-			$this->_schema = Kiri::createObject([
-				'class' => Schema::class,
-				'db'    => $this
-			]);
-		}
-		return $this->_schema;
-	}
-
-	/**
-	 * @param $sql
-	 * @return bool
-	 */
-	public function isWrite($sql): bool
-	{
-		if (empty($sql)) return false;
-		if (str_starts_with(strtolower($sql), 'select')) {
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * @return mixed
-	 * @throws Exception
-	 */
-	public function getCacheDriver(): mixed
-	{
-		if (!$this->enableCache) {
-			return null;
-		}
-		return Kiri::app()->get($this->cacheDriver);
-	}
-
-	/**
-	 * @return PDO
-	 * @throws Exception
-	 */
-	public function masterInstance(): PDO
-	{
-		return $this->connections()->get([
-			'cds'             => $this->cds,
-			'username'        => $this->username,
-			'password'        => $this->password,
-			'attributes'      => $this->attributes,
-			'connect_timeout' => $this->connect_timeout,
-			'read_timeout'    => $this->read_timeout,
-			'dbname'          => $this->database,
-			'pool'            => $this->pool
-		], true);
-	}
-
-	/**
-	 * @return PDO
-	 * @throws Exception
-	 */
-	public function slaveInstance(): PDO
-	{
-		if (empty($this->slaveConfig) || Db::transactionsActive()) {
-			return $this->masterInstance();
-		}
-		if ($this->slaveConfig['cds'] == $this->cds) {
-			return $this->masterInstance();
-		}
-		return $this->connections()->get($this->slaveConfig, false);
-	}
 
 
-	/**
+    /**
-	 * @return \Kiri\Pool\Connection
+     * @param Pool $pool
-	 * @throws Exception
+     * @return PDO|bool
-	 */
+     * @throws
-	private function connections(): \Kiri\Pool\Connection
+     */
-	{
+    protected function validator(Pool $pool): PDO|bool
-		return Kiri::getDi()->get(\Kiri\Pool\Connection::class);
+    {
-	}
+        /** @var $client PDO */
+        if (($client = $pool->get($this->getName())) === false) {
+            return false;
+        }
+        if ($client->query('select 1') === false) {
+            throw new Exception($client->errorInfo()[1]);
+        }
+        return $client;
+    }
 
 
-	/**
+    /**
-	 * @return $this
+     * @return PDO
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function beginTransaction(): static
+    public function getConnection(): PDO
-	{
+    {
-		$this->connections()->beginTransaction($this->cds);
+        if (!$this->inTransaction()) {
-		return $this;
+            return $this->getNormalClientHealth();
-	}
+        } else {
-
+            return $this->getTransactionClient();
-	/**
+        }
-	 * @return $this|bool
+    }
-	 * @throws Exception
-	 */
-	public function inTransaction(): bool|static
-	{
-		return $this->connections()->inTransaction($this->cds);
-	}
-
-	/**
-	 * @throws Exception
-	 * 事务回滚
-	 */
-	public function rollback()
-	{
-		$this->connections()->rollback($this->cds);
-		$this->release();
-	}
-
-	/**
-	 * @throws Exception
-	 * 事务提交
-	 */
-	public function commit()
-	{
-		$this->connections()->commit($this->cds);
-		$this->release();
-	}
-
-	/**
-	 * @param $sql
-	 * @return PDO
-	 * @throws Exception
-	 */
-	public function refresh($sql): PDO
-	{
-		if ($this->isWrite($sql)) {
-			$instance = $this->masterInstance();
-		} else {
-			$instance = $this->slaveInstance();
-		}
-		return $instance;
-	}
-
-	/**
-	 * @param null $sql
-	 * @param array $attributes
-	 * @return Command
-	 * @throws Exception
-	 */
-	public function createCommand($sql = null, array $attributes = []): Command
-	{
-		$command = new Command(['db' => $this, 'sql' => $sql]);
-		return $command->bindValues($attributes);
-	}
 
 
-	/**
+    /**
-	 *
+     * @return PDO
-	 * 回收链接
+     * @throws
-	 * @throws
+     */
-	 */
+    protected function getNormalClientHealth(): PDO
-	public function release()
+    {
-	{
+        $data = $this->pool()->get($this->getName(), $this->waite_time);
-		if (!Kiri::isWorker() && !Kiri::isProcess()) {
+        if ($data === false) {
-			$this->clear_connection();
+            throw new Exception('Client Waite timeout.');
-			return;
+        }
-		}
+        return $data;
-		$connections = $this->connections();
+    }
-		$connections->release($this->cds, true);
-		$connections->release($this->slaveConfig['cds'], false);
-	}
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @return $this
-	 */
+     * @throws
-	public function recovery()
+     */
-	{
+    public function beginTransaction(): static
-		$connections = $this->connections();
+    {
-
+        if ($this->storey < 0) {
-		$connections->release($this->cds, true);
+            $this->storey = 0;
-		$connections->release($this->slaveConfig['cds'], false);
+        }
-	}
+        $this->storey++;
-
+        return $this;
-	/**
+    }
-	 *
-	 * 回收链接
-	 * @throws
-	 */
-	public function clear_connection()
-	{
-		$connections = $this->connections();
-
-		$connections->connection_clear($this->cds, true);
-		$connections->connection_clear($this->slaveConfig['cds'], false);
-	}
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @return PDO
-	 */
+     * @throws
-	public function disconnect()
+     */
-	{
+    public function getTransactionClient(): PDO
-		$connections = $this->connections();
+    {
-		$connections->disconnect($this->cds, true);
+        $pdo = Context::get($this->cds);
-		$connections->disconnect($this->slaveConfig['cds'], false);
+        if ($pdo === null) {
-	}
+            /** @var PDO $pdo */
+            $pdo = Context::set($this->cds, $this->getNormalClientHealth());
+        }
+        if ($this->storey > 0 && !$pdo->inTransaction()) {
+            $pdo->beginTransaction();
+        }
+        return $pdo;
+    }
+
+
+    /**
+     * @return bool
+     * @throws
+     */
+    public function inTransaction(): bool
+    {
+        return $this->storey > 0;
+    }
+
+
+    /**
+     * @throws
+     * 事务回滚
+     */
+    public function rollback(): void
+    {
+        $this->storey--;
+        if ($this->storey == 0) {
+            if (!Context::exists($this->cds)) {
+                return;
+            }
+            $pdo = $this->getTransactionClient();
+            if ($pdo->inTransaction()) {
+                $pdo->rollback();
+            }
+            $this->release($pdo);
+        }
+    }
+
+    /**
+     * @throws
+     * 事务提交
+     */
+    public function commit(): void
+    {
+        $this->storey--;
+        if ($this->storey == 0) {
+            if (!Context::exists($this->cds)) {
+                return;
+            }
+            $pdo = $this->getTransactionClient();
+            if ($pdo->inTransaction()) {
+                $pdo->commit();
+            }
+            $this->release($pdo);
+        }
+    }
+
+
+    /**
+     * @return void
+     * @throws
+     */
+    public function clear(): void
+    {
+        /** @var PDO $pdo */
+        $pdo = Context::get($this->cds);
+        if ($pdo === null) {
+            return;
+        }
+        if ($this->inTransaction()) {
+            $pdo->rollback();
+        }
+        $this->release($pdo);
+    }
+
+
+    /**
+     * @param string $sql
+     * @param array $attributes
+     * @return Command
+     * @throws
+     */
+    public function createCommand(string $sql, array $attributes = []): Command
+    {
+        return (new Command(['connection' => $this, 'sql' => $sql]))->bindValues($attributes);
+    }
+
+
+    /**
+     * 回收链接
+     * @throws
+     */
+    public function release(PDO $pdo): void
+    {
+        if (!$this->inTransaction()) {
+            $this->pool()->push($this->getName(), $pdo);
+        }
+    }
+
+
+    /**
+     *
+     * 回收链接
+     * @throws
+     */
+    public function clear_connection(): void
+    {
+        $this->pool()->flush($this->getName(), 0);
+    }
+
+
+    /**
+     * @throws
+     */
+    public function disconnect(): void
+    {
+        if ($this->timerId > -1) {
+            Timer::clear($this->timerId);
+        }
+        $this->pool()->close($this->getName());
+    }
+
+
+    /**
+     * @return PDO
+     */
+    public function newConnect(): \PDO
+    {
+        $pdo = new PDO($this->database, $this->cds, $this->username, $this->password, [
+//        $pdo = new \PDO('mysql:dbname=' . $this->database . ';host=' . $this->cds, $this->username, $this->password, [
+            \PDO::ATTR_CASE               => \PDO::CASE_NATURAL,
+            \PDO::ATTR_ERRMODE            => \PDO::ERRMODE_EXCEPTION,
+            \PDO::ATTR_ORACLE_NULLS       => \PDO::NULL_NATURAL,
+            \PDO::ATTR_STRINGIFY_FETCHES  => false,
+            \PDO::ATTR_EMULATE_PREPARES   => true,
+            \PDO::ATTR_TIMEOUT            => $this->timeout,
+            \PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES ' . $this->charset
+        ]);
+        foreach ($this->attributes as $key => $attribute) {
+            $pdo->setAttribute($key, $attribute);
+        }
+        return $pdo;
+    }
+
+
+    /**
+     * @return Pool
+     */
+    protected function pool(): Pool
+    {
+        if (!$this->connections->hasChannel($this->getName())) {
+            $this->connections->created($this->getName(), $this->pool['max'] ?? 1, [$this, 'newConnect']);
+        }
+        return $this->connections;
+    }
 
 }

DatabasesProviders.php

@@ -5,12 +5,8 @@ namespace Database;
 
 
 use Exception;
-use Kiri\Abstracts\Config;
+use Kiri;
 use Kiri\Abstracts\Providers;
-use Kiri\Application;
-use Kiri\Exception\ConfigException;
-use Kiri\Kiri;
-use Server\Events\OnWorkerStart;
 
 /**
  * Class DatabasesProviders
@@ -20,72 +16,76 @@ class DatabasesProviders extends Providers
 {
 
 
-	/**
+    /**
-	 * @param Application $application
+     * @var array
-	 * @throws Exception
+     */
-	 */
+    protected array $connections = [];
-	public function onImport(Application $application)
-	{
-		$this->eventProvider->on(OnWorkerStart::class, [$this, 'createPool']);
-	}
 
 
-	/**
+    /**
-	 * @param $name
+     * @return void
-	 * @return Connection
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    public function onImport(): void
-	public function get($name): Connection
+    {
-	{
+        $main = Kiri::getDi()->get(Kiri\Application::class);
-		return Kiri::app()->get($name);
+        $main->command(BackupCommand::class, ImplodeCommand::class);
-	}
+        $databases = \config('databases.connections', []);
+        if (count($databases) < 1) {
+            return;
+        }
+        foreach ($databases as $key => $database) {
+            $this->set($key, $this->_settings($database));
+        }
+    }
 
 
-	/**
+    /**
-	 * @throws ConfigException
+     * @param string $name
-	 * @throws Exception
+     * @return Connection
-	 */
+     * @throws Exception
-	public function createPool(OnWorkerStart $onWorkerStart)
+     */
-	{
+    public function get(string $name): Connection
-		$databases = Config::get('databases.connections', []);
+    {
-		if (empty($databases)) {
+        return $this->connections[$name];
-			return;
+    }
-		}
-
-		$app = Kiri::app();
-		foreach ($databases as $key => $database) {
-			$database = $this->_settings($database);
-
-			$connection = Kiri::getDi()->create(Connection::class, [$database]);
-			$connection->fill();
-
-			$app->set($key, $connection);
-		}
-	}
 
 
-	/**
+    /**
-	 * @param $database
+     * @param string $key
-	 * @return array
+     * @param array $connection
-	 */
+     * @return void
-	private function _settings($database): array
+     * @throws Exception
-	{
+     */
-		$clientPool = $database['pool'] ?? ['min' => 1, 'max' => 5, 'tick' => 60];
+    protected function set(string $key, array $connection): void
-		return [
+    {
-			'id'              => $database['id'],
+        $this->connections[$key] = Kiri::createObject($connection);
-			'cds'             => $database['cds'],
+    }
-			'username'        => $database['username'],
+
-			'password'        => $database['password'],
+
-			'tablePrefix'     => $database['tablePrefix'],
+    /**
-			'database'        => $database['database'],
+     * @param array $database
-			'connect_timeout' => $database['connect_timeout'] ?? 30,
+     * @return array
-			'read_timeout'    => $database['read_timeout'] ?? 10,
+     */
-			'pool'            => $clientPool,
+    private function _settings(array $database): array
-			'attributes'      => $database['attributes'] ?? [],
+    {
-			'charset'         => $database['charset'] ?? 'utf8mb4',
+        $clientPool = $database['pool'] ?? ['min' => 1, 'max' => 5, 'tick' => 60];
-			'slaveConfig'     => $database['slaveConfig']
+        return [
-		];
+            'id'          => $database['id'],
-	}
+            'cds'         => $database['cds'],
+            'class'       => Connection::class,
+            'username'    => $database['username'],
+            'password'    => $database['password'],
+            'tablePrefix' => $database['tablePrefix'],
+            'database'    => $database['database'],
+            'timeout'     => $database['timeout'] ?? 10,
+            'tick_time'   => $database['tick_time'] ?? 60,
+            'waite_time'  => $database['waite_time'] ?? 3,
+            'pool'        => $clientPool,
+            'attributes'  => $database['attributes'] ?? [],
+            'charset'     => $database['charset'] ?? 'utf8mb4'
+        ];
+    }
 
 
 }

Db.php

@@ -9,357 +9,253 @@ declare(strict_types=1);
 
 namespace Database;
 
+use Closure;
 use Database\Affair\BeginTransaction;
 use Database\Affair\Commit;
 use Database\Affair\Rollback;
 use Database\Traits\QueryTrait;
 use Exception;
-use Kiri\Abstracts\Config;
+use Kiri;
-use Kiri\Events\EventDispatch;
+use Throwable;
-use Kiri\Exception\ConfigException;
 
 /**
  * Class Db
  * @package Database
  */
-class Db implements ISqlBuilder
+class Db extends QueryTrait implements ISqlBuilder
 {
-	use QueryTrait;
+
+    private static bool $_inTransaction = false;
 
 
-	private static bool $_inTransaction = false;
+    /**
-
+     * @var Connection|null
-	/**
+     */
-	 * @return bool
+    private ?Connection $connection = null;
-	 */
-	public static function transactionsActive(): bool
-	{
-		return static::$_inTransaction === true;
-	}
-
-	/**
-	 * @throws Exception
-	 */
-	public static function beginTransaction()
-	{
-		if (!static::transactionsActive()) {
-			di(EventDispatch::class)->dispatch(new BeginTransaction());
-		}
-		static::$_inTransaction = true;
-	}
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @param string|Connection $dbname
-	 */
+     * @return Db
-	public static function commit()
+     * @throws
-	{
+     */
-		if (static::transactionsActive()) {
+    public static function connect(string|Connection $dbname): Db
-			di(EventDispatch::class)->dispatch(new Commit());
+    {
-		}
+        $db = new Db();
-		static::$_inTransaction = false;
+        if (is_string($dbname)) {
-	}
+            $db->connection = Kiri::getDi()->get(DatabasesProviders::class)->get($dbname);
+        } else {
+            $db->connection = $dbname;
+        }
+        return $db;
+    }
+
+    /**
+     * @return void
+     * @throws
+     */
+    public static function beginTransaction(): void
+    {
+        fire(new BeginTransaction());
+    }
 
 
-	/**
+    /**
-	 * @throws Exception
+     * @return void
-	 */
+     * @throws
-	public static function rollback()
+     */
-	{
+    public static function commit(): void
-		if (static::transactionsActive()) {
+    {
-			di(EventDispatch::class)->dispatch(new Rollback());
+        fire(new Commit());
-		}
+    }
-		static::$_inTransaction = false;
-	}
 
 
-	/**
+    /**
-	 * @param $table
+     * @return void
-	 *
+     * @throws
-	 * @return static
+     */
-	 */
+    public static function rollback(): void
-	public static function table($table): Db|static
+    {
-	{
+        fire(new Rollback());
-		$connection = new Db();
+    }
-		$connection->from($table);
-		return $connection;
-	}
 
 
-	/**
+    /**
-	 * @param string $column
+     * @param string $table
-	 * @param string $alias
+     * @param string $database
-	 * @return string
+     * @return static
-	 */
+     */
-	public static function any_value(string $column, string $alias = ''): string
+    public static function table(string $table, string $database = 'db'): Db|static
-	{
+    {
-		if (empty($alias)) {
+        return self::connect($database)->from($table);
-			$alias = $column . '_any_value';
+    }
-		}
-		return 'ANY_VALUE(' . $column . ') as ' . $alias;
-	}
 
 
-	/**
+    /**
-	 * @param string $column
+     * @param string $column
-	 * @return string
+     * @param string $alias
-	 */
+     * @return string
-	public static function increment(string $column): string
+     */
-	{
+    public static function any_value(string $column, string $alias = ''): string
-		return '+ ' . $column;
+    {
-	}
+        if (empty($alias)) {
+            $alias = $column . '_any_value';
+        }
+        return 'ANY_VALUE(' . $column . ') as ' . $alias;
+    }
 
 
-	/**
+    /**
-	 * @param string $column
+     * @return int
-	 * @return string
+     */
-	 */
+    public function count(): int
-	public static function decrement(string $column): string
+    {
-	{
+        return $this->connection->createCommand(SqlBuilder::builder($this)->count())->rowCount();
-		return '- ' . $column;
+    }
-	}
+
+    /**
+     * @return bool
+     * @throws Exception
+     */
+    public function exists(): bool
+    {
+        return $this->connection->createCommand(SqlBuilder::builder($this->limit(1))->exists())->exists();
+    }
+
+    /**
+     * @param string $sql
+     * @param array $attributes
+     * @return array|bool|int|string|null
+     * @throws
+     */
+    public function fetchAll(string $sql, array $attributes = []): int|bool|array|string|null
+    {
+        return $this->connection->createCommand($sql, $attributes)->all();
+    }
+
+    /**
+     * @param string $sql
+     * @param array $attributes
+     * @return array|null
+     */
+    public function fetch(string $sql, array $attributes = []): ?array
+    {
+        return $this->connection->createCommand($sql, $attributes)->one();
+    }
 
 
-	/**
+    /**
-	 * @param Connection|null $connection
+     * @return bool
-	 * @return mixed
+     */
-	 * @throws Exception
+    public function delete(): bool
-	 */
+    {
-	public function get(Connection $connection = NULL): mixed
+        return $this->connection->createCommand(SqlBuilder::builder($this)->delete())->delete();
-	{
+    }
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand(SqlBuilder::builder($this)->one())
-			->all();
-	}
-
-	/**
-	 * @param $column
-	 * @return string
-	 */
-	public static function raw($column): string
-	{
-		return '`' . $column . '`';
-	}
-
-	/**
-	 * @param Connection|null $connection
-	 * @return mixed
-	 * @throws Exception
-	 */
-	public function find(Connection $connection = NULL): mixed
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand(SqlBuilder::builder($this)->all())
-			->one();
-	}
-
-	/**
-	 * @param Connection|NULL $connection
-	 * @return bool|int
-	 * @throws Exception
-	 */
-	public function count(Connection $connection = NULL): bool|int
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand(SqlBuilder::builder($this)->count())
-			->exec();
-	}
-
-	/**
-	 * @param Connection|NULL $connection
-	 * @return bool|int
-	 * @throws Exception
-	 */
-	public function exists(Connection $connection = NULL): bool|int
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand(SqlBuilder::builder($this)->one())
-			->fetchColumn();
-	}
-
-	/**
-	 * @param string $sql
-	 * @param array $attributes
-	 * @param Connection|null $connection
-	 * @return array|bool|int|string|null
-	 * @throws Exception
-	 */
-	public static function findAllBySql(string $sql, array $attributes = [], Connection $connection = NULL): int|bool|array|string|null
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand($sql, $attributes)->all();
-	}
-
-	/**
-	 * @param string $sql
-	 * @param array $attributes
-	 * @param Connection|NULL $connection
-	 * @return string|array|bool|int|null
-	 * @throws Exception
-	 */
-	public static function findBySql(string $sql, array $attributes = [], Connection $connection = NULL): string|array|bool|int|null
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand($sql, $attributes)->one();
-	}
-
-	/**
-	 * @param string $field
-	 * @return array|null
-	 * @throws Exception
-	 */
-	public function values(string $field): ?array
-	{
-		$data = $this->get();
-		if (empty($data) || empty($field)) {
-			return NULL;
-		}
-		$first = current($data);
-		if (!isset($first[$field])) {
-			return NULL;
-		}
-		return array_column($data, $field);
-	}
-
-	/**
-	 * @param $field
-	 * @return mixed
-	 * @throws Exception
-	 */
-	public function value($field): mixed
-	{
-		$data = $this->find();
-		if (!empty($field) && isset($data[$field])) {
-			return $data[$field];
-		}
-		return $data;
-	}
-
-	/**
-	 * @param Connection|null $connection
-	 * @return bool|int
-	 * @throws ConfigException
-	 * @throws Exception
-	 */
-	public function delete(?Connection $connection = null): bool|int
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		return $connection->createCommand($connection->getBuild()->builder($this))->delete();
-	}
-
-	/**
-	 * @param string $table
-	 * @param null $connection
-	 * @return bool|int
-	 * @throws ConfigException
-	 * @throws Exception
-	 */
-	public static function drop(string $table, $connection = null): bool|int
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		$sprint = sprintf('DROP TABLE `%s`.`%s`', $connection->database, $table);
-		return $connection->createCommand($sprint)->delete();
-	}
-
-	/**
-	 * @param string $table
-	 * @param null $connection
-	 * @return bool|int
-	 * @throws Exception
-	 */
-	public static function truncate(string $table, $connection = null): bool|int
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		$sprint = sprintf('TRUNCATE `%s`.`%s`', $connection->database, $table);
-		return $connection->createCommand($sprint)->exec();
-	}
-
-	/**
-	 * @param string $table
-	 * @param Connection|NULL $connection
-	 * @return mixed
-	 * @throws ConfigException
-	 * @throws Exception
-	 */
-	public static function showCreateSql(string $table, Connection $connection = NULL): mixed
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		$sprint = sprintf('SHOW CREATE TABLE `%s`.`%s`', $connection->database, $table);
-		return $connection->createCommand($sprint)->one();
-	}
-
-	/**
-	 * @param string $table
-	 * @param Connection|NULL $connection
-	 * @return bool|int|null
-	 * @throws ConfigException
-	 * @throws Exception
-	 */
-	public static function desc(string $table, Connection $connection = NULL): bool|int|null
-	{
-		$connection = static::getDefaultConnection($connection);
-
-		$sprint = sprintf('SHOW FULL FIELDS FROM `%s`.`%s`', $connection->database, $table);
-		return $connection->createCommand($sprint)->all();
-	}
 
 
-	/**
+    /**
-	 * @param string $table
+     * @return bool|array|null
-	 * @param Connection|NULL $connection
+     */
-	 * @return mixed
+    public function first(): bool|array|null
-	 * @throws Exception
+    {
-	 */
+        return $this->connection->createCommand(SqlBuilder::builder($this)->one())->one();
-	public static function show(string $table, Connection $connection = NULL): mixed
+    }
-	{
-		if (empty($table)) {
-			return null;
-		}
-		$connection = static::getDefaultConnection($connection);
-
-		$table = ['	const TABLE = \'select * from %s  where REFERENCED_TABLE_NAME=%s\';'];
-		return $connection->createCommand((new Query())
-			->select('*')
-			->from('INFORMATION_SCHEMA.KEY_COLUMN_USAGE')
-			->where(['REFERENCED_TABLE_NAME' => $table])
-			->getSql())->one();
-	}
 
 
-	/**
+    /**
-	 * @param null|Connection $connection
+     * @return bool|array
-	 * @param null $name
+     */
-	 * @return mixed
+    public function get(): bool|array
-	 * @throws ConfigException
+    {
-	 * @throws Exception
+        return $this->connection->createCommand(SqlBuilder::builder($this)->all())->all();
-	 */
+    }
-	public static function getDefaultConnection(?Connection $connection, $name = null): Connection
+
-	{
+
-		if ($connection instanceof Connection) {
+    /**
-			return $connection;
+     * @param string $sql
-		}
+     * @return mixed
-		$databases = Config::get('databases.connections', []);
+     */
-		if (empty($databases) || !is_array($databases)) {
+    public function exec(string $sql): mixed
-			throw new Exception('Please configure the database link.');
+    {
-		}
+        return $this->connection->createCommand($sql)->exec();
-		if (!empty($name)) {
+    }
-			if (!isset($databases[$name])) {
+
-				throw new Exception('Please configure the database link.');
+
-			}
+    /**
-			return $databases[$name];
+     * @param string $sql
-		}
+     * @return array|bool|null
-		return current($databases);
+     */
-	}
+    public function query(string $sql): array|bool|null
+    {
+        return $this->connection->createCommand($sql)->one();
+    }
+
+
+    /**
+     * @param string $sql
+     * @return array|bool
+     */
+    public function queryAll(string $sql): array|bool
+    {
+        return $this->connection->createCommand($sql)->all();
+    }
+
+
+    /**
+     * @param string $table
+     * @return array|bool|null
+     * @throws
+     */
+    public static function show(string $table): array|bool|null
+    {
+        if ($table == '') {
+            return null;
+        }
+        $connection = static::getDefaultConnection();
+
+        $table = ['	const TABLE = \'select * from %s  where REFERENCED_TABLE_NAME=%s\';'];
+        return $connection->createCommand((new Query())
+            ->from('INFORMATION_SCHEMA.KEY_COLUMN_USAGE')
+            ->where(['REFERENCED_TABLE_NAME' => $table])
+            ->build())->one();
+    }
+
+
+    /**
+     * @param string $table
+     * @param Connection|null $connection
+     * @param string $database
+     * @return array|null
+     * @throws
+     */
+    public static function desc(string $table, ?Connection $connection = null, string $database = 'db'): ?array
+    {
+        $sql = SqlBuilder::builder(new Query())->columns($table);
+
+        $connection = self::getDefaultConnection($connection, $database);
+
+        return $connection->createCommand($sql)->all();
+    }
+
+
+    /**
+     * @param null|Connection $connection
+     * @param string $database
+     * @return mixed
+     * @throws
+     */
+    public static function getDefaultConnection(?Connection $connection = null, string $database = 'db'): Connection
+    {
+        if ($connection instanceof Connection) {
+            return $connection;
+        }
+        $databases = \config('databases.connections', []);
+        $providers = Kiri::getDi()->get(DatabasesProviders::class);
+        if (empty($databases) || !is_array($databases)) {
+            throw new Exception('Please configure the database link.');
+        }
+        return $providers->get($databases[$database]);
+    }
 
 
 }

HasCount.php

@@ -3,8 +3,9 @@ declare(strict_types=1);
 
 namespace Database;
 
-use Exception;
 use Database\Traits\HasBase;
+use Exception;
+use Kiri;
 
 /**
  * Class HasCount
@@ -13,27 +14,14 @@ use Database\Traits\HasBase;
 class HasCount extends HasBase
 {
 
-	/**
+    /**
-	 * @param $name
+     * @return array|null|ModelInterface
-	 * @param $arguments
+     * @throws
-	 * @return ActiveQuery
+     */
-	 * @throws Exception
+    public function get(): array|ModelInterface|null
-	 */
+    {
-	public function __call($name, $arguments): mixed
+        $relation = Kiri::getDi()->get(Relation::class);
-	{
+        return $relation->get($this->name);
-		if (method_exists($this, $name)) {
+    }
-			return call_user_func([$this, $name], ...$arguments);
-		}
-		return $this->_relation->getQuery($this->model::className())->$name(...$arguments);
-	}
-
-	/**
-	 * @return array|null|ModelInterface
-	 * @throws Exception
-	 */
-	public function get(): array|ModelInterface|null
-	{
-		return $this->_relation->count($this->model::className(), $this->value);
-	}
 
 }

HasMany.php

@@ -6,10 +6,12 @@
  * Time: 13:58
  */
 declare(strict_types=1);
+
 namespace Database;
 
-use Exception;
 use Database\Traits\HasBase;
+use Exception;
+use Kiri;
 
 /**
  * Class HasMany
@@ -20,25 +22,13 @@ use Database\Traits\HasBase;
 class HasMany extends HasBase
 {
 
-	/**
+    /**
-	 * @param $name
+     * @return array|null|Collection
-	 * @param $arguments
+     * @throws
-	 * @return ActiveQuery
+     */
-	 */
+    public function get(): array|Collection|null
-	public function __call($name, $arguments): mixed
+    {
-	{
+        $relation = Kiri::getDi()->get(Relation::class);
-		if (method_exists($this, $name)) {
+        return $relation->get($this->name);
-			return call_user_func([$this, $name], ...$arguments);
+    }
-		}
-		return $this->_relation->getQuery($this->model::className())->$name(...$arguments);
-	}
-
-	/**
-	 * @return array|null|ModelInterface
-	 * @throws Exception
-	 */
-	public function get(): array|ModelInterface|null
-	{
-		return $this->_relation->get($this->model::className(), $this->value);
-	}
 }

HasOne.php

@@ -9,8 +9,9 @@ declare(strict_types=1);
 
 namespace Database;
 
-use Exception;
 use Database\Traits\HasBase;
+use Exception;
+use Kiri;
 
 /**
  * Class HasOne
@@ -20,26 +21,13 @@ use Database\Traits\HasBase;
 class HasOne extends HasBase
 {
 
-	/**
+    /**
-	 * @param $name
+     * @return array|null|ModelInterface
-	 * @param $arguments
+     * @throws
-	 * @return ActiveQuery
+     */
-	 */
+    public function get(): array|ModelInterface|null
-	public function __call($name, $arguments): mixed
+    {
-	{
+        $relation = Kiri::getDi()->get(Relation::class);
-		if (method_exists($this, $name)) {
+        return $relation->first($this->name);
-			return call_user_func([$this, $name], ...$arguments);
+    }
-		}
-		$this->_relation->getQuery($this->model::className())->$name(...$arguments);
-		return $this;
-	}
-
-	/**
-	 * @return array|null|ModelInterface
-	 * @throws Exception
-	 */
-	public function get(): array|ModelInterface|null
-	{
-		return $this->_relation->first($this->model::className(), $this->value);
-	}
 }

ImplodeCommand.php

@@ -0,0 +1,100 @@
+<?php
+declare(strict_types=1);
+
+namespace Database;
+
+use Co\Channel;
+use Exception;
+use Swoole\Coroutine;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+
+/**
+ *
+ */
+class ImplodeCommand extends Command
+{
+
+
+    /**
+     * @var string
+     */
+    public string $command = 'db:implode';
+
+
+    /**
+     * @var string
+     */
+    public string $description = 'php kiri.php db:implode --database users /Users/admin/snowflake-bi/test.sql';
+
+
+    /**
+     * @var Channel
+     */
+    protected Channel $channel;
+
+    protected array $data;
+
+
+    /**
+     *
+     */
+    protected function configure(): void
+    {
+        $this->setName('db:implode')
+             ->addArgument('path', InputArgument::REQUIRED, "save to path", null)
+             ->addOption('database', 'db', InputArgument::OPTIONAL)
+             ->setDescription('php kiri.php db:implode --database users /Users/admin/snowflake-bi/test.sql');
+        $this->data = array_flip(get_html_translation_table(ENT_QUOTES | ENT_SUBSTITUTE));
+    }
+
+
+    /**
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @return int
+     * @throws
+     */
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        try {
+            /** @var Connection $data */
+            $data = \Kiri::getDi()->get(DatabasesProviders::class)->get($input->getOption('database'));
+
+            $path = $input->getArgument('path');
+            if (!str_starts_with($path, '/')) {
+                $path = APP_PATH . $path;
+            }
+
+            $waite  = new Coroutine\WaitGroup();
+            $stream = fopen($path, 'r');
+            if ($stream) {
+                while (($line = fgets($stream)) !== false) {
+                    if (!str_starts_with(strtoupper($line), 'INSERT INTO')) {
+                        continue;
+                    }
+                    $waite->add();
+                    $insert = str_replace('&#039;', "\'", str_replace('&quot;', '"', $line));
+
+                    $insert = strtr($insert, $this->data);
+                    Coroutine::create(function () use ($waite, $insert, $data) {
+                        Coroutine\defer(fn() => $waite->done());
+                        $data->createCommand($insert)->exec();
+                    });
+                }
+                fclose($stream);
+            }
+            $waite->wait();
+
+            $output->write('dump data success');
+        } catch (\Throwable $throwable) {
+            $output->writeln(throwable($throwable));
+        } finally {
+            return 1;
+        }
+    }
+
+}

Model.php

@@ -10,14 +10,8 @@ declare(strict_types=1);
 namespace Database;
 
 
-use Database\Base\Getter;
+use Database\Base\ActiveQueryInterface;
-use Database\Traits\HasBase;
 use Exception;
-use Kiri\Exception\NotFindClassException;
-use Kiri\Kiri;
-use Kiri\ToArray;
-use ReflectionException;
-use Swoole\Coroutine;
 
 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.');
@@ -28,395 +22,348 @@ defined('FIND_OR_CREATE_MESSAGE') or define('FIND_OR_CREATE_MESSAGE', 'Create a
  *
  * @property $attributes
  * @property-read $oldAttributes
+ *
+ * @mixin ActiveQueryInterface
  */
 class Model extends Base\Model
 {
 
 
-	/**
+    /**
-	 * @param string $column
+     * @param string $column
-	 * @param int $value
+     * @param int|float $value
-	 * @return ModelInterface|false
+     * @return ModelInterface|false
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function increment(string $column, int $value): bool|ModelInterface
+    public function increment(string $column, int|float $value): bool|ModelInterface
-	{
+    {
-		if (!$this->mathematics([$column => $value], '+')) {
+        if (!$this->mathematics([$column => $value], '+')) {
-			return false;
+            return false;
-		}
+        }
-		$this->{$column} += $value;
+        $this->{$column} += $value;
-		return $this->refresh();
+        return $this->refresh();
-	}
+    }
 
 
-	/**
+    /**
-	 * @param string $column
+     * @param string $column
-	 * @param int $value
+     * @param int|float $value
-	 * @return ModelInterface|false
+     * @return ModelInterface|false
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function decrement(string $column, int $value): bool|ModelInterface
+    public function decrement(string $column, int|float $value): bool|ModelInterface
-	{
+    {
-		if (!$this->mathematics([$column => $value], '-')) {
+        if (!$this->mathematics([$column => $value], '-')) {
-			return false;
+            return false;
-		}
+        }
-		$this->{$column} -= $value;
+        $this->{$column} -= $value;
-		return $this->refresh();
+        return $this->refresh();
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $columns
+     * @param array $columns
-	 * @return ModelInterface|false
+     * @return ModelInterface|false
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function increments(array $columns): bool|static
+    public function increments(array $columns): bool|static
-	{
+    {
-		if (!$this->mathematics($columns, '+')) {
+        if (!$this->mathematics($columns, '+')) {
-			return false;
+            return false;
-		}
+        }
-		foreach ($columns as $key => $attribute) {
+        foreach ($columns as $key => $attribute) {
-			$this->$key += $attribute;
+            $this->$key += $attribute;
-		}
+        }
-		return $this;
+        return $this;
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $columns
+     * @param array $columns
-	 * @return ModelInterface|false
+     * @return ModelInterface|false
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function decrements(array $columns): bool|static
+    public function decrements(array $columns): bool|static
-	{
+    {
-		if (!$this->mathematics($columns, '-')) {
+        if (!$this->mathematics($columns, '-')) {
-			return false;
+            return false;
-		}
+        }
-		foreach ($columns as $key => $attribute) {
+        foreach ($columns as $key => $attribute) {
-			$this->$key -= $attribute;
+            $this->$key -= $attribute;
-		}
+        }
-		return $this;
+        return $this;
-	}
+    }
 
-	/**
+    /**
-	 * @param array $condition
+     * @param array $condition
-	 * @param array $attributes
+     * @param array $attributes
-	 * @return bool|ModelInterface
+     * @return bool|static
-	 * @throws ReflectionException
+     * @throws
-	 * @throws NotFindClassException
+     */
-	 * @throws Exception
+    public static function findOrCreate(array $condition, array $attributes): bool|static
-	 */
+    {
-	public static function findOrCreate(array $condition, array $attributes): bool|static
+        $model      = static::instance();
-	{
+        $connection = $model->getConnection()->beginTransaction();
-		$logger = Kiri::app()->getLogger();
+        try {
-		if (empty($attributes)) {
+            /** @var static $select */
-			return $logger->addError(FIND_OR_CREATE_MESSAGE, 'mysql');
+            $select = $model::query()->where($condition)->first();
-		}
+            if ($select === null) {
-		Db::beginTransaction();
+                $select = $model::populate(array_merge($condition, $attributes));
-		/** @var static $select */
+                if (!$select->save()) {
-		$select = static::query()->where($condition)->first();
+                    throw new Exception('保存失败: ' . $model->getLastError());
-		if (empty($select)) {
+                }
-			$select = duplicate(static::class);
+            }
-			$select->attributes = $attributes;
+            $connection->commit();
-			$select->setIsNowExample(true);
+            return $select;
-			if (!$select->save()) {
+        } catch (\Throwable $throwable) {
-				Db::rollback();
+            $connection->rollback();
-				return $logger->addError($select->getLastError(), 'mysql');
+            return \Kiri::getLogger()->failure($throwable);
-			}
+        }
-		}
+    }
-		Db::commit();
-		return $select;
-	}
 
 
-	/**
+    /**
-	 * @param array $condition
+     * @param array $condition
-	 * @param array $attributes
+     * @param array $attributes
-	 * @return bool|static
+     * @return bool|static
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public static function createOrUpdate(array $condition, array $attributes = []): bool|static
+    public static function createOrUpdate(array $condition, array $attributes = []): bool|static
-	{
+    {
-		$logger = Kiri::app()->getLogger();
+        $model      = static::instance();
-		if (empty($attributes)) {
+        $connection = $model->getConnection()->beginTransaction();
-			return $logger->addError(FIND_OR_CREATE_MESSAGE, 'mysql');
+        try {
-		}
+            /** @var static $select */
-
+            $select = static::query()->where($condition)->first();
-		Db::beginTransaction();
+            if (empty($select)) {
-		/** @var static $select */
+                $select = static::populate($condition);
-		$select = static::query()->where($condition)->first();
+            }
-		if (empty($select)) {
+            $select->attributes = $attributes;
-			$select = duplicate(static::class);
+            if (!$select->save()) {
-		}
+                throw new Exception('保存失败: ' . $model->getLastError());
-		$select->attributes = $attributes;
+            }
-		if (!$select->save()) {
+            $connection->commit();
-			Db::rollback();
+            return $select;
-			$select = $logger->addError($select->getLastError(), 'mysql');
+        } catch (\Throwable $throwable) {
-		} else {
+            $connection->rollback();
-			Db::commit();
+            return \Kiri::getLogger()->failure($throwable);
-		}
+        }
-		return $select;
+    }
-	}
 
 
-	/**
+    /**
-	 * @param $action
+     * @param string $name
-	 * @param $columns
+     * @param array $arguments
-	 * @param null|array $condition
+     * @return Model|ActiveQuery
-	 * @return array|bool|int|string|null
+     */
-	 * @throws Exception
+    public static function __callStatic(string $name, array $arguments): static|ActiveQuery
-	 */
+    {
-	private function mathematics($columns, $action, ?array $condition = null): int|bool|array|string|null
+        // TODO: Change the autogenerated stub
-	{
+        if (method_exists(static::class, $name)) {
-		if (empty($condition)) {
+            return call_user_func(static::class . '::' . $name, ...$arguments);
-			$condition = [$this->getPrimary() => $this->getPrimaryValue()];
+        } else {
-		}
+            return static::query()->{$name}(...$arguments);
-
+        }
-		$activeQuery = static::query()->where($condition);
+    }
-		$create = SqlBuilder::builder($activeQuery)->mathematics($columns, $action);
-		if (is_bool($create)) {
-			return false;
-		}
-		return $this->getConnection()->createCommand($create[0], $create[1])->exec();
-	}
 
 
-	/**
+    /**
-	 * @param array $fields
+     * @param array $columns
-	 * @return ModelInterface|bool
+     * @param string $action
-	 * @throws Exception
+     * @return array|bool|int|string|null
-	 */
+     */
-	public function update(array $fields): static|bool
+    private function mathematics(array $columns, string $action): int|bool|array|string|null
-	{
+    {
-		return $this->save($fields);
+        $condition   = [$this->getPrimary() => $this->getPrimaryValue()];
-	}
+        $activeQuery = static::query()->where($condition);
+        $create      = SqlBuilder::builder($activeQuery)->mathematics($columns, $action);
+        if (is_bool($create)) {
+            return false;
+        }
+        return $activeQuery->buildCommand($create)->exec();
+    }
 
 
-	/**
+    /**
-	 * @param array $data
+     * @param array $params
-	 * @return bool
+     * @return ModelInterface|bool
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public static function inserts(array $data): bool
+    public function update(array $params): static|bool
-	{
+    {
-		$result = false;
+        if (!$this->validator($this->rules(), $params) || !$this->beforeSave($this)) {
-		if (empty($data)) {
+            return FALSE;
-			error('Insert data empty.', 'mysql');
+        }
-		} else {
+        return $this->updateInternal(...$this->arrayIntersect($params));
-			$result = static::query()->batchInsert($data);
+    }
-		}
-		return $result;
-	}
-
-	/**
-	 * @return bool
-	 * @throws Exception
-	 */
-	public function delete(): bool
-	{
-		$primary = $this->getPrimary();
-		if (empty($primary) || !$this->hasPrimaryValue()) {
-			return $this->addError("Only primary key operations are supported.", 'mysql');
-		}
-		if (!$this->beforeDelete()) {
-			$result = static::deleteByCondition([$primary => $this->getPrimaryValue()]);
-			Coroutine::create(function () use ($result) {
-				$this->afterDelete($result);
-			});
-			return $result;
-		}
-		return false;
-	}
 
 
-	/**
+    /**
-	 * @param mixed $condition
+     * @param array $data
-	 * @param array $attributes
+     * @return bool
-	 *
+     * @throws
-	 * @return bool
+     */
-	 * @throws NotFindClassException
+    public static function inserts(array $data): bool
-	 * @throws ReflectionException
+    {
-	 * @throws Exception
+        if (empty($data)) {
-	 */
+            return trigger_print_error('Insert data empty.', 'mysql');
-	public static function updateAll(mixed $condition, array $attributes = []): bool
+        }
-	{
+        return static::query()->insert($data);
-		$condition = static::query()->where($condition);
+    }
-		return $condition->batchUpdate($attributes);
+
-	}
+    /**
+     * @return bool
+     * @throws
+     */
+    public function delete(): bool
+    {
+        if (!$this->beforeDelete()) {
+            return false;
+        }
+        if ($this->hasPrimary()) {
+            $result = static::deleteByCondition(['id' => $this->getPrimaryValue()]);
+        } else {
+            $result = static::deleteByCondition($this->_attributes);
+        }
+        return $this->afterDelete($result);
+    }
 
 
-	/**
+    /**
-	 * @param $condition
+     * @return array
-	 * @return array|Collection
+     * @throws
-	 * @throws NotFindClassException
+     */
-	 * @throws ReflectionException
+    public function toArray(): array
-	 */
+    {
-	public static function get($condition): Collection|array
+        $data = $this->_attributes;
-	{
+        foreach ($data as $key => $datum) {
-		return static::query()->where($condition)->all();
+            $method = 'get' . ucfirst($key) . 'Attribute';
-	}
+            if (!method_exists($this, $method)) {
+                continue;
+            }
+            $data[$key] = $this->{$method}($datum);
+        }
+        return $this->withs($data);
+    }
 
 
-	/**
+    /**
-	 * @param       $condition
+     * @param array $data
-	 * @param array $attributes
+     * @return array
-	 *
+     */
-	 * @return array|Collection
+    private function withs(array $data): array
-	 * @throws Exception
+    {
-	 */
+        $with = $this->getWith();
-	public static function findAll($condition, array $attributes = []): array|Collection
+        foreach ($with as $value) {
-	{
+            $join = $this->withRelate($value);
-		$query = static::query()->where($condition);
+            if ($join instanceof \Arrayable) {
-		if (!empty($attributes)) {
+                $join = $join->toArray();
-			$query->bindParams($attributes);
+            }
-		}
+            $data[$value] = $join;
-		return $query->all();
+        }
-	}
+        return $data;
-
+    }
-	/**
-	 * @param $method
-	 * @return mixed
-	 * @throws Exception
-	 */
-	private function withRelation($method): mixed
-	{
-		$method = $this->getRelate($method);
-		if (empty($method)) {
-			return null;
-		}
-		$resolve = $this->{$method}();
-		if ($resolve instanceof HasBase) {
-			$resolve = $resolve->get();
-		}
-		if ($resolve instanceof ToArray) {
-			return $resolve->toArray();
-		} else if (is_object($resolve)) {
-			return get_object_vars($resolve);
-		} else {
-			return $resolve;
-		}
-	}
 
 
-	/**
+    /**
-	 * @return array
+     * @param ModelInterface|string $modelName
-	 * @throws Exception
+     * @param string $foreignKey
-	 */
+     * @param string $localKey
-	public function toArray(): array
+     * @return string
-	{
+     * @throws Exception
-		$data = $this->_attributes;
+     */
-		$lists = di(Getter::class)->getGetter(static::class);
+    private function _hasBase(ModelInterface|string $modelName, string $foreignKey, string $localKey): string
-		foreach ($lists as $key => $item) {
+    {
-			$data[$key] = $this->{$item}($data[$key] ?? null);
+        if (($value = $this->{$localKey}) === null) {
-		}
+            throw new Exception("Need join table primary key.");
-		return $this->withRelates($data);
+        }
-	}
 
-	/**
+        $relation = $this->getRelation();
-	 * @param $relates
+
-	 * @return array
+        $primaryKey = $modelName . $foreignKey . $value;
-	 * @throws Exception
+        if (!$relation->hasIdentification($primaryKey)) {
-	 */
+            $relation->bindIdentification($primaryKey, $modelName::query()->where([$foreignKey => $value]));
-	private function withRelates($relates): array
+        }
-	{
+        return $primaryKey;
-		if (empty($with = $this->getWith())) {
+    }
-			return $relates;
-		}
-		foreach ($with as $val) {
-			$relates[$val] = $this->withRelation($val);
-		}
-		return $relates;
-	}
 
 
-	/**
+    /**
-	 * @param string $modelName
+     * @param ModelInterface|string $modelName
-	 * @param $foreignKey
+     * @param string $foreignKey
-	 * @param $localKey
+     * @param string $localKey
-	 * @return HasOne|ActiveQuery
+     * @return HasOne|ActiveQuery
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function hasOne(string $modelName, $foreignKey, $localKey): HasOne|ActiveQuery
+    public function hasOne(ModelInterface|string $modelName, string $foreignKey, string $localKey): HasOne|ActiveQuery
-	{
+    {
-		if (($value = $this->{$localKey}) === null) {
+        return new HasOne($this->_hasBase($modelName, $foreignKey, $localKey));
-			throw new Exception("Need join table primary key.");
+    }
-		}
-
-		$relation = $this->getRelation();
-
-		return new HasOne($modelName, $foreignKey, $value, $relation);
-	}
 
 
-	/**
+    /**
-	 * @param $modelName
+     * @param ModelInterface|string $modelName
-	 * @param $foreignKey
+     * @param string $foreignKey
-	 * @param $localKey
+     * @param string $localKey
-	 * @return ActiveQuery|HasCount
+     * @return ActiveQuery|HasCount
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function hasCount($modelName, $foreignKey, $localKey): ActiveQuery|HasCount
+    public function hasCount(ModelInterface|string $modelName, string $foreignKey, string $localKey): ActiveQuery|HasCount
-	{
+    {
-		if (($value = $this->{$localKey}) === null) {
+        return new HasCount($this->_hasBase($modelName, $foreignKey, $localKey));
-			throw new Exception("Need join table primary key.");
+    }
-		}
-
-		$relation = $this->getRelation();
-
-		return new HasCount($modelName, $foreignKey, $value, $relation);
-	}
 
 
-	/**
+    /**
-	 * @param $modelName
+     * @param ModelInterface|string $modelName
-	 * @param $foreignKey
+     * @param string $foreignKey
-	 * @param $localKey
+     * @param string $localKey
-	 * @return ActiveQuery|HasMany
+     * @return ActiveQuery|HasMany
-	 * @throws Exception
+     * @throws Exception
-	 */
+     */
-	public function hasMany($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
+    public function hasMany(ModelInterface|string $modelName, string $foreignKey, string $localKey): ActiveQuery|HasMany
-	{
+    {
-		if (($value = $this->{$localKey}) === null) {
+        return new HasMany($this->_hasBase($modelName, $foreignKey, $localKey));
-			throw new Exception("Need join table primary key.");
+    }
-		}
 
-		$relation = $this->getRelation();
+    /**
+     * @param ModelInterface|string $modelName
+     * @param string $foreignKey
+     * @param string $localKey
+     * @return ActiveQuery|HasMany
+     * @throws Exception
+     */
+    public function hasIn(ModelInterface|string $modelName, string $foreignKey, string $localKey): ActiveQuery|HasMany
+    {
+        if (($value = $this->{$localKey}) === null) {
+            throw new Exception("Need join table primary key.");
+        }
 
-		return new HasMany($modelName, $foreignKey, $value, $relation);
+        $relation = $this->getRelation();
-	}
 
-	/**
+        $primaryKey = $modelName . $foreignKey . json_encode($value, JSON_UNESCAPED_UNICODE);
-	 * @param $modelName
+        if (!$relation->hasIdentification($primaryKey)) {
-	 * @param $foreignKey
+            $relation->bindIdentification($primaryKey, $modelName::query()->whereIn($foreignKey, $value));
-	 * @param $localKey
+        }
-	 * @return ActiveQuery|HasMany
-	 * @throws Exception
-	 */
-	public function hasIn($modelName, $foreignKey, $localKey): ActiveQuery|HasMany
-	{
-		if (($value = $this->{$localKey}) === null) {
-			throw new Exception("Need join table primary key.");
-		}
 
-		$relation = $this->getRelation();
+        return new HasMany($primaryKey);
+    }
 
-		return new HasMany($modelName, $foreignKey, $value, $relation);
+    /**
-	}
+     * @param bool $result
+     * @return bool
+     */
+    public function afterDelete(bool $result): bool
+    {
+        return $result;
+    }
 
-	/**
+    /**
-	 * @param bool $result
+     * @return bool
-	 * @return void
+     * @throws Exception
-	 */
+     */
-	public function afterDelete(bool $result): void
+    public function beforeDelete(): bool
-	{
+    {
-	}
+        return TRUE;
-
+    }
-	/**
-	 * @return bool
-	 * @throws Exception
-	 */
-	public function beforeDelete(): bool
-	{
-		return TRUE;
-	}
 }

ModelInterface.php

@@ -17,19 +17,24 @@ namespace Database;
 interface ModelInterface
 {
 
-	/**
+    /**
-	 * @param $param
+     * @param array|string|int $param
-	 * @param null $db
+     * @return ModelInterface|null
-	 * @return ModelInterface
+     */
-	 */
+    public static function findOne(array|string|int $param): ?static;
-	public static function findOne($param, $db = NULL): mixed;
 
 
-	/**
+    /**
-	 * @param string|int $param
+     * @return mixed
-	 * @return ModelInterface
+     */
-	 */
+    public function optimize(): mixed;
-	public static function find(string|int $param): mixed;
+
+
+    /**
+     * @param int $param
+     * @return ModelInterface|null
+     */
+    public static function primary(int $param): ?static;
 
 
     /**
@@ -39,23 +44,73 @@ interface ModelInterface
     public static function populate(array $data): static;
 
 
-	/**
+    /**
-	 * @return ActiveQuery
+     * @return ActiveQuery
-	 * return a sql queryBuilder
+     * return a sql queryBuilder
-	 */
+     */
-	public static function query(): ActiveQuery;
+    public static function query(): ActiveQuery;
 
 
-	/**
+    /**
-	 * @return string
+     * @return ?string
-	 */
+     */
-	public function getTable(): string;
+    public function getPrimary(): ?string;
 
 
-	/**
+    /**
-	 * @return Connection
+     * @return string
-	 */
+     */
-	public function getConnection(): Connection;
+    public function getTable(): string;
 
 
+    /**
+     * @return Connection
+     */
+    public function getConnection(): Connection;
+
+
+    /**
+     * @param string $field
+     * @return mixed
+     */
+    public function getAttribute(string $field): mixed;
+
+    /**
+     * @param string $field
+     * @return mixed
+     */
+    public function getOldAttribute(string $field): mixed;
+
+
+    /**
+     * @param string $field
+     * @param mixed $value
+     * @return mixed
+     */
+    public function setAttribute(string $field, mixed $value): mixed;
+
+    /**
+     * @param string $field
+     * @param mixed $value
+     * @return mixed
+     */
+    public function setOldAttribute(string $field, mixed $value): mixed;
+
+
+    /**
+     * @return array
+     */
+    public function getOldAttributes(): array;
+
+    /**
+     * @return array
+     */
+    public function getAttributes(): array;
+
+
+    /**
+     * @return array
+     */
+    public function getChanges(): array;
+
 }

Mysql/Columns.php

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

Mysql/PDO.php

@@ -1,324 +0,0 @@
-<?php
-
-namespace Database\Mysql;
-
-use Exception;
-use Kiri\Abstracts\Config;
-use Kiri\Abstracts\Logger;
-use Kiri\Kiri;
-use Kiri\Pool\StopHeartbeatCheck;
-use PDOStatement;
-use Swoole\Timer;
-
-/**
- *
- */
-class PDO implements StopHeartbeatCheck
-{
-
-	const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
-
-
-	private ?\PDO $pdo = null;
-
-
-	private int $_transaction = 0;
-
-
-	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 array $config
-	 */
-	public function __construct(array $config)
-	{
-		$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();
-	}
-
-
-	/**
-	 * @return bool
-	 */
-	public function inTransaction(): bool
-	{
-		return $this->_transaction > 0;
-	}
-
-
-	/**
-	 *
-	 */
-	public function heartbeat_check(): void
-	{
-		if (env('state', 'start') == 'exit') {
-			return;
-		}
-		if ($this->_timer === -1) {
-			$this->_timer = Timer::tick(1000, fn() => $this->waite());
-		}
-	}
-
-
-	/**
-	 * @throws Exception
-	 */
-	private function waite(): void
-	{
-		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);
-		}
-	}
-
-
-	/**
-	 *
-	 */
-	public function stopHeartbeatCheck(): void
-	{
-		if ($this->_timer > -1) {
-			Timer::clear($this->_timer);
-		}
-		$this->_timer = -1;
-	}
-
-
-	/**
-	 *
-	 */
-	public function beginTransaction()
-	{
-		if ($this->_transaction == 0) {
-			$this->_pdo()->beginTransaction();
-		}
-		$this->_transaction++;
-	}
-
-
-	/**
-	 *
-	 */
-	public function commit()
-	{
-		if ($this->_transaction == 0) {
-			$this->_pdo()->commit();
-		}
-		$this->_transaction--;
-	}
-
-
-	/**
-	 *
-	 */
-	public function rollback()
-	{
-		if ($this->_transaction == 0) {
-			$this->_pdo()->rollBack();
-		}
-		$this->_transaction--;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return bool|array|null
-	 * @throws Exception
-	 */
-	public function fetchAll(string $sql, array $params = []): bool|null|array
-	{
-		$pdo = $this->queryPrev($sql, $params);
-
-		$result = $pdo->fetchAll(\PDO::FETCH_ASSOC);
-		$pdo->closeCursor();
-		return $result;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return bool|array|null
-	 * @throws Exception
-	 */
-	public function fetch(string $sql, array $params = []): bool|null|array
-	{
-		$pdo = $this->queryPrev($sql, $params);
-
-		$result = $pdo->fetch(\PDO::FETCH_ASSOC);
-		$pdo->closeCursor();
-		return $result;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return bool|array|null
-	 * @throws \Exception
-	 */
-	public function fetchColumn(string $sql, array $params = []): bool|null|array
-	{
-		$pdo = $this->queryPrev($sql, $params);
-
-		$result = $pdo->fetchColumn(\PDO::FETCH_ASSOC);
-		$pdo->closeCursor();
-		return $result;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return int
-	 * @throws Exception
-	 */
-	public function count(string $sql, array $params = []): int
-	{
-		$pdo = $this->queryPrev($sql, $params);
-
-		$result = $pdo->rowCount();
-		$pdo->closeCursor();
-		return $result;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return PDOStatement
-	 * @throws Exception
-	 */
-	private function queryPrev(string $sql, array $params = []): PDOStatement
-	{
-		$this->_last = time();
-		try {
-			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());
-		}
-	}
-
-
-	/**
-	 * @param PDOStatement $statement
-	 * @param array $params
-	 * @return PDOStatement
-	 */
-	private function bindValue(PDOStatement $statement, array $params = []): PDOStatement
-	{
-		if (empty($params)) return $statement;
-		foreach ($params as $key => $param) {
-			$statement->bindValue($key, $param);
-		}
-		return $statement;
-	}
-
-
-	/**
-	 * @param string $sql
-	 * @param array $params
-	 * @return int
-	 * @throws Exception
-	 */
-	public function execute(string $sql, array $params = []): int
-	{
-		$this->_last = time();
-		$pdo = $this->_pdo();
-		if (!(($prepare = $pdo->prepare($sql)) instanceof PDOStatement)) {
-			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
-		}
-		if ($prepare->execute($params) === false) {
-			throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
-		}
-		$result = (int)$pdo->lastInsertId();
-		$prepare->closeCursor();
-		if ($result == 0) {
-			return true;
-		}
-		return $result;
-	}
-
-
-	/**
-	 * @return \PDO
-	 */
-	public function _pdo(): \PDO
-	{
-		if ($this->_timer === -1) {
-			$this->heartbeat_check();
-		}
-		if (!($this->pdo instanceof \PDO)) {
-			$this->pdo = $this->newClient();
-		}
-		return $this->pdo;
-	}
-
-
-	/**
-	 * @return \PDO
-	 */
-	private function newClient(): \PDO
-	{
-		$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                  => $this->connect_timeout,
-			\PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
-			\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;
-	}
-
-}

Mysql/Schema.php

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

Orm/Condition.php

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

Pagination.php

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

Query.php

@@ -11,44 +11,23 @@ namespace Database;
 
 
 use Database\Traits\QueryTrait;
-use Exception;
 
 /**
  * Class Query
  * @package Database
  */
-class Query implements ISqlBuilder
+class Query extends QueryTrait implements ISqlBuilder
 {
 
-	use QueryTrait;
 
-
+    /**
-	/**
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function __construct()
+    public function getCondition(): string
-	{
+    {
-		$this->builder = SqlBuilder::builder($this);
+        return $this->builder->getCondition();
-	}
+    }
-
-	/**
-	 * @return string
-	 * @throws Exception
-	 */
-	public function getSql(): string
-	{
-		return $this->builder->get();
-	}
-
-
-	/**
-	 * @return string
-	 * @throws Exception
-	 */
-	public function getCondition(): string
-	{
-		return $this->builder->getCondition();
-	}
 
 
 }

Relation.php

@@ -4,8 +4,8 @@ declare(strict_types=1);
 namespace Database;
 
 
-use Exception;
 use Kiri\Abstracts\Component;
+use Kiri\Di\Context;
 
 /**
  * Class Relation
@@ -14,98 +14,83 @@ use Kiri\Abstracts\Component;
 class Relation extends Component
 {
 
-	private array $_relations = [];
+    /** @var ActiveQuery[] $_query */
+    private array $_query = [];
 
-	/** @var ActiveQuery[] $_query */
+    /**
-	private array $_query = [];
+     * @param string $identification
+     * @param ActiveQuery $query
+     * @return $this
+     */
+    public function bindIdentification(string $identification, ActiveQuery $query): static
+    {
+        $this->_query[$identification] = $query;
+        return $this;
+    }
 
-	/**
+    /**
-	 * @param string $identification
+     * @param string $identification
-	 * @param ActiveQuery $query
+     * @return bool
-	 * @return $this
+     */
-	 */
+    public function hasIdentification(string $identification): bool
-	public function bindIdentification(string $identification, ActiveQuery $query): static
+    {
-	{
+        return isset($this->_query[$identification]) && $this->_query[$identification] instanceof ActiveQuery;
-		$this->_query[$identification] = $query;
+    }
-		return $this;
-	}
 
-	/**
+    /**
-	 * @param string $name
+     * @param string $name
-	 * @return ActiveQuery|null
+     * @return ActiveQuery|null
-	 */
+     */
-	public function getQuery(string $name): ?ActiveQuery
+    public function getQuery(string $name): ?ActiveQuery
-	{
+    {
-		return $this->_query[$name] ?? null;
+        return $this->_query[$name] ?? null;
-	}
+    }
 
 
-	/**
+    /**
-	 * @param string $identification
+     * @param string $_identification
-	 * @param $localValue
+     * @return mixed
-	 * @return mixed
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    public function first(string $_identification): mixed
-	public function first(string $identification, $localValue): mixed
+    {
-	{
+        if (Context::exists($_identification)) {
-		$_identification = $identification . '_first_' . $localValue;
+            return Context::get($_identification);
-		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+        }
-			return $this->_relations[$_identification];
+        $activeModel = $this->_query[$_identification]->first();
-		}
+        unset($this->_query[$_identification]);
-
+        return Context::set($_identification, $activeModel);
-		$activeModel = $this->_query[$identification]->first();
+    }
-		if (empty($activeModel)) {
-			return null;
-		}
-
-		return $this->_relations[$_identification] = $activeModel;
-	}
 
 
-	/**
+    /**
-	 * @param string $identification
+     * @param string $_identification
-	 * @param $localValue
+     * @return mixed
-	 * @return mixed
+     */
-	 * @throws Exception
+    public function count(string $_identification): mixed
-	 */
+    {
-	public function count(string $identification, $localValue): mixed
+        if (Context::exists($_identification)) {
-	{
+            return Context::get($_identification);
-		$_identification = $identification . '_count_' . $localValue;
+        }
-		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+        $activeModel = $this->_query[$_identification]->count();
-			return $this->_relations[$_identification];
+        unset($this->_query[$_identification]);
-		}
+        return Context::set($_identification, $activeModel);
-
+    }
-		$activeModel = $this->_query[$identification]->count();
-		if (empty($activeModel)) {
-			return null;
-		}
-
-		return $this->_relations[$_identification] = $activeModel;
-	}
 
 
-	/**
+    /**
-	 * @param string $identification
+     * @param string $_identification
-	 * @param $localValue
+     * @return mixed
-	 * @return mixed
+     * @throws
-	 */
+     */
-	public function get(string $identification, $localValue): mixed
+    public function get(string $_identification): mixed
-	{
+    {
-		if (is_array($localValue)) {
+        if (Context::exists($_identification)) {
-			$_identification = $identification . '_get_' . implode('_', $localValue);
+            return Context::get($_identification);
-		} else {
+        }
-			$_identification = $identification . '_get_' . $localValue;
+        $activeModel = $this->_query[$_identification]->get();
-		}
+        unset($this->_query[$_identification]);
-		if (isset($this->_relations[$_identification]) && $this->_relations[$_identification] !== null) {
+        return Context::set($_identification, $activeModel);
-			return $this->_relations[$_identification];
+    }
-		}
-
-		$activeModel = $this->_query[$identification]->get();
-		if (empty($activeModel)) {
-			return null;
-		}
-
-		return $this->_relations[$_identification] = $activeModel;
-	}
 
 }

SqlBuilder.php

@@ -1,12 +1,12 @@
-<?php
+<?php /** @noinspection ALL */
 
+declare(strict_types=1);
 
 namespace Database;
 
 
-use Database\Traits\Builder;
-use Exception;
 use JetBrains\PhpStorm\Pure;
+use Kiri;
 use Kiri\Abstracts\Component;
 
 
@@ -17,359 +17,395 @@ use Kiri\Abstracts\Component;
 class SqlBuilder extends Component
 {
 
-	use Builder;
+    /**
+     * @var ActiveQuery|Query|ISqlBuilder|null
+     */
+    public ActiveQuery|Query|ISqlBuilder|null $query;
 
 
-	public ActiveQuery|Query|null $query;
+    /**
+     * @param ActiveQuery|Query|ISqlBuilder|null $config
+     */
+    public function __construct(ActiveQuery|Query|null|ISqlBuilder $config)
+    {
+        parent::__construct();
+
+        $this->query = $config;
+    }
 
 
-	/**
+    /**
-	 * @param ISqlBuilder|null $query
+     * @param ISqlBuilder|null $query
-	 * @return $this
+     * @return $this
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public static function builder(ISqlBuilder|null $query): static
+    public static function builder(ISqlBuilder|null $query): static
-	{
+    {
-		return new static(['query' => $query]);
+        return new static($query);
-	}
+    }
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function getCondition(): string
+    public function getCondition(): string
-	{
+    {
-		return $this->conditionToString();
+        return $this->where($this->query->getWhere());
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $compiler
+     * @param array $compiler
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function hashCompiler(array $compiler): string
+    public function hashCompiler(array $compiler): string
-	{
+    {
-		return $this->where($compiler);
+        return $this->where($compiler);
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $attributes
+     * @param array $attributes
-	 * @return bool|array
+     * @return bool|array
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function update(array $attributes): bool|array
+    public function update(array $attributes): bool|string
-	{
+    {
-		[$string, $array] = $this->builderParams($attributes);
+        $conditions = $this->query->getParams();
-
+        $this->query->setParams([]);
-		return $this->__updateBuilder($string, $array);
+        $data = $this->__updateBuilder($this->makeParams($attributes));
-	}
+        foreach ($conditions as $condition) {
+            $this->query->pushParam($condition);
+        }
+        return $data;
+    }
 
 
-	/**
+    /**
-	 * @param array $attributes
+     * @param array $attributes
-	 * @param string $opera
+     * @param string $opera
-	 * @return bool|array
+     * @return bool|array
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function mathematics(array $attributes, string $opera = '+'): bool|array
+    public function mathematics(array $attributes, string $opera = '+'): bool|string
-	{
+    {
-		$string = [];
+        $string = [];
-		foreach ($attributes as $attribute => $value) {
+        foreach ($attributes as $attribute => $value) {
-			$string[] = $attribute . '=' . $attribute . $opera . $value;
+            $string[] = $attribute . '=' . $attribute . $opera . $value;
-		}
+        }
-		return $this->__updateBuilder($string, []);
+        return $this->__updateBuilder($string);
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $string
+     * @param array $string
-	 * @param array $params
+     * @return string|bool
-	 * @return array|bool
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    private function __updateBuilder(array $string): string|bool
-	private function __updateBuilder(array $string, array $params): array|bool
+    {
-	{
+        if (empty($string)) {
-		if (empty($string)) {
+            return Kiri::getLogger()->failure('None data update.');
-			return $this->addError('None data update.');
+        }
-		}
+        return 'UPDATE ' . $this->query->getFrom() . ' SET ' . implode(',', $string) . $this->make();
-
+    }
-		$condition = $this->conditionToString();
-		if (!empty($condition)) {
-			$condition = ' WHERE ' . $condition;
-		}
-
-		$update = 'UPDATE ' . $this->tableName() . ' SET ' . implode(',', $string) . $condition;
-		$update .= $this->builderLimit($this->query, false);
-
-		return [$update, $params];
-	}
 
 
-	/**
+    /**
-	 * @param array $attributes
+     * @param array $attributes
-	 * @param false $isBatch
+     * @param false $isBatch
-	 * @return array
+     * @return array
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function insert(array $attributes, bool $isBatch = false): array
+    public function insert(array $attributes, bool $isBatch = false): string
-	{
+    {
-		$update = 'INSERT INTO ' . $this->tableName();
+        $update = 'INSERT INTO ' . $this->query->getFrom();
-		if ($isBatch === false) {
+        if ($isBatch === false) {
-			$attributes = [$attributes];
+            $attributes = [$attributes];
-		}
+        }
-		$update .= '(' . implode(',', $this->getFields($attributes)) . ') VALUES ';
+        $update .= '(' . implode(',', $this->getFields($attributes)) . ') VALUES ';
 
-		$order = 0;
+        $keys = [];
-		$keys = $params = [];
+        foreach ($attributes as $attribute) {
-		foreach ($attributes as $attribute) {
+            $_keys = $this->makeParams($attribute, true);
-			[$_keys, $params] = $this->builderParams($attribute, true, $params, $order);
 
-			$keys[] = implode(',', $_keys);
+            $keys[] = implode(',', $_keys);
-			$order++;
+        }
-		}
+        return $update . '(' . implode('),(', $keys) . ')';
-		return [$update . '(' . implode('),(', $keys) . ')', $params];
+    }
-	}
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function delete(): string
+    public function delete(): string
-	{
+    {
-		$delete = sprintf('DELETE FROM %s ', $this->query->modelClass->getTable());
+        return 'DELETE FROM ' . $this->query->getFrom() . $this->make();
-
+    }
-		$this->query->from = null;
-
-		return $delete . ' WHERE ' . $this->_prefix(true);
-	}
 
 
-	/**
+    /**
-	 * @param $attributes
+     * @param $attributes
-	 * @return array
+     * @return array
-	 */
+     */
-	#[Pure] private function getFields($attributes): array
+    #[Pure] private function getFields(array $attributes): array
-	{
+    {
-		return array_keys(current($attributes));
+        return array_keys(current($attributes));
-	}
+    }
 
 
-	/**
+    /**
-	 * @param array $attributes
+     * @param array $attributes
-	 * @param bool $isInsert
+     * @param bool $isInsert
-	 * @param array $params
+     * @return array[]
-	 * @param int $order
+     * a=:b,
-	 * @return array[]
+     */
-	 * a=:b,
+    private function makeParams(array $attributes, bool $isInsert = false): array
-	 */
+    {
-	#[Pure] private function builderParams(array $attributes, bool $isInsert = false, array $params = [], int $order = 0): array
+        $keys = [];
-	{
+        foreach ($attributes as $key => $value) {
-		$keys = [];
+            if ($isInsert === true) {
-		foreach ($attributes as $key => $value) {
+                $keys[] = '?';
-			if ($isInsert === true) {
+                $this->query->pushParam($value);
-				$keys[] = ':' . $key . $order;
+            } else {
-				$params[$key . $order] = $value;
+                $keys = $this->resolveParams($key, $value, $keys);
-			} else {
+            }
-				[$keys, $params] = $this->resolveParams($key, $value, $order, $params, $keys);
+        }
-			}
+        return $keys;
-		}
+    }
-		return [$keys, $params];
-	}
 
 
-	/**
+    /**
-	 * @param string $key
+     * @param string $key
-	 * @param mixed $value
+     * @param mixed $value
-	 * @param int $order
+     * @param array $keys
-	 * @param array $params
+     * @return array
-	 * @param array $keys
+     */
-	 * @return array
+    private function resolveParams(string $key, mixed $value, array $keys): array
-	 */
+    {
-	private function resolveParams(string $key, mixed $value, int $order, array $params, array $keys): array
+        if (is_null($value)) {
-	{
+            return $keys;
-		if (
+        }
-			str_starts_with($value, '+ ') ||
+        if (is_string($value) && $this->isMath($value)) {
-			str_starts_with($value, '- ')
+            $keys[] = $key . '=' . $key . ' ' . $value;
-		) {
+        } else {
-			$keys[] = $key . '=' . $key . ' ' . $value;
+            $this->query->pushParam($value);
-		} else {
+            $keys[] = $key . '= ?';
-			$params[$key . $order] = $value;
+        }
-			$keys[] = $key . '=:' . $key . $order;
+        return $keys;
-		}
+    }
-		return [$keys, $params];
-	}
 
 
-	/**
+    /**
-	 * @return string
+     * @param string $value
-	 * @throws Exception
+     * @return bool
-	 */
+     */
-	public function one(): string
+    private function isMath(string $value): bool
-	{
+    {
-		$this->query->limit(0, 1);
+        return str_starts_with($value, '+ ') || str_starts_with($value, '- ');
-		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+    }
-			$this->query->from($this->query->getTable());
-		}
-		return $this->_prefix(true);
-	}
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function all(): string
+    public function one(): string
-	{
+    {
-		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+        return $this->makeSelect($this->query->getSelect()) . $this->make() . $this->makeLimit($this->query->limit(1));
-			$this->query->from($this->query->getTable());
+    }
-		}
-		return $this->_prefix(true);
-	}
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     * @throws
-	 */
+     */
-	public function count(): string
+    public function all(): string
-	{
+    {
-		if (empty($this->query->from) && !empty($this->query->modelClass)) {
+        return $this->makeSelect($this->query->getSelect()) . $this->make() . $this->makeLimit($this->query);
-			$this->query->from($this->query->getTable());
+    }
-		}
-		return $this->_prefix(false, true);
-	}
 
 
-	/**
+    /**
-	 * @param $table
+     * @return string
-	 * @return string
+     * @throws
-	 */
+     */
-	public function columns($table): string
+    public function count(): string
-	{
+    {
-		return 'SHOW FULL FIELDS FROM ' . $table;
+        return $this->makeSelect(['COUNT(*)']) . $this->make();
-	}
+    }
 
 
-	/**
+    /**
-	 * @param bool $hasOrder
+     * @return string
-	 * @param bool $isCount
+     * @throws
-	 * @return string
+     */
-	 * @throws Exception
+    public function exists(): string
-	 */
+    {
-	private function _prefix(bool $hasOrder = false, bool $isCount = false): string
+        return $this->makeSelect(['0']) . $this->make();
-	{
+    }
-		$select = '';
-		if (!empty($this->query->from)) {
-			$select = $this->_selectPrefix($isCount);
-		}
-		$select = $this->_wherePrefix($select);
-		if (!empty($this->query->attributes) && is_array($this->query->attributes)) {
-			$select = strtr($select, $this->query->attributes);
-		}
-
-		if (!empty($this->query->group)) {
-			$select .= $this->builderGroup($this->query->group);
-		}
-		if ($hasOrder === true && !empty($this->query->order)) {
-			$select .= $this->builderOrder($this->query->order);
-		}
-		$sql = $select . $this->builderLimit($this->query);
-		if ($this->query->lock) {
-			$sql .= ' FOR UPDATE';
-		}
-		return $sql;
-	}
 
 
-	/**
+    /**
-	 * @param $select
+     * @param string $table
-	 * @return string
+     * @return string
-	 * @throws Exception
+     */
-	 */
+    public function columns(string $table): string
-	private function _wherePrefix($select): string
+    {
-	{
+        return 'SHOW FULL FIELDS FROM ' . $table;
-		$condition = $this->conditionToString();
+    }
-		if (empty($condition)) {
-			return $select;
-		} else if (empty($select)) {
-			return $condition;
-		}
-		return sprintf('%s WHERE %s', $select, $condition);
-	}
 
 
-	/**
+    /**
-	 * @param bool $isCount
+     * @return string
-	 * @return string
+     * @throws
-	 * @throws Exception
+     */
-	 */
+    private function make(): string
-	private function _selectPrefix(bool $isCount): string
+    {
-	{
+        $select = $this->makeCondition();
-		$select = $this->builderSelect($this->query->select, $isCount) . ' FROM ' . $this->tableName();
+        $select .= $this->makeGroup();
-		if (!empty($this->query->alias)) {
+        $select .= $this->makeOrder();
-			$select .= $this->builderAlias($this->query->alias);
+        return $select;
-		}
+    }
-		if (!empty($this->query->join)) {
+
-			$select .= $this->builderJoin($this->query->join);
+    /**
-		}
+     * @param array $select
-		return $select;
+     * @return string
-	}
+     */
+    private function makeSelect(array $select = ['*']): string
+    {
+        $select = "SELECT " . implode(',', $select) . " FROM " . $this->query->getFrom();
+        if ($this->query->getAlias() != "") {
+            $select .= " AS " . $this->query->getAlias();
+        }
+        if (count($this->query->getJoin()) > 0) {
+            $select .= ' ' . implode(' ', $this->query->getJoin());
+        }
+        return $select;
+    }
 
 
-	/**
+    /**
-	 * @param false $isCount
+     * @return string
-	 * @return string
+     */
-	 * @throws Exception
+    private function makeGroup(): string
-	 */
+    {
-	public function get(bool $isCount = false): string
+        if ($this->query->getGroup() != "") {
-	{
+            return ' GROUP BY ' . $this->query->getGroup();
-		if ($isCount === false) {
+        }
-			return $this->all();
+        return '';
-		}
+    }
-		return $this->count();
-	}
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     */
-	 */
+    private function makeOrder(): string
-	public function truncate(): string
+    {
-	{
+        if (count($this->query->getOrder()) > 0) {
-		return sprintf('TRUNCATE %s', $this->tableName());
+            return ' ORDER BY ' . implode(',', $this->query->getOrder());
-	}
+        }
+        return '';
+    }
 
 
-	/**
+    /**
-	 * @return string
+     * @return string
-	 * @throws Exception
+     */
-	 */
+    private function makeCondition(): string
-	private function conditionToString(): string
+    {
-	{
+        $condition = $this->where($this->query->getWhere());
-		return $this->where($this->query->where);
+        if (empty($condition)) {
-	}
+            return '';
+        }
+        return ' WHERE ' . $condition;
+    }
 
 
-	/**
+    private function makeLimit(): string
-	 * @return string
+    {
-	 * @throws Exception
+        if ($this->query->getOffset() >= 0 && $this->query->getLimit() >= 1) {
-	 */
+            return ' LIMIT ' . $this->query->getOffset() . ',' . $this->query->getLimit();
-	public function tableName(): string
+        }
-	{
+        return '';
-		if ($this->query->from instanceof \Closure) {
+    }
-			$this->query->from = sprintf('(%s)', $this->query->makeClosureFunction($this->query->from));
+
-		}
+
-		if ($this->query->from instanceof ActiveQuery) {
+    /**
-			$this->query->from = sprintf('%s', SqlBuilder::builder($this->query->from)->get($this->query->from));
+     * @param false $isCount
-		}
+     * @return string
-		if (empty($this->query->from)) {
+     * @throws
-			return $this->query->modelClass->getTable();
+     */
-		}
+    public function get(bool $isCount = false): string
-		return $this->query->from;
+    {
-	}
+        if ($isCount === false) {
+            return $this->all();
+        }
+        return $this->count();
+    }
+
+
+    /**
+     * @return string
+     * @throws
+     */
+    public function truncate(): string
+    {
+        return sprintf('TRUNCATE %s', $this->query->getFrom());
+    }
+
+
+    /**
+     * @param array $where
+     * @return string
+     */
+    private function where(array $where): string
+    {
+        if (count($where) < 1) {
+            return '';
+        }
+        $_tmp = [];
+        foreach ($where as $key => $value) {
+            $_tmp[] = $this->resolveCondition($key, $value);
+        }
+        return implode(' AND ', $_tmp);
+    }
+
+
+    /**
+     * @param string $field
+     * @param mixed $condition
+     * @return string
+     */
+    private function resolveCondition(string|int $field, mixed $condition): string
+    {
+        if (is_string($field)) {
+            $this->query->pushParam($condition);
+            return $field . ' = ?';
+        } else if (is_string($condition)) {
+            return $condition;
+        } else {
+            return implode(' AND ', $this->_hashMap($condition));
+        }
+    }
+
+
+    /**
+     * @param $condition
+     * @return array
+     */
+    private function _hashMap(array $condition): array
+    {
+        $_array = [];
+        foreach ($condition as $key => $value) {
+            $this->query->pushParam($value);
+            $_array[] = $key . '= ?';
+        }
+        return $_array;
+    }
+
 
 }

Traits/Builder.php

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

Traits/HasBase.php

@@ -12,70 +12,68 @@ namespace Database\Traits;
 use Database\ModelInterface;
 use Database\Collection;
 use Database\Relation;
-use Exception;
+use Kiri;
 
 /**
  * Class HasBase
  * @package Database
  *
  * @include Query
+ *
+ * @method first($name)
+ * @method all($name)
+ * @method count($name)
  */
 abstract class HasBase implements \Database\Traits\Relation
 {
 
-	/** @var ModelInterface|Collection */
+    /** @var ModelInterface|Collection */
-	protected Collection|ModelInterface $data;
+    protected mixed $data = null;
 
-	/**
+    /**
-	 * @var ModelInterface
+     * @var ModelInterface
-	 */
+     */
-	protected mixed $model;
+    protected mixed $model;
-
-	protected mixed $value = [];
 
 
-	/** @var Relation $_relation */
+    protected mixed $value = 0;
-	protected Relation $_relation;
+
 
     /**
      * HasBase constructor.
-     * @param ModelInterface $model
+     * @param string $name
-     * @param $primaryId
-     * @param $value
-     * @param Relation $relation
-     * @throws Exception
      */
-	public function __construct(mixed $model, $primaryId, $value, Relation $relation)
+    public function __construct(public string $name)
-	{
+    {
-		if (!class_exists($model)) {
+    }
-			throw new Exception('Model must implement ' . $model);
-		}
-		if (!in_array(ModelInterface::class, class_implements($model))) {
-			throw new Exception('Model must implement ' . $model);
-		}
-		if (is_array($value)) {
-			if (empty($value)) $value = [];
-			$_model = $model::query()->whereIn($primaryId, $value);
-		} else {
-			$_model = $model::query()->where(['t1.' . $primaryId => $value]);
-		}
-
-		$this->_relation = $relation->bindIdentification($model, $_model);
-
-		$this->model = $model;
-		$this->value = $value;
-	}
 
 
-	/**
+    /**
-	 * @param $name
+     * @param string $name
-	 * @return mixed
+     * @param array $arguments
-	 */
+     * @return $this|mixed
-	public function __get($name): mixed
+     */
-	{
+    public function __call(string $name, array $arguments)
-		if (empty($this->value)) {
+    {
-			return null;
+        if ($name !== 'get') {
-		}
+            $relation = Kiri::getDi()->get(Relation::class);
-		return $this->get();
+            $relation->getQuery($this->name)->$name(...$arguments);
-	}
+            return $this;
+        } else {
+            return $this->get();
+        }
+    }
+
+
+    /**
+     * @param string $name
+     * @return mixed
+     */
+    public function __get(string $name): mixed
+    {
+        if ($this->data === null) {
+            $this->data = $this->get();
+        }
+        return $this->data;
+    }
 }

Traits/Relation.php

@@ -1,10 +1,15 @@
 <?php
+declare(strict_types=1);
 
 namespace Database\Traits;
 
 interface Relation
 {
 
+
+    /**
+     * @return mixed
+     */
 	public function get(): mixed;
 
 }

Traits/When.php

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

composer.json

@@ -9,11 +9,10 @@
   ],
   "license": "MIT",
   "require": {
-    "php": ">=8.0",
+    "php": ">=8.3",
     "ext-json": "*",
     "ext-pdo": "*",
-    "game-worker/kiri-validator": "~v2.0",
+    "game-worker/kiri-pool": "~v1.0"
-    "game-worker/kiri-event": "~v2.0"
   },
   "autoload": {
     "psr-4": {