第三章 关系映射¶

// 传统可变对象模型
public class Product {
    private Long id;
    private String name;
    private BigDecimal price;
    private int stock;
    // getter 和 setter 略
}

// 在多线程环境下的问题
void process() {
    Product product = productRepository.findById(1L);
    // 线程A读取价格
    BigDecimal price = product.getPrice();
    // 同时线程B修改价格
    product.setPrice(price.multiply(new BigDecimal("0.9")));
    // 线程A基于已读取的值计算，但此时价格已经被修改，导致计算错误
}

@Test
@DisplayName("测试不可变对象在多线程环境中的线程安全性")
public void testThreadSafety() throws InterruptedException {
    // 创建不可变商品对象
    Product product = createTestProduct();

    // 创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(10);
    CountDownLatch latch = new CountDownLatch(20);
    AtomicReference<Exception> error = new AtomicReference<>();

    // 10个线程派生新对象 - 修改价格
    for (int i = 0; i < 10; i++) {
        final int discount = i + 1;
        executor.submit(() -> {
            try {
                // 基于原对象创建新的促销价格对象
                BigDecimal discountRate = new BigDecimal("0." + discount);
                Product discountedProduct = ProductDraft.$.produce(product, draft -> {
                    draft.setPrice(product.price().multiply(discountRate).setScale(2, RoundingMode.HALF_UP));
                });

                // 验证：原对象不变，新对象正确反映折扣
                assertEquals(new BigDecimal("5999.00"), product.price());
                assertTrue(discountedProduct.price().compareTo(product.price()) < 0);
            } catch (Exception e) {
                error.set(e);
            } finally {
                latch.countDown();
            }
        });
    }

    // 10个线程读取对象
    for (int i = 0; i < 10; i++) {
        executor.submit(() -> {
            try {
                // 在所有线程中，原始对象的值始终不变
                assertEquals(new BigDecimal("5999.00"), product.price());
                assertEquals("高性能笔记本电脑", product.name());
                assertEquals(100, product.stock());
            } catch (Exception e) {
                error.set(e);
            } finally {
                latch.countDown();
            }
        });
    }

    // 等待所有线程完成
    latch.await(5, TimeUnit.SECONDS);
    executor.shutdown();

    // 验证：没有出现并发错误
    assertNull(error.get(), "并发测试出现错误: " + (error.get() != null ? error.get().getMessage() : ""));
}

@Entity
public interface Product {
    @Id
    String id();

    String name();

    BigDecimal price();

    int stock();

    String description();

    boolean active();

    LocalDateTime createdTime();
}

// 创建新对象
Product product = ProductDraft.$.produce(draft -> {
    draft.setId("product-1");
    draft.setName("高性能笔记本电脑");
    draft.setPrice(new BigDecimal("5999.00"));
    draft.setStock(100);
});

// 基于现有对象创建新对象
Product discountedProduct = ProductDraft.$.produce(product, draft -> {
    draft.setPrice(new BigDecimal("4999.00"));
});

// 验证原对象不变
assert product.price().equals(new BigDecimal("5999.00"));
// 验证新对象包含更新
assert discountedProduct.price().equals(new BigDecimal("4999.00"));

