npm - @k2works/claude-code-booster - Versions diffs - 6.2.0 → 6.3.1 - Mend

@k2works/claude-code-booster 6.2.0 → 6.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (618) hide show

package/lib/assets/docs/article/practical-database-design/part4/chapter25.md DELETED Viewed

@@ -1,3670 +0,0 @@
----
-type: Article
-title: "第25章：購買管理の設計"
-description: "本章では、MRP で生成された購買オーダを実際の発注に変換し、入荷・検収までの一連の購買業務を設計します。"
-tags: [article, practical-database-design, part4]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-30T08:34:28Z }
----
-# 第25章：購買管理の設計
-本章では、MRP で生成された購買オーダを実際の発注に変換し、入荷・検収までの一連の購買業務を設計します。
----
-## 25.1 発注業務の DB 設計
-発注業務は、購買オーダを基に取引先への発注を行い、納期管理を行う業務です。
-### 発注業務の流れ
-```plantuml
-@startuml
-title 発注から検収までの業務フロー
-|生産管理部|
-start
-:オーダ情報;
-|購買部|
-:発注;
-fork
-:検査表;
-fork again
-:現品票;
-fork again
-:受領書;
-fork again
-:納品書;
-fork again
-:注文書;
-fork end
-|仕入先|
-fork
-:検査表;
-fork again
-:現品票;
-fork again
-:受領書;
-fork again
-:納品書;
-fork again
-:注文書;
-fork end
-:材料;
-|資材倉庫|
-fork
-:現品表;
-fork again
-:材料;
-fork end
-|品質管理部|
-fork
-:現品表;
-fork again
-:材料;
-fork again
-:検査表;
-fork end
-|購買部|
-:検収;
-|品質管理部|
-:受入検査;
-if (不良品) then
-  |仕入先|
-  :材料;
-  |購買部|
-  :検収返品;
-  |仕入先|
-  :返品通知;
-else (合格品)
-  |資材倉庫|
-  fork
-  :現品表;
-  fork again
-  :材料;
-  fork end
-endif
-stop
-@enduml
-```
-### 発注業務のデータ関連
-発注業務では、オーダ情報を基に発注データを生成し、単価マスタを参照して発注金額を計算します。
-```plantuml
-@startuml
-title 発注業務のデータ関連図
-database "場所マスタ" as location
-database "オーダ情報" as order
-database "単価マスタ" as price
-rectangle "購買計画作成" as plan
-database "購買計画" as purchasePlan
-rectangle "発注" as po
-database "発注情報" as poData
-location --> plan
-order --> plan
-price --> plan
-plan --> purchasePlan
-purchasePlan --> po
-po --> poData
-@enduml
-```
-### 発注関連のスキーマ設計
-発注業務で使用するテーブルを定義します。
-#### テーブル構造
-| テーブル名 | 説明 |
-|-----------|------|
-| 単価マスタ | 品目・取引先ごとの単価情報を管理 |
-| 発注データ | 発注ヘッダ情報（発注番号、取引先、ステータス等） |
-| 発注明細データ | 発注明細情報（品目、数量、単価、金額等） |
-| 諸口品目情報 | マスタに登録されていない臨時品目の情報 |
-#### 発注ステータスの状態遷移
-```plantuml
-@startuml
-title 発注ステータスの状態遷移
-[*] --> 作成中 : 発注作成
-作成中 --> 発注済 : 発注確定
-作成中 --> 取消 : 取消
-発注済 --> 一部入荷 : 分割入荷
-発注済 --> 入荷完了 : 全数入荷
-一部入荷 --> 入荷完了 : 残数入荷
-入荷完了 --> 検収完了 : 検収処理
-検収完了 --> [*]
-取消 --> [*]
-@enduml
-```
-<details>
-<summary>DDL: 発注関連テーブル</summary>
-```sql
--- V009__create_purchasing_tables.sql
--- 発注ステータス
-CREATE TYPE 発注ステータス AS ENUM ('作成中', '発注済', '一部入荷', '入荷完了', '検収完了', '取消');
--- 入荷受入区分
-CREATE TYPE 入荷受入区分 AS ENUM ('通常入荷', '分割入荷', '返品入荷');
--- 単価マスタ
-CREATE TABLE "単価マスタ" (
-    "ID" SERIAL PRIMARY KEY,
-    "品目コード" VARCHAR(20) NOT NULL,
-    "取引先コード" VARCHAR(20) NOT NULL,
-    "ロット単位数" DECIMAL(15, 2) DEFAULT 1 NOT NULL,
-    "使用開始日" DATE NOT NULL,
-    "使用停止日" DATE,
-    "単価" DECIMAL(15, 2) NOT NULL,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_単価マスタ_品目"
-        FOREIGN KEY ("品目コード") REFERENCES "品目マスタ"("品目コード"),
-    CONSTRAINT "fk_単価マスタ_取引先"
-        FOREIGN KEY ("取引先コード") REFERENCES "取引先マスタ"("取引先コード"),
-    UNIQUE ("品目コード", "取引先コード", "ロット単位数", "使用開始日")
-);
--- 発注データ
-CREATE TABLE "発注データ" (
-    "ID" SERIAL PRIMARY KEY,
-    "発注番号" VARCHAR(20) UNIQUE NOT NULL,
-    "発注日" DATE NOT NULL,
-    "取引先コード" VARCHAR(20) NOT NULL,
-    "発注担当者コード" VARCHAR(20),
-    "発注部門コード" VARCHAR(20),
-    "ステータス" 発注ステータス DEFAULT '作成中' NOT NULL,
-    "備考" TEXT,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_発注データ_取引先"
-        FOREIGN KEY ("取引先コード") REFERENCES "取引先マスタ"("取引先コード")
-);
--- 発注明細データ
-CREATE TABLE "発注明細データ" (
-    "ID" SERIAL PRIMARY KEY,
-    "発注番号" VARCHAR(20) NOT NULL,
-    "発注行番号" INTEGER NOT NULL,
-    "オーダNO" VARCHAR(20),
-    "納入場所コード" VARCHAR(20),
-    "品目コード" VARCHAR(20) NOT NULL,
-    "諸口品目区分" BOOLEAN DEFAULT FALSE NOT NULL,
-    "受入予定日" DATE NOT NULL,
-    "回答納期" DATE,
-    "発注単価" DECIMAL(15, 2) NOT NULL,
-    "発注数量" DECIMAL(15, 2) NOT NULL,
-    "入荷済数量" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "検査済数量" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "検収済数量" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "発注金額" DECIMAL(15, 2) NOT NULL,
-    "消費税金額" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "完了フラグ" BOOLEAN DEFAULT FALSE NOT NULL,
-    "明細備考" TEXT,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_発注明細_発注"
-        FOREIGN KEY ("発注番号") REFERENCES "発注データ"("発注番号"),
-    CONSTRAINT "fk_発注明細_品目"
-        FOREIGN KEY ("品目コード") REFERENCES "品目マスタ"("品目コード"),
-    UNIQUE ("発注番号", "発注行番号")
-);
--- 諸口品目情報（マスタに登録されていない臨時品目）
-CREATE TABLE "諸口品目情報" (
-    "ID" SERIAL PRIMARY KEY,
-    "発注番号" VARCHAR(20) NOT NULL,
-    "発注行番号" INTEGER NOT NULL,
-    "品目コード" VARCHAR(20) NOT NULL,
-    "品名" VARCHAR(100) NOT NULL,
-    "規格" VARCHAR(100),
-    "図番メーカー" VARCHAR(100),
-    "版数" VARCHAR(20),
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    UNIQUE ("発注番号", "発注行番号", "品目コード")
-);
--- インデックス
-CREATE INDEX "idx_発注データ_取引先コード" ON "発注データ"("取引先コード");
-CREATE INDEX "idx_発注データ_発注日" ON "発注データ"("発注日");
-CREATE INDEX "idx_発注明細_発注番号" ON "発注明細データ"("発注番号");
-CREATE INDEX "idx_発注明細_品目コード" ON "発注明細データ"("品目コード");
-CREATE INDEX "idx_単価マスタ_品目取引先" ON "単価マスタ"("品目コード", "取引先コード");
-```
-</details>
-### オーダ情報・場所マスタ・単価マスタとの連携
-発注データは以下のマスタ情報と連携します。
-```plantuml
-@startuml
-title 発注データとマスタの関連
-entity "発注データ" as po {
-  * 発注番号 [PK]
-  --
-  取引先コード [FK]
-  発注日
-  ステータス
-}
-entity "発注明細データ" as pod {
-  * 発注番号 [PK,FK]
-  * 発注行番号 [PK]
-  --
-  オーダNO [FK]
-  品目コード [FK]
-  納入場所コード [FK]
-  発注数量
-  発注単価
-}
-entity "オーダ情報" as order {
-  * オーダNO [PK]
-  --
-  品目コード
-  所要数量
-  所要日
-}
-entity "単価マスタ" as price {
-  * ID [PK]
-  --
-  品目コード [FK]
-  取引先コード [FK]
-  単価
-  使用開始日
-  使用停止日
-}
-entity "場所マスタ" as location {
-  * 場所コード [PK]
-  --
-  場所名
-}
-entity "取引先マスタ" as supplier {
-  * 取引先コード [PK]
-  --
-  取引先名
-}
-po ||--o{ pod : contains
-po }o--|| supplier : 発注先
-pod }o--o| order : 紐付け
-pod }o--|| price : 単価参照
-pod }o--o| location : 納入先
-@enduml
-```
-### 諸口品目の扱い
-マスタに登録されていない臨時品目（諸口品目）を発注する場合、発注明細データの「諸口品目区分」を `TRUE` に設定し、諸口品目情報テーブルに品目の詳細情報を登録します。
-```plantuml
-@startuml
-title 諸口品目の関連
-entity "発注明細データ" as pod {
-  * 発注番号 [PK]
-  * 発注行番号 [PK]
-  --
-  品目コード
-  諸口品目区分
-}
-entity "諸口品目情報" as misc {
-  * ID [PK]
-  --
-  発注番号 [FK]
-  発注行番号 [FK]
-  品目コード
-  品名
-  規格
-  図番メーカー
-  版数
-}
-pod ||--o| misc : 諸口品目の場合
-note right of misc
-  品目マスタに登録されていない
-  臨時品目の情報を保持
-end note
-@enduml
-```
-### 納期管理・分納対応
-発注明細には「受入予定日」と「回答納期」の 2 つの日付を持ちます。
-| フィールド | 説明 |
-|-----------|------|
-| 受入予定日 | 発注時に指定した希望納期 |
-| 回答納期 | 仕入先から回答された実際の納期 |
-分納（分割納品）に対応するため、発注明細ごとに「入荷済数量」「検査済数量」「検収済数量」を管理します。
-### Java エンティティの定義
-<details>
-<summary>発注ステータス Enum</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/PurchaseOrderStatus.java
-package com.example.pms.domain.model.purchase;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-@Getter
-@RequiredArgsConstructor
-public enum PurchaseOrderStatus {
-    CREATING("作成中"),
-    ORDERED("発注済"),
-    PARTIALLY_RECEIVED("一部入荷"),
-    RECEIVED("入荷完了"),
-    ACCEPTED("検収完了"),
-    CANCELLED("取消");
-    private final String displayName;
-    public static PurchaseOrderStatus fromDisplayName(String displayName) {
-        for (PurchaseOrderStatus status : values()) {
-            if (status.displayName.equals(displayName)) {
-                return status;
-            }
-        }
-        throw new IllegalArgumentException("不正な発注ステータス: " + displayName);
-    }
-}
-```
-</details>
-<details>
-<summary>入荷受入区分 Enum</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/ReceivingType.java
-package com.example.pms.domain.model.purchase;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-@Getter
-@RequiredArgsConstructor
-public enum ReceivingType {
-    NORMAL("通常入荷"),
-    SPLIT("分割入荷"),
-    RETURN("返品入荷");
-    private final String displayName;
-    public static ReceivingType fromDisplayName(String displayName) {
-        for (ReceivingType type : values()) {
-            if (type.displayName.equals(displayName)) {
-                return type;
-            }
-        }
-        throw new IllegalArgumentException("不正な入荷受入区分: " + displayName);
-    }
-}
-```
-</details>
-<details>
-<summary>単価マスタエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/UnitPrice.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.item.Item;
-import com.example.pms.domain.model.supplier.Supplier;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class UnitPrice {
-    private Integer id;
-    private String itemCode;
-    private String supplierCode;
-    private BigDecimal lotUnitQuantity;
-    private LocalDate effectiveFrom;
-    private LocalDate effectiveTo;
-    private BigDecimal unitPrice;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private Item item;
-    private Supplier supplier;
-}
-```
-</details>
-<details>
-<summary>発注データエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/PurchaseOrder.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.supplier.Supplier;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.List;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class PurchaseOrder {
-    private Integer id;
-    private String purchaseOrderNumber;
-    private LocalDate orderDate;
-    private String supplierCode;
-    private String ordererCode;
-    private String departmentCode;
-    private PurchaseOrderStatus status;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private Supplier supplier;
-    private List<PurchaseOrderDetail> details;
-}
-```
-</details>
-<details>
-<summary>発注明細データエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/PurchaseOrderDetail.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.item.Item;
-import com.example.pms.domain.model.plan.Order;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.List;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class PurchaseOrderDetail {
-    private Integer id;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private String orderNumber;
-    private String deliveryLocationCode;
-    private String itemCode;
-    private Boolean miscellaneousItemFlag;
-    private LocalDate expectedReceivingDate;
-    private LocalDate confirmedDeliveryDate;
-    private BigDecimal orderUnitPrice;
-    private BigDecimal orderQuantity;
-    private BigDecimal receivedQuantity;
-    private BigDecimal inspectedQuantity;
-    private BigDecimal acceptedQuantity;
-    private BigDecimal orderAmount;
-    private BigDecimal taxAmount;
-    private Boolean completedFlag;
-    private String detailRemarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private PurchaseOrder purchaseOrder;
-    private Item item;
-    private Order order;
-    private MiscellaneousItem miscellaneousItem;
-    private List<Receiving> receivings;
-    private List<Acceptance> acceptances;
-}
-```
-</details>
-<details>
-<summary>諸口品目情報エンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/MiscellaneousItem.java
-package com.example.pms.domain.model.purchase;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.time.LocalDateTime;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class MiscellaneousItem {
-    private Integer id;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private String itemCode;
-    private String itemName;
-    private String specification;
-    private String manufacturerDrawingNumber;
-    private String revision;
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-}
-```
-</details>
-### TypeHandler の実装
-PostgreSQL の日本語 ENUM 型と Java の英語 Enum を相互変換するために TypeHandler を実装します。
-<details>
-<summary>PurchaseOrderStatusTypeHandler</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/typehandler/PurchaseOrderStatusTypeHandler.java
-package com.example.pms.infrastructure.out.persistence.typehandler;
-import com.example.pms.domain.model.purchase.PurchaseOrderStatus;
-import org.apache.ibatis.type.BaseTypeHandler;
-import org.apache.ibatis.type.JdbcType;
-import org.apache.ibatis.type.MappedTypes;
-import java.sql.CallableStatement;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-@MappedTypes(PurchaseOrderStatus.class)
-public class PurchaseOrderStatusTypeHandler extends BaseTypeHandler<PurchaseOrderStatus> {
-    @Override
-    public void setNonNullParameter(PreparedStatement ps, int i, PurchaseOrderStatus parameter, JdbcType jdbcType)
-            throws SQLException {
-        ps.setString(i, parameter.getDisplayName());
-    }
-    @Override
-    public PurchaseOrderStatus getNullableResult(ResultSet rs, String columnName) throws SQLException {
-        String value = rs.getString(columnName);
-        return value == null ? null : PurchaseOrderStatus.fromDisplayName(value);
-    }
-    @Override
-    public PurchaseOrderStatus getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
-        String value = rs.getString(columnIndex);
-        return value == null ? null : PurchaseOrderStatus.fromDisplayName(value);
-    }
-    @Override
-    public PurchaseOrderStatus getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
-        String value = cs.getString(columnIndex);
-        return value == null ? null : PurchaseOrderStatus.fromDisplayName(value);
-    }
-}
-```
-</details>
-<details>
-<summary>ReceivingTypeTypeHandler</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/typehandler/ReceivingTypeTypeHandler.java
-package com.example.pms.infrastructure.out.persistence.typehandler;
-import com.example.pms.domain.model.purchase.ReceivingType;
-import org.apache.ibatis.type.BaseTypeHandler;
-import org.apache.ibatis.type.JdbcType;
-import org.apache.ibatis.type.MappedTypes;
-import java.sql.CallableStatement;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-@MappedTypes(ReceivingType.class)
-public class ReceivingTypeTypeHandler extends BaseTypeHandler<ReceivingType> {
-    @Override
-    public void setNonNullParameter(PreparedStatement ps, int i, ReceivingType parameter, JdbcType jdbcType)
-            throws SQLException {
-        ps.setString(i, parameter.getDisplayName());
-    }
-    @Override
-    public ReceivingType getNullableResult(ResultSet rs, String columnName) throws SQLException {
-        String value = rs.getString(columnName);
-        return value == null ? null : ReceivingType.fromDisplayName(value);
-    }
-    @Override
-    public ReceivingType getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
-        String value = rs.getString(columnIndex);
-        return value == null ? null : ReceivingType.fromDisplayName(value);
-    }
-    @Override
-    public ReceivingType getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
-        String value = cs.getString(columnIndex);
-        return value == null ? null : ReceivingType.fromDisplayName(value);
-    }
-}
-```
-</details>
-### MyBatis Mapper XML
-<details>
-<summary>UnitPriceMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/UnitPriceMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.UnitPriceMapper">
-    <resultMap id="UnitPriceResultMap" type="com.example.pms.domain.model.purchase.UnitPrice">
-        <id property="id" column="ID"/>
-        <result property="itemCode" column="品目コード"/>
-        <result property="supplierCode" column="取引先コード"/>
-        <result property="lotUnitQuantity" column="ロット単位数"/>
-        <result property="effectiveFrom" column="使用開始日"/>
-        <result property="effectiveTo" column="使用停止日"/>
-        <result property="unitPrice" column="単価"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <insert id="insert" useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
-        INSERT INTO "単価マスタ" (
-            "品目コード", "取引先コード", "ロット単位数", "使用開始日",
-            "使用停止日", "単価", "作成者"
-        ) VALUES (
-            #{itemCode},
-            #{supplierCode},
-            #{lotUnitQuantity},
-            #{effectiveFrom},
-            #{effectiveTo},
-            #{unitPrice},
-            #{createdBy}
-        )
-    </insert>
-    <select id="findEffectiveUnitPrice" resultMap="UnitPriceResultMap">
-        SELECT * FROM "単価マスタ"
-        WHERE "品目コード" = #{itemCode}
-          AND "取引先コード" = #{supplierCode}
-          AND "使用開始日" &lt;= #{date}
-          AND ("使用停止日" IS NULL OR "使用停止日" &gt;= #{date})
-        ORDER BY "使用開始日" DESC
-        LIMIT 1
-    </select>
-    <delete id="deleteAll">
-        DELETE FROM "単価マスタ"
-    </delete>
-</mapper>
-```
-</details>
-<details>
-<summary>PurchaseOrderMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/PurchaseOrderMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.PurchaseOrderMapper">
-    <resultMap id="PurchaseOrderResultMap" type="com.example.pms.domain.model.purchase.PurchaseOrder">
-        <id property="id" column="ID"/>
-        <result property="purchaseOrderNumber" column="発注番号"/>
-        <result property="orderDate" column="発注日"/>
-        <result property="supplierCode" column="取引先コード"/>
-        <result property="ordererCode" column="発注担当者コード"/>
-        <result property="departmentCode" column="発注部門コード"/>
-        <result property="status" column="ステータス"
-                typeHandler="com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler"/>
-        <result property="remarks" column="備考"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <!-- PostgreSQL用 INSERT -->
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.PurchaseOrder"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID" databaseId="postgresql">
-        INSERT INTO "発注データ" (
-            "発注番号", "発注日", "取引先コード", "発注担当者コード", "発注部門コード",
-            "ステータス", "備考", "作成者", "更新者"
-        ) VALUES (
-            #{purchaseOrderNumber},
-            #{orderDate},
-            #{supplierCode},
-            #{ordererCode},
-            #{departmentCode},
-            #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler}::発注ステータス,
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <!-- H2用 INSERT -->
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.PurchaseOrder"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID" databaseId="h2">
-        INSERT INTO "発注データ" (
-            "発注番号", "発注日", "取引先コード", "発注担当者コード", "発注部門コード",
-            "ステータス", "備考", "作成者", "更新者"
-        ) VALUES (
-            #{purchaseOrderNumber},
-            #{orderDate},
-            #{supplierCode},
-            #{ordererCode},
-            #{departmentCode},
-            #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler},
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <select id="findById" resultMap="PurchaseOrderResultMap">
-        SELECT * FROM "発注データ" WHERE "ID" = #{id}
-    </select>
-    <select id="findByPurchaseOrderNumber" resultMap="PurchaseOrderResultMap">
-        SELECT * FROM "発注データ" WHERE "発注番号" = #{purchaseOrderNumber}
-    </select>
-    <select id="findBySupplierCode" resultMap="PurchaseOrderResultMap">
-        SELECT * FROM "発注データ" WHERE "取引先コード" = #{supplierCode} ORDER BY "発注日" DESC
-    </select>
-    <!-- PostgreSQL用 findByStatus -->
-    <select id="findByStatus" resultMap="PurchaseOrderResultMap" databaseId="postgresql">
-        SELECT * FROM "発注データ" WHERE "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler}::発注ステータス ORDER BY "発注日" DESC
-    </select>
-    <!-- H2用 findByStatus -->
-    <select id="findByStatus" resultMap="PurchaseOrderResultMap" databaseId="h2">
-        SELECT * FROM "発注データ" WHERE "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler} ORDER BY "発注日" DESC
-    </select>
-    <select id="findAll" resultMap="PurchaseOrderResultMap">
-        SELECT * FROM "発注データ" ORDER BY "発注日" DESC
-    </select>
-    <!-- PostgreSQL用 updateStatus -->
-    <update id="updateStatus" databaseId="postgresql">
-        UPDATE "発注データ"
-        SET "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler}::発注ステータス,
-            "更新日時" = CURRENT_TIMESTAMP
-        WHERE "ID" = #{id}
-    </update>
-    <!-- H2用 updateStatus -->
-    <update id="updateStatus" databaseId="h2">
-        UPDATE "発注データ"
-        SET "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler},
-            "更新日時" = CURRENT_TIMESTAMP
-        WHERE "ID" = #{id}
-    </update>
-    <!-- PostgreSQL用 DELETE -->
-    <delete id="deleteAll" databaseId="postgresql">
-        TRUNCATE TABLE "発注データ" CASCADE
-    </delete>
-    <!-- H2用 DELETE -->
-    <delete id="deleteAll" databaseId="h2">
-        DELETE FROM "発注データ"
-    </delete>
-</mapper>
-```
-</details>
-<details>
-<summary>PurchaseOrderDetailMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/PurchaseOrderDetailMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.PurchaseOrderDetailMapper">
-    <resultMap id="PurchaseOrderDetailResultMap" type="com.example.pms.domain.model.purchase.PurchaseOrderDetail">
-        <id property="id" column="ID"/>
-        <result property="purchaseOrderNumber" column="発注番号"/>
-        <result property="lineNumber" column="発注行番号"/>
-        <result property="orderNumber" column="オーダNO"/>
-        <result property="deliveryLocationCode" column="納入場所コード"/>
-        <result property="itemCode" column="品目コード"/>
-        <result property="miscellaneousItemFlag" column="諸口品目区分"/>
-        <result property="expectedReceivingDate" column="受入予定日"/>
-        <result property="confirmedDeliveryDate" column="回答納期"/>
-        <result property="orderUnitPrice" column="発注単価"/>
-        <result property="orderQuantity" column="発注数量"/>
-        <result property="receivedQuantity" column="入荷済数量"/>
-        <result property="inspectedQuantity" column="検査済数量"/>
-        <result property="acceptedQuantity" column="検収済数量"/>
-        <result property="orderAmount" column="発注金額"/>
-        <result property="taxAmount" column="消費税金額"/>
-        <result property="completedFlag" column="完了フラグ"/>
-        <result property="detailRemarks" column="明細備考"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <insert id="insert" useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
-        INSERT INTO "発注明細データ" (
-            "発注番号", "発注行番号", "オーダNO", "納入場所コード", "品目コード",
-            "諸口品目区分", "受入予定日", "回答納期", "発注単価", "発注数量",
-            "発注金額", "消費税金額", "作成者"
-        ) VALUES (
-            #{purchaseOrderNumber},
-            #{lineNumber},
-            #{orderNumber},
-            #{deliveryLocationCode},
-            #{itemCode},
-            #{miscellaneousItemFlag},
-            #{expectedReceivingDate},
-            #{confirmedDeliveryDate},
-            #{orderUnitPrice},
-            #{orderQuantity},
-            #{orderAmount},
-            #{taxAmount},
-            #{createdBy}
-        )
-    </insert>
-    <select id="findByPurchaseOrderNumber" resultMap="PurchaseOrderDetailResultMap">
-        SELECT * FROM "発注明細データ"
-        WHERE "発注番号" = #{purchaseOrderNumber}
-        ORDER BY "発注行番号"
-    </select>
-    <select id="findByPurchaseOrderNumberAndLineNumber" resultMap="PurchaseOrderDetailResultMap">
-        SELECT * FROM "発注明細データ"
-        WHERE "発注番号" = #{purchaseOrderNumber} AND "発注行番号" = #{lineNumber}
-    </select>
-    <update id="updateReceivedQuantity">
-        UPDATE "発注明細データ"
-        SET "入荷済数量" = #{receivedQuantity}, "更新日時" = CURRENT_TIMESTAMP
-        WHERE "発注番号" = #{purchaseOrderNumber} AND "発注行番号" = #{lineNumber}
-    </update>
-    <update id="updateAcceptedQuantity">
-        UPDATE "発注明細データ"
-        SET "検収済数量" = #{acceptedQuantity}, "更新日時" = CURRENT_TIMESTAMP
-        WHERE "発注番号" = #{purchaseOrderNumber} AND "発注行番号" = #{lineNumber}
-    </update>
-    <delete id="deleteAll">
-        DELETE FROM "発注明細データ"
-    </delete>
-</mapper>
-```
-</details>
-### Mapper インターフェース
-<details>
-<summary>UnitPriceMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/UnitPriceMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.UnitPrice;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import java.time.LocalDate;
-@Mapper
-public interface UnitPriceMapper {
-    void insert(UnitPrice unitPrice);
-    UnitPrice findEffectiveUnitPrice(@Param("itemCode") String itemCode,
-                                     @Param("supplierCode") String supplierCode,
-                                     @Param("date") LocalDate date);
-    void deleteAll();
-}
-```
-</details>
-<details>
-<summary>PurchaseOrderMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/PurchaseOrderMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.PurchaseOrder;
-import com.example.pms.domain.model.purchase.PurchaseOrderStatus;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import java.util.List;
-@Mapper
-public interface PurchaseOrderMapper {
-    void insert(PurchaseOrder purchaseOrder);
-    PurchaseOrder findById(Integer id);
-    PurchaseOrder findByPurchaseOrderNumber(String purchaseOrderNumber);
-    List<PurchaseOrder> findBySupplierCode(String supplierCode);
-    List<PurchaseOrder> findByStatus(PurchaseOrderStatus status);
-    List<PurchaseOrder> findAll();
-    void updateStatus(@Param("id") Integer id, @Param("status") PurchaseOrderStatus status);
-    void deleteAll();
-}
-```
-</details>
-<details>
-<summary>PurchaseOrderDetailMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/PurchaseOrderDetailMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.PurchaseOrderDetail;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import java.math.BigDecimal;
-import java.util.List;
-@Mapper
-public interface PurchaseOrderDetailMapper {
-    void insert(PurchaseOrderDetail detail);
-    List<PurchaseOrderDetail> findByPurchaseOrderNumber(String purchaseOrderNumber);
-    PurchaseOrderDetail findByPurchaseOrderNumberAndLineNumber(
-            @Param("purchaseOrderNumber") String purchaseOrderNumber,
-            @Param("lineNumber") Integer lineNumber);
-    void updateReceivedQuantity(@Param("purchaseOrderNumber") String purchaseOrderNumber,
-                                @Param("lineNumber") Integer lineNumber,
-                                @Param("receivedQuantity") BigDecimal receivedQuantity);
-    void updateAcceptedQuantity(@Param("purchaseOrderNumber") String purchaseOrderNumber,
-                                @Param("lineNumber") Integer lineNumber,
-                                @Param("acceptedQuantity") BigDecimal acceptedQuantity);
-    void deleteAll();
-}
-```
-</details>
-### 発注サービスの実装
-<details>
-<summary>PurchaseOrderService</summary>
-```java
-// src/main/java/com/example/pms/application/service/PurchaseOrderService.java
-package com.example.pms.application.service;
-import com.example.pms.domain.model.purchase.*;
-import com.example.pms.infrastructure.out.persistence.mapper.*;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.List;
-@Service
-@RequiredArgsConstructor
-public class PurchaseOrderService {
-    private final PurchaseOrderMapper purchaseOrderMapper;
-    private final PurchaseOrderDetailMapper purchaseOrderDetailMapper;
-    private final UnitPriceMapper unitPriceMapper;
-    /**
-     * 発注番号を生成する
-     */
-    private String generatePurchaseOrderNumber(LocalDate orderDate) {
-        String prefix = "PO-" + orderDate.format(DateTimeFormatter.ofPattern("yyyyMM")) + "-";
-        String latestNumber = purchaseOrderMapper.findLatestPurchaseOrderNumber(prefix + "%");
-        int sequence = 1;
-        if (latestNumber != null) {
-            int currentSequence = Integer.parseInt(latestNumber.substring(latestNumber.length() - 4));
-            sequence = currentSequence + 1;
-        }
-        return prefix + String.format("%04d", sequence);
-    }
-    /**
-     * 発注を作成する
-     */
-    @Transactional
-    public PurchaseOrder createPurchaseOrder(PurchaseOrderCreateInput input) {
-        String purchaseOrderNumber = generatePurchaseOrderNumber(input.getOrderDate());
-        BigDecimal taxRate = input.getTaxRate() != null ? input.getTaxRate() : new BigDecimal("10");
-        // 発注ヘッダを作成
-        PurchaseOrder purchaseOrder = PurchaseOrder.builder()
-                .purchaseOrderNumber(purchaseOrderNumber)
-                .orderDate(input.getOrderDate())
-                .supplierCode(input.getSupplierCode())
-                .ordererCode(input.getOrdererCode())
-                .departmentCode(input.getDepartmentCode())
-                .status(PurchaseOrderStatus.CREATING)
-                .remarks(input.getRemarks())
-                .build();
-        purchaseOrderMapper.insert(purchaseOrder);
-        // 発注明細を作成
-        List<PurchaseOrderDetail> details = new ArrayList<>();
-        int lineNumber = 0;
-        for (PurchaseOrderDetailInput detailInput : input.getDetails()) {
-            lineNumber++;
-            // 単価を取得
-            UnitPrice unitPrice = unitPriceMapper.findEffectiveUnitPrice(
-                    detailInput.getItemCode(),
-                    input.getSupplierCode(),
-                    input.getOrderDate()
-            );
-            if (unitPrice == null) {
-                throw new IllegalArgumentException(
-                        "Unit price not found: " + detailInput.getItemCode() + " / " + input.getSupplierCode());
-            }
-            // 金額計算
-            BigDecimal orderAmount = unitPrice.getUnitPrice().multiply(detailInput.getOrderQuantity());
-            BigDecimal taxAmount = orderAmount.multiply(taxRate)
-                    .divide(new BigDecimal("100"), 0, RoundingMode.HALF_UP);
-            PurchaseOrderDetail detail = PurchaseOrderDetail.builder()
-                    .purchaseOrderNumber(purchaseOrderNumber)
-                    .lineNumber(lineNumber)
-                    .orderNumber(detailInput.getOrderNumber())
-                    .deliveryLocationCode(detailInput.getDeliveryLocationCode())
-                    .itemCode(detailInput.getItemCode())
-                    .miscellaneousItemFlag(false)
-                    .expectedReceivingDate(detailInput.getExpectedReceivingDate())
-                    .orderUnitPrice(unitPrice.getUnitPrice())
-                    .orderQuantity(detailInput.getOrderQuantity())
-                    .orderAmount(orderAmount)
-                    .taxAmount(taxAmount)
-                    .build();
-            purchaseOrderDetailMapper.insert(detail);
-            details.add(detail);
-        }
-        purchaseOrder.setDetails(details);
-        return purchaseOrder;
-    }
-    /**
-     * 発注を確定する
-     */
-    @Transactional
-    public PurchaseOrder confirmPurchaseOrder(String purchaseOrderNumber) {
-        PurchaseOrder purchaseOrder = purchaseOrderMapper.findByPurchaseOrderNumber(purchaseOrderNumber);
-        if (purchaseOrder == null) {
-            throw new IllegalArgumentException("Purchase order not found: " + purchaseOrderNumber);
-        }
-        if (purchaseOrder.getStatus() != PurchaseOrderStatus.CREATING) {
-            throw new IllegalStateException("Only creating purchase orders can be confirmed: " + purchaseOrderNumber);
-        }
-        purchaseOrderMapper.updateStatus(purchaseOrderNumber, PurchaseOrderStatus.ORDERED);
-        purchaseOrder.setStatus(PurchaseOrderStatus.ORDERED);
-        return purchaseOrder;
-    }
-    /**
-     * 発注を取消する
-     */
-    @Transactional
-    public PurchaseOrder cancelPurchaseOrder(String purchaseOrderNumber) {
-        PurchaseOrder purchaseOrder = purchaseOrderMapper.findByPurchaseOrderNumber(purchaseOrderNumber);
-        if (purchaseOrder == null) {
-            throw new IllegalArgumentException("Purchase order not found: " + purchaseOrderNumber);
-        }
-        List<PurchaseOrderDetail> details = purchaseOrderDetailMapper.findByPurchaseOrderNumber(purchaseOrderNumber);
-        boolean hasReceived = details.stream()
-                .anyMatch(d -> d.getReceivedQuantity() != null &&
-                        d.getReceivedQuantity().compareTo(BigDecimal.ZERO) > 0);
-        if (hasReceived) {
-            throw new IllegalStateException("Cannot cancel purchase order with received items: " + purchaseOrderNumber);
-        }
-        purchaseOrderMapper.updateStatus(purchaseOrderNumber, PurchaseOrderStatus.CANCELLED);
-        purchaseOrder.setStatus(PurchaseOrderStatus.CANCELLED);
-        return purchaseOrder;
-    }
-}
-```
-</details>
-<details>
-<summary>入力 DTO クラス</summary>
-```java
-// src/main/java/com/example/pms/application/service/PurchaseOrderCreateInput.java
-package com.example.pms.application.service;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.util.List;
-@Data
-@Builder
-public class PurchaseOrderCreateInput {
-    private String supplierCode;
-    private LocalDate orderDate;
-    private String ordererCode;
-    private String departmentCode;
-    private BigDecimal taxRate;
-    private String remarks;
-    private List<PurchaseOrderDetailInput> details;
-}
-```
-```java
-// src/main/java/com/example/pms/application/service/PurchaseOrderDetailInput.java
-package com.example.pms.application.service;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-@Data
-@Builder
-public class PurchaseOrderDetailInput {
-    private String itemCode;
-    private BigDecimal orderQuantity;
-    private LocalDate expectedReceivingDate;
-    private String orderNumber;
-    private String deliveryLocationCode;
-}
-```
-</details>
-### TDD: 発注データの登録テスト
-<details>
-<summary>PurchaseOrderServiceTest</summary>
-```java
-// src/test/java/com/example/pms/application/service/PurchaseOrderServiceTest.java
-package com.example.pms.application.service;
-import com.example.pms.domain.model.item.Item;
-import com.example.pms.domain.model.item.ItemCategory;
-import com.example.pms.domain.model.master.Supplier;
-import com.example.pms.domain.model.purchase.*;
-import com.example.pms.infrastructure.out.persistence.mapper.*;
-import org.junit.jupiter.api.*;
-import org.mybatis.spring.boot.test.autoconfigure.MybatisTest;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
-import org.springframework.context.annotation.Import;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.PostgreSQLContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.util.List;
-import static org.assertj.core.api.Assertions.*;
-@MybatisTest
-@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-@Import(PurchaseOrderService.class)
-@Testcontainers
-@DisplayName("発注業務")
-class PurchaseOrderServiceTest {
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
-            .withDatabaseName("testdb")
-            .withUsername("testuser")
-            .withPassword("testpass");
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-    }
-    @Autowired
-    private PurchaseOrderService purchaseOrderService;
-    @Autowired
-    private PurchaseOrderMapper purchaseOrderMapper;
-    @Autowired
-    private PurchaseOrderDetailMapper purchaseOrderDetailMapper;
-    @Autowired
-    private ItemMapper itemMapper;
-    @Autowired
-    private SupplierMapper supplierMapper;
-    @Autowired
-    private UnitPriceMapper unitPriceMapper;
-    @BeforeEach
-    void setUp() {
-        purchaseOrderDetailMapper.deleteAll();
-        purchaseOrderMapper.deleteAll();
-        unitPriceMapper.deleteAll();
-        supplierMapper.deleteAll();
-        itemMapper.deleteAll();
-    }
-    @Nested
-    @DisplayName("発注データの作成")
-    class PurchaseOrderCreation {
-        @Test
-        @DisplayName("購買オーダから発注データを作成できる")
-        void canCreatePurchaseOrderFromOrder() {
-            // Arrange: マスタデータを準備
-            Supplier supplier = Supplier.builder()
-                    .supplierCode("SUP-001")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .supplierName("テスト仕入先株式会社")
-                    .supplierNameKana("テストシイレサキカブシキガイシャ")
-                    .build();
-            supplierMapper.insert(supplier);
-            Item item = Item.builder()
-                    .itemCode("MAT-001")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .itemName("材料A")
-                    .itemCategory(ItemCategory.MATERIAL)
-                    .build();
-            itemMapper.insert(item);
-            UnitPrice unitPrice = UnitPrice.builder()
-                    .itemCode("MAT-001")
-                    .supplierCode("SUP-001")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .unitPrice(new BigDecimal("1000"))
-                    .build();
-            unitPriceMapper.insert(unitPrice);
-            // Act: 発注を作成
-            PurchaseOrderCreateInput input = PurchaseOrderCreateInput.builder()
-                    .supplierCode("SUP-001")
-                    .orderDate(LocalDate.of(2025, 1, 15))
-                    .taxRate(new BigDecimal("10"))
-                    .details(List.of(
-                            PurchaseOrderDetailInput.builder()
-                                    .itemCode("MAT-001")
-                                    .orderQuantity(new BigDecimal("100"))
-                                    .expectedReceivingDate(LocalDate.of(2025, 1, 25))
-                                    .build()
-                    ))
-                    .build();
-            PurchaseOrder purchaseOrder = purchaseOrderService.createPurchaseOrder(input);
-            // Assert
-            assertThat(purchaseOrder).isNotNull();
-            assertThat(purchaseOrder.getPurchaseOrderNumber()).startsWith("PO-");
-            assertThat(purchaseOrder.getStatus()).isEqualTo(PurchaseOrderStatus.CREATING);
-            assertThat(purchaseOrder.getDetails()).hasSize(1);
-            assertThat(purchaseOrder.getDetails().get(0).getOrderQuantity())
-                    .isEqualByComparingTo(new BigDecimal("100"));
-            assertThat(purchaseOrder.getDetails().get(0).getOrderUnitPrice())
-                    .isEqualByComparingTo(new BigDecimal("1000"));
-            assertThat(purchaseOrder.getDetails().get(0).getOrderAmount())
-                    .isEqualByComparingTo(new BigDecimal("100000"));
-        }
-        @Test
-        @DisplayName("発注を発注済ステータスに変更できる")
-        void canConfirmPurchaseOrder() {
-            // Arrange: 発注データを準備
-            Supplier supplier = Supplier.builder()
-                    .supplierCode("SUP-003")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .supplierName("ステータス確認用仕入先")
-                    .build();
-            supplierMapper.insert(supplier);
-            Item item = Item.builder()
-                    .itemCode("MAT-004")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .itemName("材料D")
-                    .itemCategory(ItemCategory.MATERIAL)
-                    .build();
-            itemMapper.insert(item);
-            unitPriceMapper.insert(UnitPrice.builder()
-                    .itemCode("MAT-004")
-                    .supplierCode("SUP-003")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .unitPrice(new BigDecimal("2000"))
-                    .build());
-            PurchaseOrderCreateInput input = PurchaseOrderCreateInput.builder()
-                    .supplierCode("SUP-003")
-                    .orderDate(LocalDate.of(2025, 1, 15))
-                    .details(List.of(
-                            PurchaseOrderDetailInput.builder()
-                                    .itemCode("MAT-004")
-                                    .orderQuantity(new BigDecimal("10"))
-                                    .expectedReceivingDate(LocalDate.of(2025, 1, 25))
-                                    .build()
-                    ))
-                    .build();
-            PurchaseOrder purchaseOrder = purchaseOrderService.createPurchaseOrder(input);
-            // Act: 発注確定
-            PurchaseOrder confirmedOrder = purchaseOrderService.confirmPurchaseOrder(
-                    purchaseOrder.getPurchaseOrderNumber());
-            // Assert
-            assertThat(confirmedOrder.getStatus()).isEqualTo(PurchaseOrderStatus.ORDERED);
-        }
-    }
-    @Nested
-    @DisplayName("消費税計算")
-    class TaxCalculation {
-        @Test
-        @DisplayName("消費税額が正しく計算される")
-        void calculatesTaxCorrectly() {
-            // Arrange
-            Supplier supplier = Supplier.builder()
-                    .supplierCode("SUP-004")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .supplierName("消費税確認用仕入先")
-                    .build();
-            supplierMapper.insert(supplier);
-            Item item = Item.builder()
-                    .itemCode("MAT-005")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .itemName("材料E")
-                    .itemCategory(ItemCategory.MATERIAL)
-                    .build();
-            itemMapper.insert(item);
-            unitPriceMapper.insert(UnitPrice.builder()
-                    .itemCode("MAT-005")
-                    .supplierCode("SUP-004")
-                    .effectiveFrom(LocalDate.of(2025, 1, 1))
-                    .unitPrice(new BigDecimal("1000"))
-                    .build());
-            // Act
-            PurchaseOrderCreateInput input = PurchaseOrderCreateInput.builder()
-                    .supplierCode("SUP-004")
-                    .orderDate(LocalDate.of(2025, 1, 15))
-                    .taxRate(new BigDecimal("10"))
-                    .details(List.of(
-                            PurchaseOrderDetailInput.builder()
-                                    .itemCode("MAT-005")
-                                    .orderQuantity(new BigDecimal("100"))
-                                    .expectedReceivingDate(LocalDate.of(2025, 1, 25))
-                                    .build()
-                    ))
-                    .build();
-            PurchaseOrder purchaseOrder = purchaseOrderService.createPurchaseOrder(input);
-            // Assert: 100 × 1000 = 100,000円、消費税 10,000円
-            assertThat(purchaseOrder.getDetails().get(0).getOrderAmount())
-                    .isEqualByComparingTo(new BigDecimal("100000"));
-            assertThat(purchaseOrder.getDetails().get(0).getTaxAmount())
-                    .isEqualByComparingTo(new BigDecimal("10000"));
-        }
-    }
-}
-```
-</details>
----
-## 25.2 入荷・検収業務の DB 設計
-入荷・検収業務は、発注した品目が納品された後の一連の処理を管理します。
-### 入荷・受入業務の流れ
-```plantuml
-@startuml
-title 入荷から検収までの流れ
-start
-:発注明細;
-:入荷受付;
-note right
-・納品書と現品の確認
-・入荷数量の記録
-end note
-:受入検査;
-note right
-・品質検査の実施
-・良品/不良品の判定
-end note
-if (検査結果) then (合格)
-  :検収処理;
-  note right
-  ・検収数量の確定
-  ・仕入計上
-  end note
-  :在庫計上;
-else (不合格)
-  :検収返品;
-  note right
-  ・返品処理
-  ・仕入先への通知
-  end note
-endif
-stop
-@enduml
-```
-### 入荷・検収関連のスキーマ設計
-#### テーブル構造
-| テーブル名 | 説明 |
-|-----------|------|
-| 入荷受入データ | 入荷情報（入荷番号、数量、担当者等） |
-| 欠点マスタ | 不良品の欠点コード・内容 |
-| 受入検査データ | 受入検査情報（良品数、不良品数等） |
-| 検収データ | 検収情報（検収数、検収金額等） |
-#### データの関連
-```plantuml
-@startuml
-title 入荷・検収データの関連
-entity "発注明細データ" as pod {
-  * 発注番号 [PK]
-  * 発注行番号 [PK]
-  --
-  発注数量
-  入荷済数量
-  検収済数量
-}
-entity "入荷受入データ" as rcv {
-  * 入荷番号 [PK]
-  --
-  発注番号 [FK]
-  発注行番号 [FK]
-  入荷日
-  入荷数量
-  入荷受入区分
-}
-entity "受入検査データ" as ins {
-  * 受入検査番号 [PK]
-  --
-  入荷番号 [FK]
-  受入検査日
-  良品数
-  不良品数
-}
-entity "検収データ" as acc {
-  * 検収番号 [PK]
-  --
-  受入検査番号 [FK]
-  発注番号 [FK]
-  発注行番号 [FK]
-  検収日
-  検収数
-  検収金額
-}
-pod ||--o{ rcv : 入荷
-rcv ||--o{ ins : 検査
-ins ||--o{ acc : 検収
-pod ||--o{ acc : 検収
-@enduml
-```
-<details>
-<summary>DDL: 入荷・検収関連テーブル</summary>
-```sql
--- V010__create_receiving_tables.sql
--- 入荷受入データ
-CREATE TABLE "入荷受入データ" (
-    "ID" SERIAL PRIMARY KEY,
-    "入荷番号" VARCHAR(20) UNIQUE NOT NULL,
-    "発注番号" VARCHAR(20) NOT NULL,
-    "発注行番号" INTEGER NOT NULL,
-    "入荷日" DATE NOT NULL,
-    "入荷担当者コード" VARCHAR(20),
-    "入荷受入区分" 入荷受入区分 DEFAULT '通常入荷' NOT NULL,
-    "品目コード" VARCHAR(20) NOT NULL,
-    "諸口品目区分" BOOLEAN DEFAULT FALSE NOT NULL,
-    "入荷数量" DECIMAL(15, 2) NOT NULL,
-    "入荷備考" TEXT,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_入荷受入_発注明細"
-        FOREIGN KEY ("発注番号", "発注行番号") REFERENCES "発注明細データ"("発注番号", "発注行番号"),
-    CONSTRAINT "fk_入荷受入_品目"
-        FOREIGN KEY ("品目コード") REFERENCES "品目マスタ"("品目コード")
-);
--- 欠点マスタ
-CREATE TABLE "欠点マスタ" (
-    "ID" SERIAL PRIMARY KEY,
-    "欠点コード" VARCHAR(20) UNIQUE NOT NULL,
-    "欠点内容" VARCHAR(200) NOT NULL,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50)
-);
--- 受入検査データ
-CREATE TABLE "受入検査データ" (
-    "ID" SERIAL PRIMARY KEY,
-    "受入検査番号" VARCHAR(20) UNIQUE NOT NULL,
-    "入荷番号" VARCHAR(20) NOT NULL,
-    "発注番号" VARCHAR(20) NOT NULL,
-    "発注行番号" INTEGER NOT NULL,
-    "受入検査日" DATE NOT NULL,
-    "受入検査担当者コード" VARCHAR(20),
-    "品目コード" VARCHAR(20) NOT NULL,
-    "諸口品目区分" BOOLEAN DEFAULT FALSE NOT NULL,
-    "良品数" DECIMAL(15, 2) NOT NULL,
-    "不良品数" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "受入検査備考" TEXT,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_受入検査_入荷"
-        FOREIGN KEY ("入荷番号") REFERENCES "入荷受入データ"("入荷番号"),
-    CONSTRAINT "fk_受入検査_品目"
-        FOREIGN KEY ("品目コード") REFERENCES "品目マスタ"("品目コード")
-);
--- 検収データ
-CREATE TABLE "検収データ" (
-    "ID" SERIAL PRIMARY KEY,
-    "検収番号" VARCHAR(20) UNIQUE NOT NULL,
-    "受入検査番号" VARCHAR(20) NOT NULL,
-    "発注番号" VARCHAR(20) NOT NULL,
-    "発注行番号" INTEGER NOT NULL,
-    "検収日" DATE NOT NULL,
-    "検収担当者コード" VARCHAR(20),
-    "取引先コード" VARCHAR(20) NOT NULL,
-    "品目コード" VARCHAR(20) NOT NULL,
-    "諸口品目区分" BOOLEAN DEFAULT FALSE NOT NULL,
-    "検収数" DECIMAL(15, 2) NOT NULL,
-    "検収単価" DECIMAL(15, 2) NOT NULL,
-    "検収金額" DECIMAL(15, 2) NOT NULL,
-    "検収消費税額" DECIMAL(15, 2) DEFAULT 0 NOT NULL,
-    "検収備考" TEXT,
-    "作成日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "作成者" VARCHAR(50),
-    "更新日時" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
-    "更新者" VARCHAR(50),
-    CONSTRAINT "fk_検収_受入検査"
-        FOREIGN KEY ("受入検査番号") REFERENCES "受入検査データ"("受入検査番号"),
-    CONSTRAINT "fk_検収_発注明細"
-        FOREIGN KEY ("発注番号", "発注行番号") REFERENCES "発注明細データ"("発注番号", "発注行番号"),
-    CONSTRAINT "fk_検収_取引先"
-        FOREIGN KEY ("取引先コード") REFERENCES "取引先マスタ"("取引先コード"),
-    CONSTRAINT "fk_検収_品目"
-        FOREIGN KEY ("品目コード") REFERENCES "品目マスタ"("品目コード")
-);
--- インデックス
-CREATE INDEX "idx_入荷受入_発注番号" ON "入荷受入データ"("発注番号", "発注行番号");
-CREATE INDEX "idx_入荷受入_入荷日" ON "入荷受入データ"("入荷日");
-CREATE INDEX "idx_受入検査_入荷番号" ON "受入検査データ"("入荷番号");
-CREATE INDEX "idx_検収_受入検査番号" ON "検収データ"("受入検査番号");
-CREATE INDEX "idx_検収_発注番号" ON "検収データ"("発注番号", "発注行番号");
-```
-</details>
-### 発注明細との紐付け
-入荷受入データは発注明細データと紐付けられ、入荷のたびに発注明細の「入荷済数量」が更新されます。これにより、分納への対応が可能になります。
-### 入荷受入区分（入荷 / 受入返品）
-入荷受入区分は以下の値を取ります。
-| 区分 | 説明 |
-|-----|------|
-| 通常入荷 | 通常の入荷処理 |
-| 分割入荷 | 発注数量を分割して入荷する場合 |
-| 返品入荷 | 検収後の返品を受け入れる場合 |
-### Java エンティティの定義
-<details>
-<summary>入荷受入データエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/Receiving.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.item.Item;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.List;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class Receiving {
-    private Integer id;
-    private String receivingNumber;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private LocalDate receivingDate;
-    private String receiverCode;
-    private ReceivingType receivingType;
-    private String itemCode;
-    private Boolean miscellaneousItemFlag;
-    private BigDecimal receivingQuantity;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private PurchaseOrderDetail purchaseOrderDetail;
-    private Item item;
-    private List<Inspection> inspections;
-}
-```
-</details>
-<details>
-<summary>受入検査データエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/Inspection.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.item.Item;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.List;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class Inspection {
-    private Integer id;
-    private String inspectionNumber;
-    private String receivingNumber;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private LocalDate inspectionDate;
-    private String inspectorCode;
-    private String itemCode;
-    private Boolean miscellaneousItemFlag;
-    private BigDecimal goodQuantity;
-    private BigDecimal defectQuantity;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private Receiving receiving;
-    private Item item;
-    private List<Acceptance> acceptances;
-}
-```
-</details>
-<details>
-<summary>検収データエンティティ</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/Acceptance.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.item.Item;
-import com.example.pms.domain.model.supplier.Supplier;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class Acceptance {
-    private Integer id;
-    private String acceptanceNumber;
-    private String inspectionNumber;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private LocalDate acceptanceDate;
-    private String acceptorCode;
-    private String supplierCode;
-    private String itemCode;
-    private Boolean miscellaneousItemFlag;
-    private BigDecimal acceptedQuantity;
-    private BigDecimal unitPrice;
-    private BigDecimal amount;
-    private BigDecimal taxAmount;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // リレーション
-    private Inspection inspection;
-    private PurchaseOrderDetail purchaseOrderDetail;
-    private Supplier supplier;
-    private Item item;
-}
-```
-</details>
-### MyBatis Mapper XML（入荷・検収）
-<details>
-<summary>ReceivingMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/ReceivingMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.ReceivingMapper">
-    <resultMap id="ReceivingResultMap" type="com.example.pms.domain.model.purchase.Receiving">
-        <id property="id" column="ID"/>
-        <result property="receivingNumber" column="入荷番号"/>
-        <result property="purchaseOrderNumber" column="発注番号"/>
-        <result property="lineNumber" column="発注行番号"/>
-        <result property="receivingDate" column="入荷日"/>
-        <result property="receiverCode" column="入荷担当者コード"/>
-        <result property="receivingType" column="入荷受入区分"
-                typeHandler="com.example.pms.infrastructure.out.persistence.typehandler.ReceivingTypeTypeHandler"/>
-        <result property="itemCode" column="品目コード"/>
-        <result property="miscellaneousItemFlag" column="諸口品目区分"/>
-        <result property="receivingQuantity" column="入荷数量"/>
-        <result property="remarks" column="入荷備考"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <!-- PostgreSQL用 INSERT -->
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.Receiving"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID" databaseId="postgresql">
-        INSERT INTO "入荷受入データ" (
-            "入荷番号", "発注番号", "発注行番号", "入荷日", "入荷担当者コード",
-            "入荷受入区分", "品目コード", "諸口品目区分", "入荷数量", "入荷備考", "作成者", "更新者"
-        ) VALUES (
-            #{receivingNumber},
-            #{purchaseOrderNumber},
-            #{lineNumber},
-            #{receivingDate},
-            #{receiverCode},
-            #{receivingType, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.ReceivingTypeTypeHandler}::入荷受入区分,
-            #{itemCode},
-            #{miscellaneousItemFlag},
-            #{receivingQuantity},
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <!-- H2用 INSERT -->
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.Receiving"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID" databaseId="h2">
-        INSERT INTO "入荷受入データ" (
-            "入荷番号", "発注番号", "発注行番号", "入荷日", "入荷担当者コード",
-            "入荷受入区分", "品目コード", "諸口品目区分", "入荷数量", "入荷備考", "作成者", "更新者"
-        ) VALUES (
-            #{receivingNumber},
-            #{purchaseOrderNumber},
-            #{lineNumber},
-            #{receivingDate},
-            #{receiverCode},
-            #{receivingType, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.ReceivingTypeTypeHandler},
-            #{itemCode},
-            #{miscellaneousItemFlag},
-            #{receivingQuantity},
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <select id="findById" resultMap="ReceivingResultMap">
-        SELECT * FROM "入荷受入データ" WHERE "ID" = #{id}
-    </select>
-    <select id="findByReceivingNumber" resultMap="ReceivingResultMap">
-        SELECT * FROM "入荷受入データ" WHERE "入荷番号" = #{receivingNumber}
-    </select>
-    <select id="findByPurchaseOrderNumber" resultMap="ReceivingResultMap">
-        SELECT * FROM "入荷受入データ" WHERE "発注番号" = #{purchaseOrderNumber} ORDER BY "入荷日" DESC
-    </select>
-    <select id="findByPurchaseOrderNumberAndLineNumber" resultMap="ReceivingResultMap">
-        SELECT * FROM "入荷受入データ"
-        WHERE "発注番号" = #{purchaseOrderNumber} AND "発注行番号" = #{lineNumber}
-        ORDER BY "入荷日" DESC
-    </select>
-    <select id="findAll" resultMap="ReceivingResultMap">
-        SELECT * FROM "入荷受入データ" ORDER BY "入荷日" DESC
-    </select>
-    <!-- PostgreSQL用 DELETE -->
-    <delete id="deleteAll" databaseId="postgresql">
-        TRUNCATE TABLE "入荷受入データ" CASCADE
-    </delete>
-    <!-- H2用 DELETE -->
-    <delete id="deleteAll" databaseId="h2">
-        DELETE FROM "入荷受入データ"
-    </delete>
-</mapper>
-```
-</details>
-<details>
-<summary>InspectionMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/InspectionMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.InspectionMapper">
-    <resultMap id="InspectionResultMap" type="com.example.pms.domain.model.purchase.Inspection">
-        <id property="id" column="ID"/>
-        <result property="inspectionNumber" column="受入検査番号"/>
-        <result property="receivingNumber" column="入荷番号"/>
-        <result property="purchaseOrderNumber" column="発注番号"/>
-        <result property="lineNumber" column="発注行番号"/>
-        <result property="inspectionDate" column="受入検査日"/>
-        <result property="inspectorCode" column="受入検査担当者コード"/>
-        <result property="itemCode" column="品目コード"/>
-        <result property="miscellaneousItemFlag" column="諸口品目区分"/>
-        <result property="goodQuantity" column="良品数"/>
-        <result property="defectQuantity" column="不良品数"/>
-        <result property="remarks" column="受入検査備考"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.Inspection"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
-        INSERT INTO "受入検査データ" (
-            "受入検査番号", "入荷番号", "発注番号", "発注行番号", "受入検査日",
-            "受入検査担当者コード", "品目コード", "諸口品目区分", "良品数", "不良品数",
-            "受入検査備考", "作成者", "更新者"
-        ) VALUES (
-            #{inspectionNumber},
-            #{receivingNumber},
-            #{purchaseOrderNumber},
-            #{lineNumber},
-            #{inspectionDate},
-            #{inspectorCode},
-            #{itemCode},
-            #{miscellaneousItemFlag},
-            #{goodQuantity},
-            #{defectQuantity},
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <select id="findById" resultMap="InspectionResultMap">
-        SELECT * FROM "受入検査データ" WHERE "ID" = #{id}
-    </select>
-    <select id="findByInspectionNumber" resultMap="InspectionResultMap">
-        SELECT * FROM "受入検査データ" WHERE "受入検査番号" = #{inspectionNumber}
-    </select>
-    <select id="findByReceivingNumber" resultMap="InspectionResultMap">
-        SELECT * FROM "受入検査データ" WHERE "入荷番号" = #{receivingNumber} ORDER BY "受入検査日" DESC
-    </select>
-    <select id="findAll" resultMap="InspectionResultMap">
-        SELECT * FROM "受入検査データ" ORDER BY "受入検査日" DESC
-    </select>
-    <!-- PostgreSQL用 DELETE -->
-    <delete id="deleteAll" databaseId="postgresql">
-        TRUNCATE TABLE "受入検査データ" CASCADE
-    </delete>
-    <!-- H2用 DELETE -->
-    <delete id="deleteAll" databaseId="h2">
-        DELETE FROM "受入検査データ"
-    </delete>
-</mapper>
-```
-</details>
-<details>
-<summary>AcceptanceMapper.xml</summary>
-```xml
-<!-- src/main/resources/mapper/AcceptanceMapper.xml -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.AcceptanceMapper">
-    <resultMap id="AcceptanceResultMap" type="com.example.pms.domain.model.purchase.Acceptance">
-        <id property="id" column="ID"/>
-        <result property="acceptanceNumber" column="検収番号"/>
-        <result property="inspectionNumber" column="受入検査番号"/>
-        <result property="purchaseOrderNumber" column="発注番号"/>
-        <result property="lineNumber" column="発注行番号"/>
-        <result property="acceptanceDate" column="検収日"/>
-        <result property="acceptorCode" column="検収担当者コード"/>
-        <result property="supplierCode" column="取引先コード"/>
-        <result property="itemCode" column="品目コード"/>
-        <result property="miscellaneousItemFlag" column="諸口品目区分"/>
-        <result property="acceptedQuantity" column="検収数"/>
-        <result property="unitPrice" column="検収単価"/>
-        <result property="amount" column="検収金額"/>
-        <result property="taxAmount" column="検収消費税額"/>
-        <result property="remarks" column="検収備考"/>
-        <result property="createdAt" column="作成日時"/>
-        <result property="createdBy" column="作成者"/>
-        <result property="updatedAt" column="更新日時"/>
-        <result property="updatedBy" column="更新者"/>
-    </resultMap>
-    <insert id="insert" parameterType="com.example.pms.domain.model.purchase.Acceptance"
-            useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
-        INSERT INTO "検収データ" (
-            "検収番号", "受入検査番号", "発注番号", "発注行番号", "検収日",
-            "検収担当者コード", "取引先コード", "品目コード", "諸口品目区分",
-            "検収数", "検収単価", "検収金額", "検収消費税額", "検収備考", "作成者", "更新者"
-        ) VALUES (
-            #{acceptanceNumber},
-            #{inspectionNumber},
-            #{purchaseOrderNumber},
-            #{lineNumber},
-            #{acceptanceDate},
-            #{acceptorCode},
-            #{supplierCode},
-            #{itemCode},
-            #{miscellaneousItemFlag},
-            #{acceptedQuantity},
-            #{unitPrice},
-            #{amount},
-            #{taxAmount},
-            #{remarks},
-            #{createdBy},
-            #{updatedBy}
-        )
-    </insert>
-    <select id="findById" resultMap="AcceptanceResultMap">
-        SELECT * FROM "検収データ" WHERE "ID" = #{id}
-    </select>
-    <select id="findByAcceptanceNumber" resultMap="AcceptanceResultMap">
-        SELECT * FROM "検収データ" WHERE "検収番号" = #{acceptanceNumber}
-    </select>
-    <select id="findByInspectionNumber" resultMap="AcceptanceResultMap">
-        SELECT * FROM "検収データ" WHERE "受入検査番号" = #{inspectionNumber} ORDER BY "検収日" DESC
-    </select>
-    <select id="findByPurchaseOrderNumber" resultMap="AcceptanceResultMap">
-        SELECT * FROM "検収データ" WHERE "発注番号" = #{purchaseOrderNumber} ORDER BY "検収日" DESC
-    </select>
-    <select id="findAll" resultMap="AcceptanceResultMap">
-        SELECT * FROM "検収データ" ORDER BY "検収日" DESC
-    </select>
-    <!-- PostgreSQL用 DELETE -->
-    <delete id="deleteAll" databaseId="postgresql">
-        TRUNCATE TABLE "検収データ" CASCADE
-    </delete>
-    <!-- H2用 DELETE -->
-    <delete id="deleteAll" databaseId="h2">
-        DELETE FROM "検収データ"
-    </delete>
-</mapper>
-```
-</details>
-### Mapper インターフェース（入荷・検収）
-<details>
-<summary>ReceivingMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/ReceivingMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.Receiving;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import java.util.List;
-@Mapper
-public interface ReceivingMapper {
-    void insert(Receiving receiving);
-    Receiving findByReceivingNumber(String receivingNumber);
-    String findLatestReceivingNumber(String prefix);
-    List<Receiving> findByPurchaseOrderNumber(String purchaseOrderNumber);
-    void deleteAll();
-}
-```
-</details>
-<details>
-<summary>InspectionMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/InspectionMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.Inspection;
-import org.apache.ibatis.annotations.Mapper;
-@Mapper
-public interface InspectionMapper {
-    void insert(Inspection inspection);
-    Inspection findByInspectionNumber(String inspectionNumber);
-    String findLatestInspectionNumber(String prefix);
-    void deleteAll();
-}
-```
-</details>
-<details>
-<summary>AcceptanceMapper</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/out/persistence/mapper/AcceptanceMapper.java
-package com.example.pms.infrastructure.out.persistence.mapper;
-import com.example.pms.domain.model.purchase.Acceptance;
-import org.apache.ibatis.annotations.Mapper;
-import java.util.List;
-@Mapper
-public interface AcceptanceMapper {
-    void insert(Acceptance acceptance);
-    Acceptance findByAcceptanceNumber(String acceptanceNumber);
-    String findLatestAcceptanceNumber(String prefix);
-    List<Acceptance> findByPurchaseOrderNumber(String purchaseOrderNumber);
-    void deleteAll();
-}
-```
-</details>
-### コマンドクラス
-ヘキサゴナルアーキテクチャに従い、入力用 DTO は `application/port/in/command` に配置し、命名は `xxxCommand` とします。
-<details>
-<summary>ReceivingCommand</summary>
-```java
-// src/main/java/com/example/pms/application/port/in/command/ReceivingCommand.java
-package com.example.pms.application.port.in.command;
-import com.example.pms.domain.model.purchase.ReceivingType;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-@Data
-@Builder
-public class ReceivingCommand {
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private LocalDate receivingDate;
-    private String receiverCode;
-    private ReceivingType receivingType;
-    private BigDecimal receivingQuantity;
-    private String remarks;
-}
-```
-</details>
-<details>
-<summary>InspectionCommand</summary>
-```java
-// src/main/java/com/example/pms/application/port/in/command/InspectionCommand.java
-package com.example.pms.application.port.in.command;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-@Data
-@Builder
-public class InspectionCommand {
-    private String receivingNumber;
-    private LocalDate inspectionDate;
-    private String inspectorCode;
-    private BigDecimal goodQuantity;
-    private BigDecimal defectQuantity;
-    private String remarks;
-}
-```
-</details>
-<details>
-<summary>AcceptanceCommand</summary>
-```java
-// src/main/java/com/example/pms/application/port/in/command/AcceptanceCommand.java
-package com.example.pms.application.port.in.command;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-@Data
-@Builder
-public class AcceptanceCommand {
-    private String inspectionNumber;
-    private LocalDate acceptanceDate;
-    private String acceptorCode;
-    private BigDecimal taxRate;
-    private String remarks;
-}
-```
-</details>
-### 入荷検収サービスの実装
-<details>
-<summary>ReceivingService</summary>
-```java
-// src/main/java/com/example/pms/application/service/ReceivingService.java
-package com.example.pms.application.service;
-import com.example.pms.domain.model.purchase.*;
-import com.example.pms.infrastructure.out.persistence.mapper.*;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-@Service
-@RequiredArgsConstructor
-public class ReceivingService {
-    private final ReceivingMapper receivingMapper;
-    private final InspectionMapper inspectionMapper;
-    private final AcceptanceMapper acceptanceMapper;
-    private final PurchaseOrderMapper purchaseOrderMapper;
-    private final PurchaseOrderDetailMapper purchaseOrderDetailMapper;
-    /**
-     * 入荷を登録する
-     */
-    @Transactional
-    public Receiving registerReceiving(ReceivingCommand command) {
-        PurchaseOrderDetail detail = purchaseOrderDetailMapper.findByPurchaseOrderNumberAndLineNumber(
-                command.getPurchaseOrderNumber(), command.getLineNumber());
-        if (detail == null) {
-            throw new IllegalArgumentException(
-                    "Purchase order detail not found: " + command.getPurchaseOrderNumber() + "-" + command.getLineNumber());
-        }
-        BigDecimal receivedQuantity = detail.getReceivedQuantity() != null ?
-                detail.getReceivedQuantity() : BigDecimal.ZERO;
-        BigDecimal remainingQuantity = detail.getOrderQuantity().subtract(receivedQuantity);
-        if (command.getReceivingQuantity().compareTo(remainingQuantity) > 0) {
-            throw new IllegalStateException("Cannot receive more than ordered quantity");
-        }
-        String receivingNumber = generateReceivingNumber(command.getReceivingDate());
-        Receiving receiving = Receiving.builder()
-                .receivingNumber(receivingNumber)
-                .purchaseOrderNumber(command.getPurchaseOrderNumber())
-                .lineNumber(command.getLineNumber())
-                .receivingDate(command.getReceivingDate())
-                .receiverCode(command.getReceiverCode())
-                .receivingType(command.getReceivingType() != null ? command.getReceivingType() : ReceivingType.NORMAL)
-                .itemCode(detail.getItemCode())
-                .miscellaneousItemFlag(detail.getMiscellaneousItemFlag())
-                .receivingQuantity(command.getReceivingQuantity())
-                .remarks(command.getRemarks())
-                .build();
-        receivingMapper.insert(receiving);
-        BigDecimal newReceivedQuantity = receivedQuantity.add(command.getReceivingQuantity());
-        purchaseOrderDetailMapper.updateReceivedQuantity(
-                command.getPurchaseOrderNumber(), command.getLineNumber(), newReceivedQuantity);
-        PurchaseOrderStatus newStatus = newReceivedQuantity.compareTo(detail.getOrderQuantity()) >= 0
-                ? PurchaseOrderStatus.RECEIVED : PurchaseOrderStatus.PARTIALLY_RECEIVED;
-        purchaseOrderMapper.updateStatus(command.getPurchaseOrderNumber(), newStatus);
-        return receiving;
-    }
-    private String generateReceivingNumber(LocalDate date) {
-        String prefix = "RCV-" + date.format(DateTimeFormatter.ofPattern("yyyyMM")) + "-";
-        String latestNumber = receivingMapper.findLatestReceivingNumber(prefix + "%");
-        int sequence = 1;
-        if (latestNumber != null) {
-            int currentSequence = Integer.parseInt(latestNumber.substring(latestNumber.length() - 4));
-            sequence = currentSequence + 1;
-        }
-        return prefix + String.format("%04d", sequence);
-    }
-    /**
-     * 受入検査を登録する
-     */
-    @Transactional
-    public Inspection registerInspection(InspectionCommand command) {
-        Receiving receiving = receivingMapper.findByReceivingNumber(command.getReceivingNumber());
-        if (receiving == null) {
-            throw new IllegalArgumentException("Receiving not found: " + command.getReceivingNumber());
-        }
-        BigDecimal totalQuantity = command.getGoodQuantity().add(command.getDefectQuantity());
-        if (totalQuantity.compareTo(receiving.getReceivingQuantity()) > 0) {
-            throw new IllegalStateException("Inspection quantity exceeds receiving quantity");
-        }
-        String inspectionNumber = generateInspectionNumber(command.getInspectionDate());
-        Inspection inspection = Inspection.builder()
-                .inspectionNumber(inspectionNumber)
-                .receivingNumber(command.getReceivingNumber())
-                .purchaseOrderNumber(receiving.getPurchaseOrderNumber())
-                .lineNumber(receiving.getLineNumber())
-                .inspectionDate(command.getInspectionDate())
-                .inspectorCode(command.getInspectorCode())
-                .itemCode(receiving.getItemCode())
-                .miscellaneousItemFlag(receiving.getMiscellaneousItemFlag())
-                .goodQuantity(command.getGoodQuantity())
-                .defectQuantity(command.getDefectQuantity())
-                .remarks(command.getRemarks())
-                .build();
-        inspectionMapper.insert(inspection);
-        return inspection;
-    }
-    private String generateInspectionNumber(LocalDate date) {
-        String prefix = "INS-" + date.format(DateTimeFormatter.ofPattern("yyyyMM")) + "-";
-        String latestNumber = inspectionMapper.findLatestInspectionNumber(prefix + "%");
-        int sequence = 1;
-        if (latestNumber != null) {
-            int currentSequence = Integer.parseInt(latestNumber.substring(latestNumber.length() - 4));
-            sequence = currentSequence + 1;
-        }
-        return prefix + String.format("%04d", sequence);
-    }
-    /**
-     * 検収処理を行う
-     */
-    @Transactional
-    public Acceptance processAcceptance(AcceptanceCommand command) {
-        Inspection inspection = inspectionMapper.findByInspectionNumber(command.getInspectionNumber());
-        if (inspection == null) {
-            throw new IllegalArgumentException("Inspection not found: " + command.getInspectionNumber());
-        }
-        PurchaseOrderDetail detail = purchaseOrderDetailMapper.findByPurchaseOrderNumberAndLineNumber(
-                inspection.getPurchaseOrderNumber(), inspection.getLineNumber());
-        PurchaseOrder purchaseOrder = purchaseOrderMapper.findByPurchaseOrderNumber(
-                inspection.getPurchaseOrderNumber());
-        BigDecimal taxRate = command.getTaxRate() != null ? command.getTaxRate() : new BigDecimal("10");
-        BigDecimal amount = detail.getOrderUnitPrice().multiply(inspection.getGoodQuantity());
-        BigDecimal taxAmount = amount.multiply(taxRate)
-                .divide(new BigDecimal("100"), 0, RoundingMode.HALF_UP);
-        String acceptanceNumber = generateAcceptanceNumber(command.getAcceptanceDate());
-        Acceptance acceptance = Acceptance.builder()
-                .acceptanceNumber(acceptanceNumber)
-                .inspectionNumber(command.getInspectionNumber())
-                .purchaseOrderNumber(inspection.getPurchaseOrderNumber())
-                .lineNumber(inspection.getLineNumber())
-                .acceptanceDate(command.getAcceptanceDate())
-                .acceptorCode(command.getAcceptorCode())
-                .supplierCode(purchaseOrder.getSupplierCode())
-                .itemCode(inspection.getItemCode())
-                .miscellaneousItemFlag(inspection.getMiscellaneousItemFlag())
-                .acceptedQuantity(inspection.getGoodQuantity())
-                .unitPrice(detail.getOrderUnitPrice())
-                .amount(amount)
-                .taxAmount(taxAmount)
-                .remarks(command.getRemarks())
-                .build();
-        acceptanceMapper.insert(acceptance);
-        return acceptance;
-    }
-    private String generateAcceptanceNumber(LocalDate date) {
-        String prefix = "ACC-" + date.format(DateTimeFormatter.ofPattern("yyyyMM")) + "-";
-        String latestNumber = acceptanceMapper.findLatestAcceptanceNumber(prefix + "%");
-        int sequence = 1;
-        if (latestNumber != null) {
-            int currentSequence = Integer.parseInt(latestNumber.substring(latestNumber.length() - 4));
-            sequence = currentSequence + 1;
-        }
-        return prefix + String.format("%04d", sequence);
-    }
-}
-```
-</details>
-### 在庫計上処理
-検収処理が完了すると、良品数が在庫に計上されます。在庫計上処理の詳細は第28章で解説します。
-### TDD: 入荷・検収のテスト
-<details>
-<summary>ReceivingServiceTest</summary>
-```java
-// src/test/java/com/example/pms/application/service/ReceivingServiceTest.java
-package com.example.pms.application.service;
-import com.example.pms.domain.model.item.Item;
-import com.example.pms.domain.model.item.ItemCategory;
-import com.example.pms.domain.model.master.Supplier;
-import com.example.pms.domain.model.purchase.*;
-import com.example.pms.infrastructure.out.persistence.mapper.*;
-import org.junit.jupiter.api.*;
-import org.mybatis.spring.boot.test.autoconfigure.MybatisTest;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
-import org.springframework.context.annotation.Import;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.PostgreSQLContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.util.List;
-import static org.assertj.core.api.Assertions.*;
-@MybatisTest
-@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-@Import({ReceivingService.class, PurchaseOrderService.class})
-@Testcontainers
-@DisplayName("入荷・検収業務")
-class ReceivingServiceTest {
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
-            .withDatabaseName("testdb")
-            .withUsername("testuser")
-            .withPassword("testpass");
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-    }
-    @Autowired
-    private ReceivingService receivingService;
-    @Autowired
-    private PurchaseOrderService purchaseOrderService;
-    @Autowired
-    private ItemMapper itemMapper;
-    @Autowired
-    private SupplierMapper supplierMapper;
-    @Autowired
-    private UnitPriceMapper unitPriceMapper;
-    @Autowired
-    private AcceptanceMapper acceptanceMapper;
-    @Autowired
-    private InspectionMapper inspectionMapper;
-    @Autowired
-    private ReceivingMapper receivingMapper;
-    @Autowired
-    private PurchaseOrderDetailMapper purchaseOrderDetailMapper;
-    @Autowired
-    private PurchaseOrderMapper purchaseOrderMapper;
-    private PurchaseOrder testPurchaseOrder;
-    @BeforeEach
-    void setUp() {
-        // テストデータのクリーンアップ
-        acceptanceMapper.deleteAll();
-        inspectionMapper.deleteAll();
-        receivingMapper.deleteAll();
-        purchaseOrderDetailMapper.deleteAll();
-        purchaseOrderMapper.deleteAll();
-        unitPriceMapper.deleteAll();
-        supplierMapper.deleteAll();
-        itemMapper.deleteAll();
-        // マスタデータの準備
-        Supplier supplier = Supplier.builder()
-                .supplierCode("SUP-RCV-001")
-                .effectiveFrom(LocalDate.of(2025, 1, 1))
-                .supplierName("入荷テスト用仕入先")
-                .build();
-        supplierMapper.insert(supplier);
-        Item item = Item.builder()
-                .itemCode("MAT-RCV-001")
-                .effectiveFrom(LocalDate.of(2025, 1, 1))
-                .itemName("入荷テスト用材料")
-                .itemCategory(ItemCategory.MATERIAL)
-                .build();
-        itemMapper.insert(item);
-        unitPriceMapper.insert(UnitPrice.builder()
-                .itemCode("MAT-RCV-001")
-                .supplierCode("SUP-RCV-001")
-                .effectiveFrom(LocalDate.of(2025, 1, 1))
-                .unitPrice(new BigDecimal("1000"))
-                .build());
-        // テスト用発注を作成
-        PurchaseOrderCreateInput poInput = PurchaseOrderCreateInput.builder()
-                .supplierCode("SUP-RCV-001")
-                .orderDate(LocalDate.of(2025, 1, 15))
-                .details(List.of(
-                        PurchaseOrderDetailInput.builder()
-                                .itemCode("MAT-RCV-001")
-                                .orderQuantity(new BigDecimal("100"))
-                                .expectedReceivingDate(LocalDate.of(2025, 1, 25))
-                                .build()
-                ))
-                .build();
-        testPurchaseOrder = purchaseOrderService.createPurchaseOrder(poInput);
-        purchaseOrderService.confirmPurchaseOrder(testPurchaseOrder.getPurchaseOrderNumber());
-    }
-    @Nested
-    @DisplayName("入荷登録")
-    class ReceivingRegistration {
-        @Test
-        @DisplayName("発注に対して入荷を登録できる")
-        void canRegisterReceiving() {
-            // Act
-            ReceivingCommand command = ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 25))
-                    .receivingQuantity(new BigDecimal("50"))
-                    .build();
-            Receiving receiving = receivingService.registerReceiving(command);
-            // Assert
-            assertThat(receiving).isNotNull();
-            assertThat(receiving.getReceivingNumber()).startsWith("RCV-");
-            assertThat(receiving.getReceivingQuantity()).isEqualByComparingTo(new BigDecimal("50"));
-            assertThat(receiving.getReceivingType()).isEqualTo(ReceivingType.NORMAL);
-        }
-        @Test
-        @DisplayName("分割入荷を登録できる")
-        void canRegisterSplitReceiving() {
-            // Arrange: 1回目の入荷
-            receivingService.registerReceiving(ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 25))
-                    .receivingQuantity(new BigDecimal("30"))
-                    .receivingType(ReceivingType.SPLIT)
-                    .build());
-            // Act: 2回目の入荷
-            Receiving secondReceiving = receivingService.registerReceiving(ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 28))
-                    .receivingQuantity(new BigDecimal("70"))
-                    .receivingType(ReceivingType.SPLIT)
-                    .build());
-            // Assert
-            assertThat(secondReceiving).isNotNull();
-            assertThat(secondReceiving.getReceivingType()).isEqualTo(ReceivingType.SPLIT);
-        }
-        @Test
-        @DisplayName("発注数量を超える入荷はエラーになる")
-        void cannotReceiveMoreThanOrdered() {
-            // Act & Assert
-            ReceivingCommand command = ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 25))
-                    .receivingQuantity(new BigDecimal("150"))
-                    .build();
-            assertThatThrownBy(() -> receivingService.registerReceiving(command))
-                    .isInstanceOf(IllegalStateException.class)
-                    .hasMessageContaining("Cannot receive more than ordered quantity");
-        }
-    }
-    @Nested
-    @DisplayName("受入検査")
-    class InspectionRegistration {
-        @Test
-        @DisplayName("入荷に対して受入検査を登録できる")
-        void canRegisterInspection() {
-            // Arrange
-            Receiving receiving = receivingService.registerReceiving(ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 25))
-                    .receivingQuantity(new BigDecimal("100"))
-                    .build());
-            // Act
-            InspectionCommand command = InspectionCommand.builder()
-                    .receivingNumber(receiving.getReceivingNumber())
-                    .inspectionDate(LocalDate.of(2025, 1, 26))
-                    .goodQuantity(new BigDecimal("95"))
-                    .defectQuantity(new BigDecimal("5"))
-                    .build();
-            Inspection inspection = receivingService.registerInspection(command);
-            // Assert
-            assertThat(inspection).isNotNull();
-            assertThat(inspection.getInspectionNumber()).startsWith("INS-");
-            assertThat(inspection.getGoodQuantity()).isEqualByComparingTo(new BigDecimal("95"));
-            assertThat(inspection.getDefectQuantity()).isEqualByComparingTo(new BigDecimal("5"));
-        }
-    }
-    @Nested
-    @DisplayName("検収処理")
-    class AcceptanceProcessing {
-        @Test
-        @DisplayName("検査合格品を検収できる")
-        void canProcessAcceptance() {
-            // Arrange
-            Receiving receiving = receivingService.registerReceiving(ReceivingCommand.builder()
-                    .purchaseOrderNumber(testPurchaseOrder.getPurchaseOrderNumber())
-                    .lineNumber(1)
-                    .receivingDate(LocalDate.of(2025, 1, 25))
-                    .receivingQuantity(new BigDecimal("100"))
-                    .build());
-            Inspection inspection = receivingService.registerInspection(InspectionCommand.builder()
-                    .receivingNumber(receiving.getReceivingNumber())
-                    .inspectionDate(LocalDate.of(2025, 1, 26))
-                    .goodQuantity(new BigDecimal("100"))
-                    .defectQuantity(BigDecimal.ZERO)
-                    .build());
-            // Act
-            AcceptanceCommand command = AcceptanceCommand.builder()
-                    .inspectionNumber(inspection.getInspectionNumber())
-                    .acceptanceDate(LocalDate.of(2025, 1, 27))
-                    .taxRate(new BigDecimal("10"))
-                    .build();
-            Acceptance acceptance = receivingService.processAcceptance(command);
-            // Assert
-            assertThat(acceptance).isNotNull();
-            assertThat(acceptance.getAcceptanceNumber()).startsWith("ACC-");
-            assertThat(acceptance.getAcceptedQuantity()).isEqualByComparingTo(new BigDecimal("100"));
-            // 100個 × 1000円 = 100,000円
-            assertThat(acceptance.getAmount()).isEqualByComparingTo(new BigDecimal("100000"));
-            // 消費税 10% = 10,000円
-            assertThat(acceptance.getTaxAmount()).isEqualByComparingTo(new BigDecimal("10000"));
-        }
-    }
-}
-```
-</details>
----
-## 25.3 リレーションと楽観ロックの設計
-### MyBatis ネストした ResultMap によるリレーション設定
-購買管理データは、発注→発注明細、入荷→発注明細、検収→入荷 という複数のリレーションを持ちます。MyBatis でこれらの関係を効率的に取得するための設定を実装します。
-#### ネストした ResultMap の定義
-<details>
-<summary>PurchaseOrderMapper.xml（リレーション設定）</summary>
-```xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<!-- src/main/resources/mapper/PurchaseOrderMapper.xml -->
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.PurchaseOrderMapper">
-    <!-- 発注データ ResultMap（明細込み） -->
-    <resultMap id="purchaseOrderWithDetailsResultMap" type="com.example.pms.domain.model.purchase.PurchaseOrder">
-        <id property="id" column="po_ID"/>
-        <result property="purchaseOrderNumber" column="po_発注番号"/>
-        <result property="orderDate" column="po_発注日"/>
-        <result property="supplierCode" column="po_取引先コード"/>
-        <result property="purchaserCode" column="po_発注担当者コード"/>
-        <result property="departmentCode" column="po_発注部門コード"/>
-        <result property="status" column="po_ステータス"
-                typeHandler="com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler"/>
-        <result property="remarks" column="po_備考"/>
-        <result property="version" column="po_バージョン"/>
-        <result property="createdAt" column="po_作成日時"/>
-        <result property="createdBy" column="po_作成者"/>
-        <result property="updatedAt" column="po_更新日時"/>
-        <result property="updatedBy" column="po_更新者"/>
-        <!-- 取引先マスタとの N:1 関連 -->
-        <association property="supplier" javaType="com.example.pms.domain.model.master.Supplier">
-            <id property="supplierCode" column="s_取引先コード"/>
-            <result property="supplierName" column="s_取引先名"/>
-            <result property="supplierType" column="s_取引先区分"/>
-        </association>
-        <!-- 発注明細との 1:N 関連 -->
-        <collection property="details" ofType="com.example.pms.domain.model.purchase.PurchaseOrderDetail"
-                    resultMap="purchaseOrderDetailNestedResultMap"/>
-    </resultMap>
-    <!-- 発注明細のネスト ResultMap -->
-    <resultMap id="purchaseOrderDetailNestedResultMap" type="com.example.pms.domain.model.purchase.PurchaseOrderDetail">
-        <id property="id" column="pod_ID"/>
-        <result property="purchaseOrderNumber" column="pod_発注番号"/>
-        <result property="lineNumber" column="pod_発注行番号"/>
-        <result property="orderNumber" column="pod_オーダNO"/>
-        <result property="deliveryLocationCode" column="pod_納入場所コード"/>
-        <result property="itemCode" column="pod_品目コード"/>
-        <result property="isMiscellaneous" column="pod_諸口品目区分"/>
-        <result property="expectedReceiveDate" column="pod_受入予定日"/>
-        <result property="confirmedDeliveryDate" column="pod_回答納期"/>
-        <result property="unitPrice" column="pod_発注単価"/>
-        <result property="orderQuantity" column="pod_発注数量"/>
-        <result property="receivedQuantity" column="pod_入荷済数量"/>
-        <result property="inspectedQuantity" column="pod_検査済数量"/>
-        <result property="acceptedQuantity" column="pod_検収済数量"/>
-        <result property="amount" column="pod_発注金額"/>
-        <result property="taxAmount" column="pod_消費税金額"/>
-        <result property="isCompleted" column="pod_完了フラグ"/>
-        <result property="lineRemarks" column="pod_明細備考"/>
-        <result property="version" column="pod_バージョン"/>
-        <!-- 品目マスタとの N:1 関連 -->
-        <association property="item" javaType="com.example.pms.domain.model.item.Item">
-            <id property="itemCode" column="i_品目コード"/>
-            <result property="itemName" column="i_品名"/>
-            <result property="itemCategory" column="i_品目区分"/>
-            <result property="unit" column="i_単位"/>
-        </association>
-    </resultMap>
-    <!-- JOIN による一括取得クエリ -->
-    <select id="findWithDetailsByPurchaseOrderNumber" resultMap="purchaseOrderWithDetailsResultMap">
-        SELECT
-            -- 発注データ
-            po."ID" AS po_ID,
-            po."発注番号" AS po_発注番号,
-            po."発注日" AS po_発注日,
-            po."取引先コード" AS po_取引先コード,
-            po."発注担当者コード" AS po_発注担当者コード,
-            po."発注部門コード" AS po_発注部門コード,
-            po."ステータス" AS po_ステータス,
-            po."備考" AS po_備考,
-            po."バージョン" AS po_バージョン,
-            po."作成日時" AS po_作成日時,
-            po."作成者" AS po_作成者,
-            po."更新日時" AS po_更新日時,
-            po."更新者" AS po_更新者,
-            -- 取引先マスタ
-            s."取引先コード" AS s_取引先コード,
-            s."取引先名" AS s_取引先名,
-            s."取引先区分" AS s_取引先区分,
-            -- 発注明細データ
-            pod."ID" AS pod_ID,
-            pod."発注番号" AS pod_発注番号,
-            pod."発注行番号" AS pod_発注行番号,
-            pod."オーダNO" AS pod_オーダNO,
-            pod."納入場所コード" AS pod_納入場所コード,
-            pod."品目コード" AS pod_品目コード,
-            pod."諸口品目区分" AS pod_諸口品目区分,
-            pod."受入予定日" AS pod_受入予定日,
-            pod."回答納期" AS pod_回答納期,
-            pod."発注単価" AS pod_発注単価,
-            pod."発注数量" AS pod_発注数量,
-            pod."入荷済数量" AS pod_入荷済数量,
-            pod."検査済数量" AS pod_検査済数量,
-            pod."検収済数量" AS pod_検収済数量,
-            pod."発注金額" AS pod_発注金額,
-            pod."消費税金額" AS pod_消費税金額,
-            pod."完了フラグ" AS pod_完了フラグ,
-            pod."明細備考" AS pod_明細備考,
-            pod."バージョン" AS pod_バージョン,
-            -- 品目マスタ
-            i."品目コード" AS i_品目コード,
-            i."品名" AS i_品名,
-            i."品目区分" AS i_品目区分,
-            i."単位" AS i_単位
-        FROM "発注データ" po
-        LEFT JOIN "取引先マスタ" s ON po."取引先コード" = s."取引先コード"
-        LEFT JOIN "発注明細データ" pod ON po."発注番号" = pod."発注番号"
-        LEFT JOIN "品目マスタ" i ON pod."品目コード" = i."品目コード"
-            AND i."適用開始日" = (
-                SELECT MAX("適用開始日") FROM "品目マスタ"
-                WHERE "品目コード" = pod."品目コード"
-                AND "適用開始日" <= CURRENT_DATE
-            )
-        WHERE po."発注番号" = #{purchaseOrderNumber}
-        ORDER BY pod."発注行番号"
-    </select>
-</mapper>
-```
-</details>
-<details>
-<summary>ReceivingMapper.xml（リレーション設定）</summary>
-```xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<!-- src/main/resources/mapper/ReceivingMapper.xml -->
-<mapper namespace="com.example.pms.infrastructure.out.persistence.mapper.ReceivingMapper">
-    <!-- 入荷受入データ ResultMap（発注明細・検査・検収込み） -->
-    <resultMap id="receivingWithRelationsResultMap" type="com.example.pms.domain.model.purchase.Receiving">
-        <id property="id" column="r_ID"/>
-        <result property="receivingNumber" column="r_入荷受入番号"/>
-        <result property="purchaseOrderNumber" column="r_発注番号"/>
-        <result property="lineNumber" column="r_発注行番号"/>
-        <result property="receivingDate" column="r_入荷日"/>
-        <result property="receivingType" column="r_入荷受入区分"
-                typeHandler="com.example.pms.infrastructure.out.persistence.typehandler.ReceivingTypeTypeHandler"/>
-        <result property="receivedQuantity" column="r_入荷数量"/>
-        <result property="locationCode" column="r_入荷場所コード"/>
-        <result property="remarks" column="r_備考"/>
-        <result property="version" column="r_バージョン"/>
-        <result property="createdAt" column="r_作成日時"/>
-        <result property="updatedAt" column="r_更新日時"/>
-        <!-- 発注明細との N:1 関連 -->
-        <association property="purchaseOrderDetail" javaType="com.example.pms.domain.model.purchase.PurchaseOrderDetail">
-            <id property="id" column="pod_ID"/>
-            <result property="purchaseOrderNumber" column="pod_発注番号"/>
-            <result property="lineNumber" column="pod_発注行番号"/>
-            <result property="itemCode" column="pod_品目コード"/>
-            <result property="orderQuantity" column="pod_発注数量"/>
-            <result property="unitPrice" column="pod_発注単価"/>
-        </association>
-        <!-- 検査データとの 1:1 関連 -->
-        <association property="inspection" javaType="com.example.pms.domain.model.purchase.Inspection">
-            <id property="id" column="ins_ID"/>
-            <result property="inspectionNumber" column="ins_検査番号"/>
-            <result property="inspectionDate" column="ins_検査日"/>
-            <result property="inspectedQuantity" column="ins_検査数量"/>
-            <result property="goodQuantity" column="ins_良品数量"/>
-            <result property="defectQuantity" column="ins_不良数量"/>
-        </association>
-        <!-- 検収データとの 1:1 関連 -->
-        <association property="acceptance" javaType="com.example.pms.domain.model.purchase.Acceptance">
-            <id property="id" column="acc_ID"/>
-            <result property="acceptanceNumber" column="acc_検収番号"/>
-            <result property="acceptanceDate" column="acc_検収日"/>
-            <result property="acceptedQuantity" column="acc_検収数量"/>
-            <result property="amount" column="acc_検収金額"/>
-            <result property="taxAmount" column="acc_消費税額"/>
-        </association>
-    </resultMap>
-    <!-- JOIN による一括取得クエリ -->
-    <select id="findWithRelationsByReceivingNumber" resultMap="receivingWithRelationsResultMap">
-        SELECT
-            -- 入荷受入データ
-            r."ID" AS r_ID,
-            r."入荷受入番号" AS r_入荷受入番号,
-            r."発注番号" AS r_発注番号,
-            r."発注行番号" AS r_発注行番号,
-            r."入荷日" AS r_入荷日,
-            r."入荷受入区分" AS r_入荷受入区分,
-            r."入荷数量" AS r_入荷数量,
-            r."入荷場所コード" AS r_入荷場所コード,
-            r."備考" AS r_備考,
-            r."バージョン" AS r_バージョン,
-            r."作成日時" AS r_作成日時,
-            r."更新日時" AS r_更新日時,
-            -- 発注明細データ
-            pod."ID" AS pod_ID,
-            pod."発注番号" AS pod_発注番号,
-            pod."発注行番号" AS pod_発注行番号,
-            pod."品目コード" AS pod_品目コード,
-            pod."発注数量" AS pod_発注数量,
-            pod."発注単価" AS pod_発注単価,
-            -- 受入検査データ
-            ins."ID" AS ins_ID,
-            ins."検査番号" AS ins_検査番号,
-            ins."検査日" AS ins_検査日,
-            ins."検査数量" AS ins_検査数量,
-            ins."良品数量" AS ins_良品数量,
-            ins."不良数量" AS ins_不良数量,
-            -- 検収データ
-            acc."ID" AS acc_ID,
-            acc."検収番号" AS acc_検収番号,
-            acc."検収日" AS acc_検収日,
-            acc."検収数量" AS acc_検収数量,
-            acc."検収金額" AS acc_検収金額,
-            acc."消費税額" AS acc_消費税額
-        FROM "入荷受入データ" r
-        LEFT JOIN "発注明細データ" pod
-            ON r."発注番号" = pod."発注番号" AND r."発注行番号" = pod."発注行番号"
-        LEFT JOIN "受入検査データ" ins ON r."入荷受入番号" = ins."入荷受入番号"
-        LEFT JOIN "検収データ" acc ON r."入荷受入番号" = acc."入荷受入番号"
-        WHERE r."入荷受入番号" = #{receivingNumber}
-    </select>
-</mapper>
-```
-</details>
-#### リレーション設定のポイント
-| 設定項目 | 説明 |
-|---------|------|
-| `<collection>` | 発注→発注明細 の 1:N 関連 |
-| `<association>` | 入荷→発注明細、入荷→検査、入荷→検収 の N:1/1:1 関連 |
-| エイリアス | `po_`（発注）、`pod_`（発注明細）、`r_`（入荷）、`ins_`（検査）、`acc_`（検収） |
-| 有効日サブクエリ | 品目マスタの適用開始日を考慮した最新レコード取得 |
-### 楽観ロックの実装
-発注から検収までの一連の業務で複数ユーザーが同時に操作する可能性があるため、楽観ロックを実装します。
-#### Flyway マイグレーション: バージョンカラム追加
-<details>
-<summary>V010__add_purchasing_version_columns.sql</summary>
-```sql
--- src/main/resources/db/migration/V010__add_purchasing_version_columns.sql
--- 発注データテーブルにバージョンカラムを追加
-ALTER TABLE "発注データ" ADD COLUMN "バージョン" INTEGER DEFAULT 1 NOT NULL;
--- 発注明細データテーブルにバージョンカラムを追加
-ALTER TABLE "発注明細データ" ADD COLUMN "バージョン" INTEGER DEFAULT 1 NOT NULL;
--- 入荷受入データテーブルにバージョンカラムを追加
-ALTER TABLE "入荷受入データ" ADD COLUMN "バージョン" INTEGER DEFAULT 1 NOT NULL;
--- 受入検査データテーブルにバージョンカラムを追加
-ALTER TABLE "受入検査データ" ADD COLUMN "バージョン" INTEGER DEFAULT 1 NOT NULL;
--- 検収データテーブルにバージョンカラムを追加
-ALTER TABLE "検収データ" ADD COLUMN "バージョン" INTEGER DEFAULT 1 NOT NULL;
--- コメント追加
-COMMENT ON COLUMN "発注データ"."バージョン" IS '楽観ロック用バージョン番号';
-COMMENT ON COLUMN "発注明細データ"."バージョン" IS '楽観ロック用バージョン番号';
-COMMENT ON COLUMN "入荷受入データ"."バージョン" IS '楽観ロック用バージョン番号';
-COMMENT ON COLUMN "受入検査データ"."バージョン" IS '楽観ロック用バージョン番号';
-COMMENT ON COLUMN "検収データ"."バージョン" IS '楽観ロック用バージョン番号';
-```
-</details>
-#### エンティティへのバージョンフィールド追加
-<details>
-<summary>PurchaseOrder.java（バージョンフィールド追加）</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/PurchaseOrder.java
-package com.example.pms.domain.model.purchase;
-import com.example.pms.domain.model.master.Supplier;
-import lombok.Builder;
-import lombok.Data;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-@Data
-@Builder
-public class PurchaseOrder {
-    private Integer id;
-    private String purchaseOrderNumber;
-    private LocalDate orderDate;
-    private String supplierCode;
-    private String purchaserCode;
-    private String departmentCode;
-    private PurchaseOrderStatus status;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private String createdBy;
-    private LocalDateTime updatedAt;
-    private String updatedBy;
-    // 楽観ロック用バージョン
-    @Builder.Default
-    private Integer version = 1;
-    // リレーション
-    private Supplier supplier;
-    @Builder.Default
-    private List<PurchaseOrderDetail> details = new ArrayList<>();
-}
-```
-</details>
-<details>
-<summary>Receiving.java（バージョンフィールド追加）</summary>
-```java
-// src/main/java/com/example/pms/domain/model/purchase/Receiving.java
-package com.example.pms.domain.model.purchase;
-import lombok.Builder;
-import lombok.Data;
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-@Data
-@Builder
-public class Receiving {
-    private Integer id;
-    private String receivingNumber;
-    private String purchaseOrderNumber;
-    private Integer lineNumber;
-    private LocalDate receivingDate;
-    private ReceivingType receivingType;
-    private BigDecimal receivedQuantity;
-    private String locationCode;
-    private String remarks;
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-    // 楽観ロック用バージョン
-    @Builder.Default
-    private Integer version = 1;
-    // リレーション
-    private PurchaseOrderDetail purchaseOrderDetail;
-    private Inspection inspection;
-    private Acceptance acceptance;
-}
-```
-</details>
-#### MyBatis Mapper: 楽観ロック対応の更新
-<details>
-<summary>PurchaseOrderMapper.xml（楽観ロック対応 UPDATE）</summary>
-```xml
-<!-- 楽観ロック対応の更新（バージョンチェック付き） -->
-<update id="updateWithOptimisticLock" parameterType="com.example.pms.domain.model.purchase.PurchaseOrder">
-    UPDATE "発注データ"
-    SET
-        "発注日" = #{orderDate},
-        "取引先コード" = #{supplierCode},
-        "発注担当者コード" = #{purchaserCode},
-        "発注部門コード" = #{departmentCode},
-        "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler}::発注ステータス,
-        "備考" = #{remarks},
-        "更新日時" = CURRENT_TIMESTAMP,
-        "更新者" = #{updatedBy},
-        "バージョン" = "バージョン" + 1
-    WHERE "ID" = #{id}
-    AND "バージョン" = #{version}
-</update>
-<!-- ステータス更新（楽観ロック対応） -->
-<update id="updateStatusWithOptimisticLock">
-    UPDATE "発注データ"
-    SET
-        "ステータス" = #{status, typeHandler=com.example.pms.infrastructure.out.persistence.typehandler.PurchaseOrderStatusTypeHandler}::発注ステータス,
-        "更新日時" = CURRENT_TIMESTAMP,
-        "バージョン" = "バージョン" + 1
-    WHERE "ID" = #{id}
-    AND "バージョン" = #{version}
-</update>
-<!-- 現在のバージョン取得 -->
-<select id="findVersionById" resultType="java.lang.Integer">
-    SELECT "バージョン" FROM "発注データ" WHERE "ID" = #{id}
-</select>
-```
-</details>
-<details>
-<summary>PurchaseOrderDetailMapper.xml（楽観ロック対応 UPDATE）</summary>
-```xml
-<!-- 入荷数量更新（楽観ロック対応） -->
-<update id="updateReceivedQuantityWithOptimisticLock">
-    UPDATE "発注明細データ"
-    SET
-        "入荷済数量" = "入荷済数量" + #{additionalQuantity},
-        "更新日時" = CURRENT_TIMESTAMP,
-        "バージョン" = "バージョン" + 1
-    WHERE "ID" = #{id}
-    AND "バージョン" = #{version}
-</update>
-<!-- 検収数量更新（楽観ロック対応） -->
-<update id="updateAcceptedQuantityWithOptimisticLock">
-    UPDATE "発注明細データ"
-    SET
-        "検収済数量" = "検収済数量" + #{additionalQuantity},
-        "完了フラグ" = CASE
-            WHEN "検収済数量" + #{additionalQuantity} >= "発注数量" THEN TRUE
-            ELSE FALSE
-        END,
-        "更新日時" = CURRENT_TIMESTAMP,
-        "バージョン" = "バージョン" + 1
-    WHERE "ID" = #{id}
-    AND "バージョン" = #{version}
-</update>
-<!-- 現在のバージョン取得 -->
-<select id="findVersionById" resultType="java.lang.Integer">
-    SELECT "バージョン" FROM "発注明細データ" WHERE "ID" = #{id}
-</select>
-```
-</details>
-#### Repository 実装: 楽観ロック対応
-<details>
-<summary>PurchaseOrderRepositoryImpl.java（楽観ロック対応）</summary>
-```java
-// src/main/java/com/example/pms/infrastructure/persistence/repository/PurchaseOrderRepositoryImpl.java
-package com.example.pms.infrastructure.out.persistence.typehandler.repository;
-import com.example.pms.application.port.out.PurchaseOrderRepository;
-import com.example.pms.domain.exception.OptimisticLockException;
-import com.example.pms.domain.model.purchase.PurchaseOrder;
-import com.example.pms.domain.model.purchase.PurchaseOrderStatus;
-import com.example.pms.infrastructure.out.persistence.mapper.PurchaseOrderMapper;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-import java.util.Optional;
-@Repository
-@RequiredArgsConstructor
-public class PurchaseOrderRepositoryImpl implements PurchaseOrderRepository {
-    private final PurchaseOrderMapper mapper;
-    @Override
-    @Transactional
-    public void update(PurchaseOrder purchaseOrder) {
-        int updatedCount = mapper.updateWithOptimisticLock(purchaseOrder);
-        if (updatedCount == 0) {
-            Integer currentVersion = mapper.findVersionById(purchaseOrder.getId());
-            if (currentVersion == null) {
-                throw new OptimisticLockException("発注", purchaseOrder.getId());
-            } else {
-                throw new OptimisticLockException("発注", purchaseOrder.getId(),
-                        purchaseOrder.getVersion(), currentVersion);
-            }
-        }
-    }
-    @Override
-    @Transactional
-    public void updateStatus(Integer id, PurchaseOrderStatus status, Integer version) {
-        int updatedCount = mapper.updateStatusWithOptimisticLock(id, status, version);
-        if (updatedCount == 0) {
-            Integer currentVersion = mapper.findVersionById(id);
-            if (currentVersion == null) {
-                throw new OptimisticLockException("発注", id);
-            } else {
-                throw new OptimisticLockException("発注", id, version, currentVersion);
-            }
-        }
-    }
-    @Override
-    public Optional<PurchaseOrder> findWithDetailsByPurchaseOrderNumber(String purchaseOrderNumber) {
-        return Optional.ofNullable(mapper.findWithDetailsByPurchaseOrderNumber(purchaseOrderNumber));
-    }
-    // その他のメソッド...
-}
-```
-</details>
-#### TDD: 楽観ロックのテスト
-<details>
-<summary>PurchaseOrderRepositoryOptimisticLockTest.java</summary>
-```java
-// src/test/java/com/example/pms/infrastructure/persistence/repository/PurchaseOrderRepositoryOptimisticLockTest.java
-package com.example.pms.infrastructure.out.persistence.typehandler.repository;
-import com.example.pms.application.port.out.PurchaseOrderRepository;
-import com.example.pms.domain.exception.OptimisticLockException;
-import com.example.pms.domain.model.purchase.PurchaseOrder;
-import com.example.pms.domain.model.purchase.PurchaseOrderStatus;
-import com.example.pms.testsetup.BaseIntegrationTest;
-import org.junit.jupiter.api.*;
-import org.springframework.beans.factory.annotation.Autowired;
-import java.time.LocalDate;
-import static org.assertj.core.api.Assertions.*;
-@DisplayName("発注リポジトリ - 楽観ロック")
-class PurchaseOrderRepositoryOptimisticLockTest extends BaseIntegrationTest {
-    @Autowired
-    private PurchaseOrderRepository purchaseOrderRepository;
-    @BeforeEach
-    void setUp() {
-        purchaseOrderRepository.deleteAll();
-    }
-    @Nested
-    @DisplayName("楽観ロック")
-    class OptimisticLocking {
-        @Test
-        @DisplayName("同じバージョンで更新できる")
-        void canUpdateWithSameVersion() {
-            // Arrange
-            var po = PurchaseOrder.builder()
-                    .purchaseOrderNumber("PO-2025-0001")
-                    .orderDate(LocalDate.of(2025, 1, 20))
-                    .supplierCode("SUP-001")
-                    .status(PurchaseOrderStatus.CREATING)
-                    .build();
-            purchaseOrderRepository.save(po);
-            // Act
-            var fetched = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0001").get();
-            fetched.setRemarks("更新テスト");
-            purchaseOrderRepository.update(fetched);
-            // Assert
-            var updated = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0001").get();
-            assertThat(updated.getRemarks()).isEqualTo("更新テスト");
-            assertThat(updated.getVersion()).isEqualTo(2);
-        }
-        @Test
-        @DisplayName("異なるバージョンで更新すると楽観ロック例外が発生する")
-        void throwsExceptionWhenVersionMismatch() {
-            // Arrange
-            var po = PurchaseOrder.builder()
-                    .purchaseOrderNumber("PO-2025-0002")
-                    .orderDate(LocalDate.of(2025, 1, 20))
-                    .supplierCode("SUP-001")
-                    .status(PurchaseOrderStatus.CREATING)
-                    .build();
-            purchaseOrderRepository.save(po);
-            // ユーザーAが取得
-            var poA = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0002").get();
-            // ユーザーBが取得
-            var poB = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0002").get();
-            // ユーザーAが更新（成功）
-            poA.setRemarks("ユーザーAの更新");
-            purchaseOrderRepository.update(poA);
-            // Act & Assert: ユーザーBが古いバージョンで更新（失敗）
-            poB.setRemarks("ユーザーBの更新");
-            assertThatThrownBy(() -> purchaseOrderRepository.update(poB))
-                    .isInstanceOf(OptimisticLockException.class)
-                    .hasMessageContaining("他のユーザーによって更新されています");
-        }
-        @Test
-        @DisplayName("ステータス更新も楽観ロックが適用される")
-        void statusUpdateWithOptimisticLock() {
-            // Arrange
-            var po = PurchaseOrder.builder()
-                    .purchaseOrderNumber("PO-2025-0003")
-                    .orderDate(LocalDate.of(2025, 1, 20))
-                    .supplierCode("SUP-001")
-                    .status(PurchaseOrderStatus.CREATING)
-                    .build();
-            purchaseOrderRepository.save(po);
-            // ユーザーAとBが同時に取得
-            var poA = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0003").get();
-            var poB = purchaseOrderRepository.findByPurchaseOrderNumber("PO-2025-0003").get();
-            // ユーザーAがステータス更新（成功）
-            purchaseOrderRepository.updateStatus(poA.getId(), PurchaseOrderStatus.ORDERED, poA.getVersion());
-            // Act & Assert: ユーザーBが古いバージョンでステータス更新（失敗）
-            assertThatThrownBy(() ->
-                    purchaseOrderRepository.updateStatus(poB.getId(), PurchaseOrderStatus.CANCELLED, poB.getVersion()))
-                    .isInstanceOf(OptimisticLockException.class);
-        }
-    }
-}
-```
-</details>
-### 入荷・検収処理における楽観ロックの考慮
-入荷から検収までの一連の処理では、発注明細の数量を段階的に更新するため、楽観ロックの適切な処理が重要です。
-```plantuml
-@startuml
-title 入荷・検収処理と楽観ロック
-participant "入荷サービス" as RecvSvc
-participant "発注明細リポジトリ" as PODRepo
-participant "入荷リポジトリ" as RecvRepo
-database "DB" as DB
-RecvSvc -> PODRepo: findByPurchaseOrderAndLine(poNumber, lineNumber)
-PODRepo -> DB: SELECT ... WHERE 発注番号 = ? AND 発注行番号 = ?
-DB --> PODRepo: 発注明細（バージョン込み）
-PODRepo --> RecvSvc: PurchaseOrderDetail
-RecvSvc -> RecvSvc: 入荷データ作成
-RecvSvc -> RecvRepo: save(receiving)
-RecvRepo -> DB: INSERT INTO 入荷受入データ
-DB --> RecvRepo: OK
-RecvSvc -> PODRepo: updateReceivedQuantity(id, quantity, version)
-PODRepo -> DB: UPDATE ... WHERE ID = ? AND バージョン = ?
-alt バージョン一致
-    DB --> PODRepo: 更新成功（1件）
-    PODRepo --> RecvSvc: OK
-else バージョン不一致
-    DB --> PODRepo: 更新失敗（0件）
-    PODRepo --> RecvSvc: OptimisticLockException
-    RecvSvc -> RecvSvc: ロールバック
-end
-@enduml
-```
-#### 分割入荷時の楽観ロック戦略
-<details>
-<summary>ReceivingService.java（楽観ロック対応）</summary>
-```java
-/**
- * 入荷処理（楽観ロック対応）
- */
-@Transactional
-public Receiving processReceiving(ReceivingRequest request) {
-    // 発注明細を取得
-    var detail = purchaseOrderDetailRepository
-            .findByPurchaseOrderAndLine(request.getPurchaseOrderNumber(), request.getLineNumber())
-            .orElseThrow(() -> new IllegalArgumentException("発注明細が見つかりません"));
-    // 入荷可能数量チェック
-    var remainingQuantity = detail.getOrderQuantity()
-            .subtract(detail.getReceivedQuantity());
-    if (request.getReceivedQuantity().compareTo(remainingQuantity) > 0) {
-        throw new IllegalArgumentException(
-                String.format("入荷数量が残数を超えています（残数: %s）", remainingQuantity));
-    }
-    // 入荷データ作成
-    var receiving = Receiving.builder()
-            .receivingNumber(generateReceivingNumber())
-            .purchaseOrderNumber(request.getPurchaseOrderNumber())
-            .lineNumber(request.getLineNumber())
-            .receivingDate(request.getReceivingDate())
-            .receivingType(determineReceivingType(detail, request.getReceivedQuantity()))
-            .receivedQuantity(request.getReceivedQuantity())
-            .locationCode(request.getLocationCode())
-            .build();
-    receivingRepository.save(receiving);
-    // 発注明細の入荷済数量を更新（楽観ロック）
-    try {
-        purchaseOrderDetailRepository.updateReceivedQuantity(
-                detail.getId(),
-                request.getReceivedQuantity(),
-                detail.getVersion()
-        );
-    } catch (OptimisticLockException e) {
-        // 他ユーザーが先に入荷処理を行った場合
-        throw new ConcurrentUpdateException(
-                "他のユーザーが同時に入荷処理を行いました。画面を更新して再度お試しください。", e);
-    }
-    // 発注ステータス更新
-    updatePurchaseOrderStatus(request.getPurchaseOrderNumber());
-    return receiving;
-}
-private ReceivingType determineReceivingType(PurchaseOrderDetail detail, BigDecimal receivedQuantity) {
-    var totalReceived = detail.getReceivedQuantity().add(receivedQuantity);
-    if (totalReceived.compareTo(detail.getOrderQuantity()) < 0) {
-        return ReceivingType.SPLIT; // 分割入荷
-    }
-    return ReceivingType.NORMAL; // 通常入荷（全数）
-}
-```
-</details>
-#### 楽観ロックのベストプラクティス（購買管理向け）
-| ポイント | 説明 |
-|---------|------|
-| **発注明細の数量更新** | 入荷・検査・検収それぞれで楽観ロックを適用 |
-| **分割入荷対応** | 複数回の入荷でも整合性を保証 |
-| **ステータス連動** | 発注ステータスと明細の完了フラグを連動更新 |
-| **エラーメッセージ** | ユーザーに再操作を促す明確なメッセージ |
-| **トランザクション境界** | 入荷→明細更新→ステータス更新を1トランザクションで |
----
-## 25.4 まとめ
-本章では、購買管理（発注から検収まで）の DB 設計と実装について学びました。
-### 学んだこと
-1. **発注業務の設計**
-   - 発注データと発注明細データの親子関係
-   - 単価マスタによる価格管理
-   - 発注ステータスの状態遷移
-   - 諸口品目（マスタ外品目）の扱い
-2. **入荷・検収業務の設計**
-   - 入荷→検査→検収の業務フロー
-   - 分割入荷への対応
-   - 良品・不良品の管理
-   - 消費税計算
-3. **命名規則のパターン**
-   - **DB（日本語）**: テーブル名、カラム名、ENUM 型・値は日本語
-   - **Java（英語）**: クラス名、フィールド名、enum 値は英語
-   - **MyBatis resultMap**: 日本語カラムと英語プロパティのマッピング
-   - **TypeHandler**: 日本語 ENUM 値と英語 enum の相互変換
-### テーブル一覧
-| テーブル名（日本語） | Java エンティティ | 説明 |
-|---|---|---|
-| 単価マスタ | UnitPrice | 品目・取引先ごとの単価情報 |
-| 発注データ | PurchaseOrder | 発注ヘッダ情報 |
-| 発注明細データ | PurchaseOrderDetail | 発注明細情報 |
-| 諸口品目情報 | MiscellaneousItem | マスタ外品目の臨時情報 |
-| 入荷受入データ | Receiving | 入荷情報 |
-| 欠点マスタ | Defect | 不良品の欠点コード |
-| 受入検査データ | Inspection | 受入検査情報 |
-| 検収データ | Acceptance | 検収情報 |
-### ENUM 一覧
-| DB ENUM 型（日本語） | Java Enum | 値 |
-|---|---|---|
-| 発注ステータス | PurchaseOrderStatus | 作成中→CREATING, 発注済→ORDERED, 一部入荷→PARTIALLY_RECEIVED, 入荷完了→RECEIVED, 検収完了→ACCEPTED, 取消→CANCELLED |
-| 入荷受入区分 | ReceivingType | 通常入荷→NORMAL, 分割入荷→SPLIT, 返品入荷→RETURN |