事务工作单元

用事务工作单元更好地处理数据库相关工作。

引入相关类

  • use Leevel\Database\Ddd\Entity;
  • use Leevel\Database\Ddd\IUnitOfWork;
  • use Leevel\Database\Ddd\UnitOfWork;
  • use Tests\Database\DatabaseTestCase as TestCase;
  • use Tests\Database\Ddd\Entity\CompositeId;
  • use Tests\Database\Ddd\Entity\Guestbook;
  • use Tests\Database\Ddd\Entity\GuestbookRepository;
  • use Tests\Database\Ddd\Entity\Relation\Post;
  • use Throwable;

    保存一个实体

  1. public function testBaseUse()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $post = new Post([
  9.         'title'   => 'hello world',
  10.         'user_id' => 1,
  11.         'summary' => 'post summary',
  12.     ]);
  14.     $this->assertNull($post->id);
  16.     $work->persist($post);
  18.     $work->flush();
  20.     $this->assertSame('1', $post->id);
  21.     $this->assertSame('1', $post['id']);
  22.     $this->assertSame('1', $post->getId());
  23.     $this->assertSame(1, $post->userId);
  24.     $this->assertSame('post summary', $post->summary);
  25. }

::: tip
通过 persist 方法保存一个实体，并通过 flush 将实体持久化到数据库。
:::

保存多个实体

  1. public function testPersist()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $post = new Post([
  9.         'title'   => 'hello world',
  10.         'user_id' => 1,
  11.         'summary' => 'post summary',
  12.     ]);
  14.     $this->assertNull($post->id);
  16.     $post2 = new Post([
  17.         'title'   => 'hello world',
  18.         'user_id' => 2,
  19.         'summary' => 'foo bar',
  20.     ]);
  22.     $this->assertNull($post2->id);
  24.     $work->persist($post);
  25.     $work->persist($post2);
  27.     $work->flush();
  29.     $this->assertSame('1', $post->id);
  30.     $this->assertSame('1', $post['id']);
  31.     $this->assertSame('1', $post->getId());
  32.     $this->assertSame(1, $post->userId);
  33.     $this->assertSame('post summary', $post->summary);
  35.     $this->assertSame('2', $post2->id);
  36.     $this->assertSame('2', $post2['id']);
  37.     $this->assertSame('2', $post2->getId());
  38.     $this->assertSame(2, $post2->userId);
  39.     $this->assertSame('foo bar', $post2->summary);
  40. }

::: tip
底层会开启一个事务，只有全部保存成功才会真正持久化到数据库。
:::

新增实体

  1. public function testCreate()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $post = new Post([
  9.         'title'   => 'hello world',
  10.         'user_id' => 1,
  11.         'summary' => 'post summary',
  12.     ]);
  14.     $post2 = new Post([
  15.         'title'   => 'hello world',
  16.         'user_id' => 2,
  17.         'summary' => 'foo bar',
  18.     ]);
  20.     $this->assertNull($post->id);
  21.     $this->assertNull($post2->id);
  22.     $this->assertFalse($work->created($post));
  23.     $this->assertFalse($work->created($post2));
  24.     $this->assertFalse($work->registered($post));
  25.     $this->assertFalse($work->registered($post2));
  27.     $work->create($post);
  28.     $work->create($post2);
  30.     $this->assertTrue($work->created($post));
  31.     $this->assertTrue($work->created($post2));
  32.     $this->assertTrue($work->registered($post));
  33.     $this->assertTrue($work->registered($post2));
  35.     $work->flush();
  37.     $this->assertFalse($work->created($post));
  38.     $this->assertFalse($work->created($post2));
  39.     $this->assertFalse($work->registered($post));
  40.     $this->assertFalse($work->registered($post2));
  42.     $this->assertSame('1', $post->id);
  43.     $this->assertSame('1', $post['id']);
  44.     $this->assertSame('1', $post->getId());
  45.     $this->assertSame(1, $post->userId);
  46.     $this->assertSame('post summary', $post->summary);
  48.     $this->assertSame('2', $post2->id);
  49.     $this->assertSame('2', $post2['id']);
  50.     $this->assertSame('2', $post2->getId());
  51.     $this->assertSame(2, $post2->userId);
  52.     $this->assertSame('foo bar', $post2->summary);
  53. }