@Test
@DisplayName("测试不可变对象在并发环境下的一致性视图")
public void testConsistentView() throws InterruptedException {
    // 创建初始商品
    Product originalProduct = createTestProduct();

    // 准备使用的对象引用
    final AtomicReference<Product> sharedProduct = new AtomicReference<>(originalProduct);
    final CountDownLatch updateLatch = new CountDownLatch(1);
    final CountDownLatch readLatch = new CountDownLatch(5);
    final AtomicReference<Exception> error = new AtomicReference<>();

    // 创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(6);

    // 5个线程读取初始对象，然后等待，再读取更新后的对象
    for (int i = 0; i < 5; i++) {
        executor.submit(() -> {
            try {
                // 读取初始版本
                Product initialView = sharedProduct.get();
                assertEquals(new BigDecimal("5999.00"), initialView.price());
                assertEquals(100, initialView.stock());

                // 等待更新完成
                updateLatch.await();

                // 读取更新后的版本
                Product updatedView = sharedProduct.get();
                assertEquals(new BigDecimal("4999.00"), updatedView.price());
                assertEquals(50, updatedView.stock());

                // 重要：初始视图保持不变
                assertEquals(new BigDecimal("5999.00"), initialView.price());
                assertEquals(100, initialView.stock());
            } catch (Exception e) {
                error.set(e);
            } finally {
                readLatch.countDown();
            }
        });
    }

    // 1个线程更新对象
    executor.submit(() -> {
        try {
            // 稍微延迟，确保读取线程先开始
            Thread.sleep(100);

            // 更新共享对象
            Product updatedProduct = ProductDraft.$.produce(sharedProduct.get(), draft -> {
                draft.setPrice(new BigDecimal("4999.00"));
                draft.setStock(50);
            });

            // 更新引用
            sharedProduct.set(updatedProduct);

            // 通知读取线程继续
            updateLatch.countDown();
        } catch (Exception e) {
            error.set(e);
        }
    });

    // 等待所有读取线程完成
    readLatch.await(5, TimeUnit.SECONDS);
    executor.shutdown();

    // 验证：没有出现并发错误
    assertNull(error.get(), "并发测试出现错误: " + (error.get() != null ? error.get().getMessage() : ""));
}

// 更新共享对象
Product updatedProduct = ProductDraft.$.produce(sharedProduct.get(), draft -> {
    draft.setPrice(new BigDecimal("4999.00"));
    draft.setStock(50);
});

// 更新引用
sharedProduct.set(updatedProduct);

@Test
@DisplayName("比较不可变对象和可变对象在并发环境下的性能和安全性")
public void testImmutableVsMutablePerformance() throws InterruptedException {
    // 测试参数
    final int threadCount = 100;
    final int iterationsPerThread = 1000;

    // 准备测试数据
    Product immutableProduct = createTestProduct();
    MutableProduct mutableProduct = createMutableFromImmutable(immutableProduct);

    // 收集错误
    List<Exception> mutableErrors = new ArrayList<>();
    List<Exception> immutableErrors = new ArrayList<>();

    // 执行测试并测量性能
    long mutableTime = testMutableProductWithLock(mutableProduct, threadCount, iterationsPerThread, mutableErrors);
    long immutableTime = testImmutableProductWithCAS(immutableProduct, threadCount, iterationsPerThread, immutableErrors);

    // 打印性能对比结果
    System.out.println("可变对象（使用锁）执行时间: " + mutableTime + " ms, 错误数: " + mutableErrors.size());
    System.out.println("不可变对象执行时间: " + immutableTime + " ms, 错误数: " + immutableErrors.size());

    // 验证执行结果
    assertTrue(mutableErrors.isEmpty(), "可变对象执行出现错误");
    assertTrue(immutableErrors.isEmpty(), "不可变对象执行出现错误");
}

@Test
@DisplayName("测试使用不可变对象实现时间旅行查询（特定版本访问）")
public void testTimeTravel() {
    // 创建历史追踪器
    ProductHistoryTracker historyTracker = new ProductHistoryTracker();

    // 创建初始版本并记录5个版本的变更
    Product initialProduct = createInitialProduct();
    historyTracker.initializeHistory(initialProduct, "商品初始创建");

    // 逐步模拟商品生命周期
    Product product = initialProduct;

    // 阶段1: 调整价格和描述
    product = historyTracker.createVersion(
        product,
        draft -> {
            draft.setPrice(new BigDecimal("1099.99"));
            draft.setDescription("高品质商品，值得信赖");
        },
        "首次价格调整和描述优化"
    );

    // 阶段2: 促销活动
    final Product finalProduct = product; // 创建一个final副本用于lambda捕获
    product = historyTracker.createVersion(
        product,
        draft -> {
            draft.setPrice(new BigDecimal("899.99"));
            draft.setName(finalProduct.name() + " [促销]");
        },
        "季节性促销活动"
    );

    // 阶段3: 库存变化
    product = historyTracker.createVersion(
        product,
        draft -> draft.setStock(50),
        "销售了50个单位"
    );

    // 阶段4: 促销结束，价格回调
    product = historyTracker.createVersion(
        product,
        draft -> {
            draft.setPrice(new BigDecimal("1199.99"));
            draft.setName(draft.name().replace(" [促销]", ""));
        },
        "促销活动结束"
    );

    // 获取完整历史记录
    List<Product> history = historyTracker.getVersionHistory();

    // 验证历史版本数量
    assertThat(history).hasSize(5);

    // 时间旅行 - 访问促销期间的版本
    Product promotionVersion = history.get(2);
    assertThat(promotionVersion.name()).contains("[促销]");
    assertThat(promotionVersion.price()).isEqualTo(new BigDecimal("899.99"));

    // 比较初始版本和最终版本
    Product finalVersion = history.get(4);
    assertThat(finalVersion.price()).isEqualTo(new BigDecimal("1199.99"));
    assertThat(finalVersion.stock()).isEqualTo(50);
    assertThat(finalVersion.description()).isEqualTo("高品质商品，值得信赖");

    // 验证不可变性确保历史版本没有被修改
    assertThat(initialProduct.price()).isEqualTo(new BigDecimal("999.99"));
    assertThat(initialProduct.stock()).isEqualTo(100);
}

private static class ProductHistoryTracker {
    private final List<Product> versions = new ArrayList<>();
    private final Map<Product, String> changeReasons = new HashMap<>();

    // 创建新的版本
    public Product createVersion(Product baseProduct, Consumer<ProductDraft> modifier, String reason) {
        // 创建新版本
        Product newVersion = ProductDraft.$.produce(baseProduct, draft -> {
            modifier.accept(draft);
        });

        // 记录版本和变更原因
        versions.add(newVersion);
        changeReasons.put(newVersion, reason);

        return newVersion;
    }

    // 获取所有历史版本
    public List<Product> getVersionHistory() {
        return new ArrayList<>(versions);
    }

    // 获取变更日志
    public List<Map<String, Object>> getChangeLog() {
        List<Map<String, Object>> changeLog = new ArrayList<>();

        // 比较每一个版本与前一个版本的差异
        for (int i = 1; i < versions.size(); i++) {
            Product currentVersion = versions.get(i);
            Product previousVersion = versions.get(i - 1);

            Map<String, Object> change = new HashMap<>();
            change.put("version", i + 1);
            change.put("reason", changeReasons.get(currentVersion));
            change.put("changes", detectChanges(previousVersion, currentVersion));

            changeLog.add(change);
        }

        return changeLog;
    }

    // 检测版本间差异
    private Map<String, Object[]> detectChanges(Product oldVersion, Product newVersion) {
        Map<String, Object[]> changes = new HashMap<>();

        // 比较各个属性
        if (!oldVersion.name().equals(newVersion.name())) {
            changes.put("name", new Object[] { oldVersion.name(), newVersion.name() });
        }

        if (!oldVersion.price().equals(newVersion.price())) {
            changes.put("price", new Object[] { oldVersion.price(), newVersion.price() });
        }

        // 更多属性比较...

        return changes;
    }
}

// 记录商品变更事件
void recordProductEvent(String productId, ProductEvent event) {
    eventStore.save(new ProductEventRecord(productId, event));
}

// 重建特定时刻的商品状态
Product rebuildProductAtTime(String productId, LocalDateTime pointInTime) {
    List<ProductEventRecord> events = eventStore.findEventsBeforeTime(productId, pointInTime);
    Product product = null;

    for (ProductEventRecord record : events) {
        if (product == null) {
            // 初始事件创建产品
            product = record.getEvent().createProduct();
        } else {
            // 后续事件修改产品
            product = record.getEvent().applyTo(product);
        }
    }

    return product;
}