::: tip
底层执行的是 insert 语句，只有全部保存成功才会真正持久化到数据库。
:::

更新实体

  1. public function testUpdate()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $this->assertSame('2', $connect->
  19.     table('post')->
  20.     insert([
  21.         'title'   => 'hello world',
  22.         'user_id' => 2,
  23.         'summary' => 'foo bar',
  24.     ]));
  26.     $post = Post::find(1);
  28.     $post2 = Post::find(2);
  30.     $this->assertInstanceof(Entity::class, $post);
  31.     $this->assertInstanceof(Entity::class, $post2);
  32.     $this->assertInstanceof(Post::class, $post);
  33.     $this->assertInstanceof(Post::class, $post2);
  35.     $this->assertSame('1', $post->id);
  36.     $this->assertSame('1', $post['id']);
  37.     $this->assertSame('1', $post->getId());
  38.     $this->assertSame('1', $post->userId);
  39.     $this->assertSame('post summary', $post->summary);
  40.     $this->assertSame('hello world', $post->title);
  42.     $this->assertSame('2', $post2->id);
  43.     $this->assertSame('2', $post2['id']);
  44.     $this->assertSame('2', $post2->getId());
  45.     $this->assertSame('2', $post2->userId);
  46.     $this->assertSame('foo bar', $post2->summary);
  47.     $this->assertSame('hello world', $post2->title);
  49.     $this->assertFalse($work->updated($post));
  50.     $this->assertFalse($work->updated($post2));
  51.     $this->assertFalse($work->registered($post));
  52.     $this->assertFalse($work->registered($post2));
  54.     $post->title = 'new post title';
  55.     $post->summary = 'new post summary';
  57.     $post2->title = 'new post2 title';
  58.     $post2->summary = 'new post2 summary';
  60.     $work->update($post);
  61.     $work->update($post2);
  63.     $this->assertTrue($work->updated($post));
  64.     $this->assertTrue($work->updated($post2));
  65.     $this->assertTrue($work->registered($post));
  66.     $this->assertTrue($work->registered($post2));
  68.     $work->flush();
  70.     $this->assertFalse($work->updated($post));
  71.     $this->assertFalse($work->updated($post2));
  72.     $this->assertFalse($work->registered($post));
  73.     $this->assertFalse($work->registered($post2));
  75.     $this->assertSame('1', $post->id);
  76.     $this->assertSame('1', $post['id']);
  77.     $this->assertSame('1', $post->getId());
  78.     $this->assertSame('1', $post->userId);
  79.     $this->assertSame('new post title', $post->title);
  80.     $this->assertSame('new post summary', $post->summary);
  82.     $this->assertSame('2', $post2->id);
  83.     $this->assertSame('2', $post2['id']);
  84.     $this->assertSame('2', $post2->getId());
  85.     $this->assertSame('2', $post2->userId);
  86.     $this->assertSame('new post2 title', $post2->title);
  87.     $this->assertSame('new post2 summary', $post2->summary);
  88. }

::: tip
底层执行的是 update 语句，只有全部保存成功才会真正持久化到数据库。
:::