@Test
@DisplayName("测试递归查询获取完整分类树")
public void testRecursiveTreeFetcher() {
    // 准备测试数据
    Map<String, String> ids = prepareTestCategoryTreeForRecursiveTest();
    String rootId = ids.get("rootId");

    // 创建递归获取器，抓取整个分类树
    Fetcher<Category> treeFetcher = CategoryFetcher.$
        .allScalarFields()
        .childCategories(
            CategoryFetcher.$.allScalarFields()
                .childCategories(
                    CategoryFetcher.$.allScalarFields()
                )
        );

    // 执行查询
    Category root = sqlClient
        .createQuery(CategoryTable.$)
        .where(CategoryTable.$.id().eq(rootId))
        .select(CategoryTable.$.fetch(treeFetcher))
        .fetchOne();

    // 验证根节点
    assertThat(root).isNotNull();
    assertThat(root.name()).isEqualTo("电子产品");

    // 验证子节点
    List<Category> level1Children = root.childCategories();
    assertThat(level1Children).hasSize(3);

    // 创建一个可变列表并按sortIndex排序
    List<Category> sortedChildren = new ArrayList<>(level1Children);
    sortedChildren.sort(Comparator.comparing(Category::sortIndex));

    // 验证排序后的结果
    assertThat(sortedChildren.get(0).name()).isEqualTo("手机");
    assertThat(sortedChildren.get(1).name()).isEqualTo("笔记本");
    assertThat(sortedChildren.get(2).name()).isEqualTo("配件");

    // 验证第二层级的"手机"分类下的子分类
    Category phones = findCategoryByName(level1Children, "手机");
    assertThat(phones.childCategories()).hasSize(2);

    List<String> phoneSubcategories = new ArrayList<>();
    for (Category subCategory : phones.childCategories()) {
        phoneSubcategories.add(subCategory.name());
    }
    assertThat(phoneSubcategories).containsExactlyInAnyOrder("iPhone", "Android");

    // 验证更多子分类...
}

@Test
@DisplayName("测试从叶子节点向上查询分类路径")
public void testCategoryPathToRoot() {
    // 准备测试数据
    Map<String, String> ids = prepareTestCategoryTreeForPathTest();
    String iPhoneId = ids.get("iPhoneId");

    // 获取从iPhone分类到根节点的路径
    List<Category> path = getCategoryPathToRoot(iPhoneId);

    // 验证路径
    assertThat(path).hasSize(3); // 应该是三层：iPhone -> 手机 -> 电子产品

    // 验证路径顺序（从叶子到根）
    assertThat(path.get(0).name()).isEqualTo("iPhone");
    assertThat(path.get(1).name()).isEqualTo("手机");
    assertThat(path.get(2).name()).isEqualTo("电子产品");

    // 验证其他叶子节点路径...
}

@Entity
@Table(name = "t_category")
public interface Category {

    @Id
    String id();

    @Key
    String name();

    @Column(name = "sort_index")
    int sortIndex();

    @Nullable
    @ManyToOne
    @JoinColumn(name = "parent_id")
    Category parent();

    @OneToMany(mappedBy = "parent")
    @OrderBy("sortIndex asc")
    List<Category> childCategories();

    @OneToMany(mappedBy = "category")
    List<Product> products();
}

Fetcher<Category> treeFetcher = CategoryFetcher.$
    .allScalarFields()
    .childCategories(
        CategoryFetcher.$.allScalarFields()
            .childCategories(
                CategoryFetcher.$.allScalarFields()
            )
    );

private List<Category> getCategoryPathToRoot(String categoryId) {
    // 一次性加载所有分类的基本信息
    List<Category> allCategories = sqlClient
        .createQuery(CategoryTable.$)
        .select(CategoryTable.$.fetch(CategoryFetcher.$.name()))
        .execute();

    // 一次性加载所有父子关系
    List<Tuple2<String, String>> relations = sqlClient
        .createQuery(CategoryTable.$)
        .select(
            CategoryTable.$.id(),
            CategoryTable.$.parent().id()
        )
        .execute();

    // 构建映射表和关系图   
    Map<String, Category> categoryMap = new HashMap<>();
    Map<String, String> parentIdMap = new HashMap<>();

    // 填充...

    // 构建从叶子到根的路径
    List<Category> path = new ArrayList<>();
    String currentId = categoryId;

    while (currentId != null) {
        Category category = categoryMap.get(currentId);
        if (category != null) {
            path.add(category);
            // 查找父ID
            currentId = parentIdMap.get(currentId);
        } else {
            currentId = null;
        }
    }

    return path;
}

// 创建分类及其父子关系
Category phones = CategoryDraft.$.produce(draft -> {
    draft.setId("phones");
    draft.setName("手机");
    draft.setSortIndex(1);
    draft.setParent(CategoryDraft.$.produce(p -> p.setId("electronics")));
});
sqlClient.getEntities().save(phones);

// 加载时，parent和childCategories会自动保持一致

// 设置最大递归深度
Fetcher<Category> treeFetcher = CategoryFetcher.$
    .allScalarFields()
    .childCategories(cfg -> cfg
        .filter(childTable -> childTable.name().like("手机%"))
        .recursive(recursiveCfg -> recursiveCfg.depth(5))
    );

// 缓存根分类树
Category rootCategory = categoryCache.computeIfAbsent(
    "ROOT_TREE", 
    key -> sqlClient.findById(treeFetcher, rootId)
);

// 批量保存多个分类节点
List<Category> categories = /* ... */;
sqlClient.getEntities().saveAll(categories);

@Entity
public interface CategoryWithPath {
    @Id
    String id();

    String name();

    // 存储从根到当前节点的完整路径，如 "/1/12/123/"
    @Column(name = "path")
    String path();

    // 其他属性...
}

@Test
@DisplayName("测试ManyToMany关系 - 查询商品及其标签")
public void testManyToManyAssociation() {
    // 准备测试数据
    Map<String, String> testData = prepareManyToManyTestData();
    String productId = testData.get("productId");

    // 定义查询，获取商品及其标签
    Fetcher<Product> fetcher = ProductFetcher.$
        .allScalarFields()
        .tags(TagFetcher.$
            .allScalarFields()
        );

    // 执行查询
    Product product = sqlClient
        .createQuery(ProductTable.$)
        .where(ProductTable.$.id().eq(productId))
        .select(ProductTable.$.fetch(fetcher))
        .fetchOne();

    // 验证查询结果
    assertThat(product).isNotNull();
    assertThat(product.name()).contains("iPhone 15 Pro");

    List<Tag> tags = product.tags();
    assertThat(tags).hasSize(3);

    // 验证标签内容
    List<String> tagNames = tags.stream()
        .map(Tag::name)
        .collect(Collectors.toList());
    assertThat(tagNames).containsExactlyInAnyOrder("高端", "手机", "Apple");
}

@Test
@DisplayName("测试根据标签查询产品")
public void testQueryProductsByTag() {
    // 准备测试数据
    Map<String, String> testData = prepareProductTagQueryTestData();
    String tagId = testData.get("tagId");

    // 定义查询获取器
    Fetcher<Tag> fetcher = TagFetcher.$
        .allScalarFields()
        .products(ProductFetcher.$.allScalarFields());

    // 执行查询
    Tag tag = sqlClient
        .createQuery(TagTable.$)
        .where(TagTable.$.id().eq(tagId))
        .select(TagTable.$.fetch(fetcher))
        .fetchOne();

    // 验证查询结果
    assertThat(tag).isNotNull();
    assertThat(tag.name()).isEqualTo("高端");
    assertThat(tag.products()).hasSize(2);

    // 验证相关联的产品
    List<String> productNames = tag.products().stream()
        .map(Product::name)
        .collect(Collectors.toList());
    assertThat(productNames).containsExactlyInAnyOrder(
        "iPhone 15 Pro", "MacBook Pro 16"
    );
}

@Entity
@Table(name = "t_product")
public interface Product {
    // 其他属性...

    @ManyToMany
    @JoinTable(
        name = "t_product_tag",
        joinColumnName = "product_id",
        inverseJoinColumnName = "tag_id"
    )
    @OrderBy("name asc")
    List<Tag> tags();
}

@Entity
@Table(name = "t_tag")
public interface Tag {
    @Id
    String id();

    @Key
    String name();

    @ManyToMany(mappedBy = "tags")
    List<Product> products();
}

// 创建带有标签的商品
Product product = ProductDraft.$.produce(draft -> {
    draft.setId("iphone");
    draft.setName("iPhone 15 Pro");
    draft.setPrice(new BigDecimal("8999.00"));
    // 省略其他属性...

    // 设置关联标签
    draft.setTags(Arrays.asList(
        TagDraft.$.produce(t -> t.setId("tag-1").setName("高端")),
        TagDraft.$.produce(t -> t.setId("tag-2").setName("手机")),
        TagDraft.$.produce(t -> t.setId("tag-3").setName("Apple"))
    ));
});

// 保存商品及其标签关系
sqlClient.getEntities().save(product);

// 标签变更时，Jimmer会生成如下操作：
// 1. 删除移除的关联
DELETE FROM t_product_tag WHERE product_id = ? AND tag_id IN (?, ?, ...);
// 2. 添加新的关联
INSERT INTO t_product_tag(product_id, tag_id) VALUES (?, ?), (?, ?), ...;