删除实体

  1. public function testDelete()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $this->assertSame('2', $connect->
  19.     table('post')->
  20.     insert([
  21.         'title'   => 'hello world',
  22.         'user_id' => 2,
  23.         'summary' => 'foo bar',
  24.     ]));
  26.     $post = Post::find(1);
  28.     $post2 = Post::find(2);
  30.     $this->assertInstanceof(Entity::class, $post);
  31.     $this->assertInstanceof(Entity::class, $post2);
  32.     $this->assertInstanceof(Post::class, $post);
  33.     $this->assertInstanceof(Post::class, $post2);
  35.     $this->assertSame('1', $post->id);
  36.     $this->assertSame('1', $post['id']);
  37.     $this->assertSame('1', $post->getId());
  38.     $this->assertSame('1', $post->userId);
  39.     $this->assertSame('post summary', $post->summary);
  40.     $this->assertSame('hello world', $post->title);
  42.     $this->assertSame('2', $post2->id);
  43.     $this->assertSame('2', $post2['id']);
  44.     $this->assertSame('2', $post2->getId());
  45.     $this->assertSame('2', $post2->userId);
  46.     $this->assertSame('foo bar', $post2->summary);
  47.     $this->assertSame('hello world', $post2->title);
  49.     $this->assertFalse($work->deleted($post));
  50.     $this->assertFalse($work->deleted($post2));
  51.     $this->assertFalse($work->registered($post));
  52.     $this->assertFalse($work->registered($post2));
  54.     $work->delete($post);
  55.     $work->delete($post2);
  57.     $this->assertTrue($work->deleted($post));
  58.     $this->assertTrue($work->deleted($post2));
  59.     $this->assertTrue($work->registered($post));
  60.     $this->assertTrue($work->registered($post2));
  62.     $work->flush();
  64.     $this->assertFalse($work->deleted($post));
  65.     $this->assertFalse($work->deleted($post2));
  66.     $this->assertFalse($work->registered($post));
  67.     $this->assertFalse($work->registered($post2));
  69.     $postAfter = Post::find(1);
  71.     $post2After = Post::find(2);
  73.     $this->assertNull($postAfter->id);
  74.     $this->assertNull($postAfter['id']);
  75.     $this->assertNull($postAfter->getId());
  76.     $this->assertNull($postAfter->userId);
  77.     $this->assertNull($postAfter->title);
  78.     $this->assertNull($postAfter->summary);
  80.     $this->assertNull($post2After->id);
  81.     $this->assertNull($post2After['id']);
  82.     $this->assertNull($post2After->getId());
  83.     $this->assertNull($post2After->userId);
  84.     $this->assertNull($post2After->title);
  85.     $this->assertNull($post2After->summary);
  86. }

::: tip
底层执行的是 delete 语句，只有全部保存成功才会真正持久化到数据库。
:::

刷新实体

  1. public function testRefresh()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $post = new Post([
  19.         'id'      => 1,
  20.         'title'   => 'old',
  21.         'summary' => 'old',
  22.     ], true);
  24.     $this->assertSame(1, $post->getId());
  25.     $this->assertSame('old', $post->getSummary());
  26.     $this->assertSame('old', $post->getTitle());
  28.     $work->persist($post);
  29.     $work->refresh($post);
  31.     $this->assertSame('1', $post->getId());
  32.     $this->assertSame('post summary', $post->getSummary());
  33.     $this->assertSame('hello world', $post->getTitle());
  35.     $work->flush();
  37.     $post = Post::find(1);
  39.     $this->assertInstanceof(Entity::class, $post);
  40.     $this->assertInstanceof(Post::class, $post);
  42.     $this->assertSame('1', $post->id);
  43.     $this->assertSame('1', $post['id']);
  44.     $this->assertSame('1', $post->getId());
  45.     $this->assertSame('1', $post->userId);
  46.     $this->assertSame('post summary', $post->summary);
  47.     $this->assertSame('hello world', $post->title);
  48. }

::: tip
底层执行的是 select 语句，这个操作会读取数据库最新信息并刷新实体的属性。
:::

手工启动事务 beginTransaction

  1. public function testBeginTransaction()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $work->beginTransaction();
  20.     $post = Post::find(1);
  21.     $work->update($post);
  23.     try {
  24.         $post->title = 'new title';
  26.         $work->flush();
  27.         $work->commit();
  28.     } catch (Throwable $e) {
  29.         $work->close();
  30.         $work->rollBack();
  31.     }
  33.     $this->assertSame('1', $post->getId());
  34.     $this->assertSame('new title', $post->getTitle());
  35. }

::: tip
通常来说事务工作单元会自动帮你处理事务，可以通过手工 beginTransaction，成功 commit 或者失败 rollBack，系统提供了 API 让你也手工开启事务处理。
:::

执行失败事务回滚 rollBack

  1. public function testFlushButRollBack()
  2. {
  3.     $this->expectException(\Leevel\Database\DuplicateKeyException::class);
  4.     $this->expectExceptionMessage(
  5.         'SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry \'1\' for key \'PRIMARY\''
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $post = new Post([
  11.         'id'      => 1,
  12.         'title'   => 'old',
  13.         'summary' => 'old',
  14.     ]);
  16.     $post2 = new Post([
  17.         'id'      => 1,
  18.         'title'   => 'old',
  19.         'summary' => 'old',
  20.     ]);
  22.     $work->create($post);
  23.     $work->create($post2);
  25.     $work->flush();
  26. }

::: tip
底层会自动运行一个事务，如果执行失败自动回滚，不会更新数据库。
:::

事务包裹在闭包中 transaction

  1. public function testTransaction()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $work->transaction(function ($w) {
  19.         $post = Post::find(1);
  20.         $w->update($post);
  22.         $post->title = 'new title';
  23.     });
  25.     $newPost = Post::find(1);
  27.     $this->assertSame('1', $newPost->getId());
  28.     $this->assertSame('new title', $newPost->getTitle());
  29. }

::: tip
可以将事务包裹在一个闭包中，如果执行失败自动回滚，不会更新数据库。
:::

事务包裹在闭包中失败回滚 transaction

  1. public function testTransactionAndRollBack()
  2. {
  3.     $this->expectException(\Leevel\Database\DuplicateKeyException::class);
  4.     $this->expectExceptionMessage(
  5.         'SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry \'1\' for key \'PRIMARY\''
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $this->assertInstanceof(UnitOfWork::class, $work);
  11.     $this->assertInstanceof(IUnitOfWork::class, $work);
  13.     $connect = $this->createDatabaseConnect();
  15.     $work->transaction(function ($w) {
  16.         $post = new Post([
  17.             'id'      => 1,
  18.             'title'   => 'old',
  19.             'summary' => 'old',
  20.         ]);
  22.         $post2 = new Post([
  23.             'id'      => 1,
  24.             'title'   => 'old',
  25.             'summary' => 'old',
  26.         ]);
  28.         $w->create($post);
  29.         $w->create($post2);
  30.     });
  32.     $this->assertSame(0, $connect->table('post')->findCount());
  33. }

::: tip
可以将事务包裹在一个闭包中，执行失败自动回滚测试，不会更新数据库。
:::

设置根实体 setRootEntity

  1. public function testSetRootEntity()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $post = Post::find(1);
  20.     $work->setRootEntity($post);
  22.     $work->update($post);
  24.     $post->title = 'new title';
  26.     $work->flush();
  28.     $this->assertSame('1', $post->getId());
  29.     $this->assertSame('new title', $post->getTitle());
  31.     $newPost = Post::find(1);
  33.     $this->assertSame('1', $newPost->getId());
  34.     $this->assertSame('new title', $newPost->getTitle());
  35. }

::: tip
系统默认读取基础的数据库配置来处理数据相关信息，设置跟实体可以更改事务处理的数据库连接。
:::