// 修改商品标签
Product updatedProduct = ProductDraft.$.produce(existingProduct, draft -> {
    // 获取现有标签集合的可变副本
    List<Tag> tags = new ArrayList<>(existingProduct.tags());

    // 移除一个标签
    tags.removeIf(tag -> tag.name().equals("手机"));

    // 添加一个新标签
    tags.add(TagDraft.$.produce(t -> t.setId("tag-4").setName("新品")));

    // 设置更新后的标签集合
    draft.setTags(tags);
});

// 保存修改
sqlClient.getEntities().save(updatedProduct);

@ManyToMany
@JoinTable(
    name = "t_product_tag",
    joinColumnName = "product_id",
    inverseJoinColumnName = "tag_id",
    extraColumnDefinition = {
        "assigned_time datetime not null",
        "assigned_by varchar(50)"
    }
)
List<Tag> tags();

@ManyToMany
@JoinTable(/* ... */)
@OnDelete(deleteMode = DeleteMode.CASCADE)
List<Tag> tags();

@ManyToMany(mappedBy = "tags")
// 注意：没有级联删除配置
List<Product> products();

@Test
@DisplayName("测试基本动态查询 - 可选条件")
public void testBasicDynamicQuery() {
    // 准备测试数据
    java.util.Map<String, Object> testData = prepareDynamicQueryTestData();
    String testPrefix = (String) testData.get("testPrefix");
    String nameKeyword = (String) testData.get("nameKeyword");
    BigDecimal minPrice = (BigDecimal) testData.get("minPrice");
    BigDecimal maxPrice = (BigDecimal) testData.get("maxPrice"); // null

    // 构建查询
    var query = sqlClient.createQuery(ProductTable.$)
        .where(ProductTable.$.id().like(testPrefix + "-%")); // 只查询我们刚创建的测试数据

    // 名称关键词条件（如果提供）
    if (StringUtils.hasText(nameKeyword)) {
        query = query.where(ProductTable.$.name().like("%" + nameKeyword + "%"));
    }

    // 最低价格条件（如果提供）
    if (minPrice != null) {
        query = query.where(ProductTable.$.price().ge(minPrice));
    }

    // 最高价格条件（如果提供）
    if (maxPrice != null) {
        query = query.where(ProductTable.$.price().le(maxPrice));
    }

    // 执行查询
    List<Product> products = query.select(ProductTable.$).execute();

    // 验证查询结果
    assertFalse(products.isEmpty(), "应该找到包含'Pro'且价格大于1000的商品");

    // 验证结果符合条件
    for (Product product : products) {
        // 验证ID前缀正确
        assertTrue(product.id().startsWith(testPrefix), 
            "产品ID应以测试前缀开头: " + testPrefix);

        // 验证名称包含关键词
        assertTrue(product.name().contains(nameKeyword), 
            "产品名称应包含关键词: " + nameKeyword);

        // 验证价格大于等于最低价格
        assertTrue(product.price().compareTo(minPrice) >= 0, 
            "产品价格应大于等于: " + minPrice);
    }
}

private java.util.Map<String, Object> prepareDynamicQueryTestData() {
    // 为此测试创建唯一的数据标识前缀
    String testPrefix = "dq-test-" + java.util.UUID.randomUUID().toString().substring(0, 8);

    // 定义测试产品信息
    java.util.List<java.util.Map<String, Object>> productsInfo = java.util.Arrays.asList(
        java.util.Map.of(
            "id", testPrefix + "-macbook-pro",
            "name", testPrefix + "-MacBook Pro",
            "price", new BigDecimal("12999.00"),
            "stock", 30
        ),
        java.util.Map.of(
            "id", testPrefix + "-iphone-pro",
            "name", testPrefix + "-iPhone Pro",
            "price", new BigDecimal("8999.00"),
            "stock", 100
        ),
        // 更多测试产品...
    );

    // 创建测试产品
    for (java.util.Map<String, Object> productInfo : productsInfo) {
        Product product = ProductDraft.$.produce(draft -> {
            draft.setId((String) productInfo.get("id"));
            draft.setName((String) productInfo.get("name"));
            draft.setPrice((BigDecimal) productInfo.get("price"));
            draft.setStock((Integer) productInfo.get("stock"));
            draft.setDescription("测试产品");
            draft.setActive(true);
            draft.setCreatedTime(java.time.LocalDateTime.now());
        });
        sqlClient.getEntities().save(product);
    }

    // 返回测试参数
    java.util.Map<String, Object> result = new java.util.HashMap<>();
    result.put("testPrefix", testPrefix);
    result.put("nameKeyword", "Pro");
    result.put("minPrice", new BigDecimal("1000"));
    result.put("maxPrice", null);
    return result;
}

@Test
@DisplayName("测试复杂条件组合 - 谓词构建器")
public void testPredicateBuilder() {
    // 准备测试数据
    java.util.Map<String, Object> testData = prepareDynamicQueryTestData();
    String testPrefix = (String) testData.get("testPrefix");

    // 构建搜索参数对象
    ProductSearchParams params = new ProductSearchParams();
    params.setNamePattern("%" + testPrefix + "%");
    params.setMinPrice(new BigDecimal("3000"));
    params.setMaxPrice(new BigDecimal("15000"));
    // 设置多个库存区间：库存<50或库存>100
    params.setStockRanges(Arrays.asList(
        new StockRange(0, 50),
        new StockRange(100, Integer.MAX_VALUE)
    ));

    // 使用谓词构建器模式查询
    List<Product> products = searchProducts(params, testPrefix);

    // 验证结果
    assertFalse(products.isEmpty(), "应该找到符合复杂条件的商品");

    // 验证每个产品都符合条件
    for (Product product : products) {
        // 验证名称包含前缀
        assertTrue(product.name().contains(testPrefix),
            "产品名称应包含前缀: " + testPrefix);

        // 验证价格在范围内
        assertTrue(product.price().compareTo(params.getMinPrice()) >= 0,
            "产品价格应大于等于: " + params.getMinPrice());
        assertTrue(product.price().compareTo(params.getMaxPrice()) <= 0,
            "产品价格应小于等于: " + params.getMaxPrice());

        // 验证库存符合任一区间
        boolean stockInRange = false;
        for (StockRange range : params.getStockRanges()) {
            if (product.stock() >= range.getMin() && product.stock() <= range.getMax()) {
                stockInRange = true;
                break;
            }
        }
        assertTrue(stockInRange, "产品库存应在指定范围内");
    }
}

// 产品搜索参数类
private static class ProductSearchParams {
    private String namePattern;
    private BigDecimal minPrice;
    private BigDecimal maxPrice;
    private List<StockRange> stockRanges;

    // getter和setter方法...
}

// 库存范围类
private static class StockRange {
    private final int min;
    private final int max;

    public StockRange(int min, int max) {
        this.min = min;
        this.max = max;
    }

    // getter方法...
}

// 使用谓词构建器模式搜索产品
private List<Product> searchProducts(ProductSearchParams params, String testPrefix) {
    ProductTable table = ProductTable.$;

    // 使用Consumer<List<Predicate>>模式构建复合条件
    List<Predicate> predicates = new ArrayList<>();

    // 添加测试数据前缀条件
    predicates.add(table.id().like(testPrefix + "-%"));

    // 添加基本条件 - 名称匹配
    if (StringUtils.hasText(params.getNamePattern())) {
        predicates.add(table.name().like(params.getNamePattern()));
    }

    // 添加价格范围条件
    if (params.getMinPrice() != null) {
        predicates.add(table.price().ge(params.getMinPrice()));
    }

    if (params.getMaxPrice() != null) {
        predicates.add(table.price().le(params.getMaxPrice()));
    }

    // 添加复杂库存条件 (多个范围的OR组合)
    if (params.getStockRanges() != null && !params.getStockRanges().isEmpty()) {
        List<Predicate> stockPredicates = new ArrayList<>();

        for (StockRange range : params.getStockRanges()) {
            stockPredicates.add(
                Predicate.and(
                    table.stock().ge(range.getMin()),
                    table.stock().le(range.getMax())
                )
            );
        }

        // 将多个库存范围条件用OR组合
        predicates.add(Predicate.or(stockPredicates.toArray(new Predicate[0])));
    }

    // 执行查询
    return sqlClient
        .createQuery(table)
        .where(Predicate.and(predicates.toArray(new Predicate[0])))
        .select(table)
        .execute();
}