更改数据库连接 setConnect

  1. public function testSetConnectNotFoundWillUseDefault()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $this->assertInstanceof(UnitOfWork::class, $work);
  6.     $this->assertInstanceof(IUnitOfWork::class, $work);
  8.     $connect = $this->createDatabaseConnect();
  10.     $this->assertSame('1', $connect->
  11.     table('post')->
  12.     insert([
  13.         'title'   => 'hello world',
  14.         'user_id' => 1,
  15.         'summary' => 'post summary',
  16.     ]));
  18.     $post = Post::find(1);
  20.     $work->setConnect('hello');
  22.     $work->update($post);
  24.     $post->title = 'new title';
  26.     $work->flush();
  28.     $this->assertSame('1', $post->getId());
  29.     $this->assertSame('new title', $post->getTitle());
  31.     $newPost = Post::find(1);
  33.     $this->assertSame('1', $newPost->getId());
  34.     $this->assertSame('new title', $newPost->getTitle());
  35. }

::: tip
如果没有存在的连接，则会使用默认的连接。
:::

无实体执行 flush 什么都不做

  1. public function testFlushButNotFoundAny()
  2. {
  3.     $work = UnitOfWork::make(new Post());
  5.     $this->assertNull($work->flush());
  6. }

::: tip
实际上什么也不会发生。
:::

实体实体支持缓存

  1. public function testPersistStageManagedEntityDoNothing()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $connect = $this->createDatabaseConnect();
  7.     $post = new Post([
  8.         'id'      => 1,
  9.         'title'   => 'old',
  10.         'summary' => 'old',
  11.     ]);
  13.     $work->persist($post, 'create');
  14.     $work->persist($post, 'create');
  16.     $work->flush();
  18.     $this->assertSame(1, $connect->table('post')->findCount());
  19. }

::: tip
保存两个一样的实体，第二个实体并不会被添加。
:::

重新保存已删除的实体实体

  1. public function testPersistStageRemovedEntity()
  2. {
  3.     $work = UnitOfWork::make();
  5.     $connect = $this->createDatabaseConnect();
  7.     $this->assertSame('1', $connect->
  8.     table('post')->
  9.     insert([
  10.         'title'   => 'hello world',
  11.         'user_id' => 1,
  12.         'summary' => 'post summary',
  13.     ]));
  15.     $post = Post::find(1);
  17.     $this->assertSame('1', $post->getId());
  18.     $this->assertSame('hello world', $post->getTitle());
  19.     $this->assertSame('post summary', $post->getSummary());
  21.     $work->delete($post);
  23.     $work->persist($post);
  25.     $work->flush();
  27.     $this->assertSame(1, $connect->table('post')->findCount());
  28. }

::: tip
这样被删除的实体并不会被删除。
:::

注册更新的实体不能重新被创建

  1. public function testCreateButAlreadyInUpdates()
  2. {
  3.     $this->expectException(\InvalidArgumentException::class);
  4.     $this->expectExceptionMessage(
  5.         'Updated entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $post = new Post(['id' => 5, 'title' => 'foo']);
  12.     $work->update($post);
  14.     $work->create($post);
  15. }

注册删除的实体不能重新被创建

  1. public function testCreateButAlreadyInDeletes()
  2. {
  3.     $this->expectException(\InvalidArgumentException::class);
  4.     $this->expectExceptionMessage(
  5.         'Deleted entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $post = new Post(['id' => 5]);
  12.     $work->delete($post);
  14.     $work->create($post);
  15. }

注册替换的实体不能重新被创建

  1. public function testCreateButAlreadyInReplaces()
  2. {
  3.     $this->expectException(\InvalidArgumentException::class);
  4.     $this->expectExceptionMessage(
  5.         'Replaced entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $post = new Post(['id' => 5]);
  12.     $work->replace($post);
  14.     $work->create($post);
  15. }

不能多次创建同一个实体

  1. public function testCreateManyTimes()
  2. {
  3.     $this->expectException(\InvalidArgumentException::class);
  4.     $this->expectExceptionMessage(
  5.         'Entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for twice.'
  6.     );
  8.     $work = UnitOfWork::make();
  10.     $connect = $this->createDatabaseConnect();
  12.     $post = new Post(['title' => 'foo']);
  14.     $work->create($post);
  15.     $work->create($post);
  16. }