import io.quarkus.hibernate.orm.panache.PanacheEntity;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;

/**
 * 建立对象实体
 * '@Entity' 用于声明该类为实体类
 * '@Table' 用于声明表名信息和其他扩展配置, name 为表名, scheme 为数据库名
 * 注意1: 看官方例子的成员权限都是 public, 可以简化引入其他扩展和减少手动编写 getter/setter
 * 注意2: 留意 PanacheEntity 父类定义, 底层帮你实现默认主键, 如果想自定义主键就要去按照父类那样重写
 */
@Entity
@Table(name = "tests", schema = "game")
public class TestsModel extends PanacheEntity {

    // 因为 PanacheEntity 上层定义好了默认主键(名称为id)和我们数据库默认一样
    // 所以这里其实不用编写成员字段 id

    /**
     * 映射内部字段, '@Column' 用于扩展内部的高级参数
     */
    @Column(nullable = false, length = 64)
    public String username;


    /**
     * 默认会将类的 小驼峰命名 的字段自动转化 下划线 字段映射数据之中
     * 如果出现表名字段有差异可以通过修改 name 来映射到数据库字段
     * 注1: 虽然默认自动转化, 但是为了保险一般会尽可能追加上 name 字段防止异常, 浪费不了多少时间
     * 注2: 部分配置修改之后会出现字段不自动转化映射下划线字段, 所以建议全部有 驼峰法 的最好手动映射字段
     */
    @Column(name = "create_time", nullable = false)
    public Long createTime;


    @Column(name = "update_time", nullable = false)
    public Long updateTime;

    /**
     * 这里将 boolean 默认映射到数据库的 tinyint(1)
     * 1 = true, 0 = false
     */
    @Column(nullable = false, length = 1)
    public Boolean enabled;
}

import io.quarkus.hibernate.orm.panache.PanacheQuery;
import io.quarkus.hibernate.orm.panache.PanacheRepository;
import io.quarkus.panache.common.Page;
import io.quarkus.panache.common.Parameters;
import io.quarkus.panache.common.Sort;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.transaction.Transactional;

import java.util.Collections;
import java.util.List;
import java.util.Optional;

/**
 * 数据仓库层, 用于操作数据实体内容
 * '@ApplicationScoped': 代表持久全局初始化
 * 'PanacheRepository': 代表抽象实现具体的 Repository 工具方法
 */
@ApplicationScoped
public class TestsRepository implements PanacheRepository<TestsModel> {

    /**
     * 通过用户名查询具体实体
     */
    public Optional<TestsModel> findByUsername(String username) {
        return find("username", username).firstResultOptional();
    }


    /**
     * 针对某个 id 切换状态
     */
    public boolean enabled(int id, boolean enabled) {
        // 内部采用 ?1~?n 做递增占位填充
        // enabled 是布尔值, 直接映射 tinyint(1), 无需手动转 0/1
        int updatedRows = update("enabled = ?1 where id = ?2", enabled, id);
        return updatedRows > 0; // 影响的数据行数
    }

    /**
     * 创建用户实体, 创建数据必须啊采用事务 ‘@Transactional’ 来处理
     *
     */
    @Transactional
    public TestsModel create(TestsModel entity) {
        persistAndFlush(entity); // 创建持久化实体并立即刷新到数据库
        return entity;
    }

    /**
     * 命名参数（可读性更高，避免参数顺序错误）
     */
    public Optional<TestsModel> findByUsernameParameter(String username) {
        return find("username = :username", Parameters.with("username", username)).firstResultOptional();
    }

    /**
     * 带参数的查询 + 排序
     */
    public PanacheQuery<TestsModel> findByUsernameLike(String keyword) {
        // 命名参数 + 排序
        return find("username like :keyword order by updateTime asc",
                Parameters.with("keyword", "%" + keyword + "%"));
    }

    /**
     * 复杂条件查询（链式拼接）
     */
    public PanacheQuery<TestsModel> findByCondition(String username, Boolean enabled) {
        Sort sorted = Sort.by("username asc , updateTime desc");
        PanacheQuery<TestsModel> query = find("1=1", sorted);
        if (username != null) {
            query = query.filter("username like :username", Parameters.with("username", "%" + username + "%"));
        }
        if (enabled != null) {
            query = query.filter("enabled = :enabled", Parameters.with("enabled", enabled));
        }
        return query;
    }


    /**
     * 所有对应 Repository 方法
     */
    public void methods() {

        // 创建混合查询句柄
        PanacheQuery<TestsModel> queries = find("id > ?1", 1);


        // 设置分页总量, 每一页需要25条数据 - 注意这里不是分页功能, 只是首次分页配置
        // Page.ofSize(25) 等价于 Page.of(0, 25)
        queries.page(Page.ofSize(25));


        // 按照 page({每次数量}) 提交首次提取 25 条数据, 用于需要多次遍历
        List<TestsModel> firstPage = queries.list(); // 第1页：0~24条\
        // 判断是否有下一页, 有下一页递进获取下一页数据, 这种方式适合递归获取数据
        if (queries.hasNextPage()) {
            List<TestsModel> secondPage = queries.nextPage().list(); // 再次次获取 25~n+25
        }


        // 获取当前总页数
        // 需要知道 pageCount 和 count 的差异
        // pageCount: 代表按照指定 page 分页的页面数量
        // count: 代表指定数据的总数量
        queries.pageCount();
        queries.count();

        // 支持两种分页模式:
        // 1. page 分页: 按照每页的页码递增, 比如第 1 页查询参数为 (page=1, total = 5) 则 1 * total, 第二页查询参数为 (page=2, total = 5) 则 2 * total
        // 2. offset 分页: 按照每页的起始点递增, 比如第 1 页面查询参数为 (offset=0, total = 5) LIMIT 0, total, 第二页面查询参数为 (offset=5, total = 5)  则为 LIMIT 5,5


        //  page 分页处理
        int validPageNum = 1; // 页码≥1
        int validPageSize = 5; // 每页条数1

        // 构建查询并设置分页 - Page索引从0开始, 需转换
        PanacheQuery<TestsModel> pageResult = find("id > ?1", 1)
                .page(Page.of(validPageNum - 1, validPageSize));
        List<TestsModel> pageData = pageResult.list();
        long pageCount = pageResult.count(); // 总记录数

        // 最后封装 page 分页处理结果
        TotalPageResult<TestsModel> totalPageResult = new TotalPageResult<>(
                validPageNum,
                validPageSize,
                pageCount,
                pageData == null ? Collections.emptyList() : pageData
        );


        // offset 分页处理
        int validOffset = 0; // 偏移量≥0
        int validLimit = 5; // 条数1~5

        // 构建查询并设置分页 - Page索引从0开始, 无需转换
        PanacheQuery<TestsModel> offsetResult = find("id > ?1", 1)
                .page(Page.of(validOffset, validLimit));
        List<TestsModel> offsetData = offsetResult.list();
        long offsetCount = offsetResult.count(); // 总记录数


        // 最后封装 offset 分页处理结果
        TotalPageResult<TestsModel> offsetPageResult = new TotalPageResult<>(
                validPageNum,
                validPageSize,
                offsetCount,
                offsetData == null ? Collections.emptyList() : offsetData
        );

    }


    /**
     * offset 分页数据结果
     * 这数据类可以提取到外层统一工具, 这里放置在这里方便查看而已
     *
     * @param offset 偏移值, 默认为0, 每次递增 total
     * @param total  查询量, 客户端申请查询的每页数据量
     * @param count  数据库当中总的数据量
     * @param lists  分页列表
     * @param <T>
     */
    public record OffsetPageResult<T>(
            int offset,
            int total,
            long count,
            List<T> lists
    ) {

    }

    /**
     * page 分页数据结果
     *
     * @param page  页码值, 默认为1, 每次递增 1
     * @param total 查询量, 客户端申请查询的每页数据量
     * @param count 数据库当中总的数据量
     * @param lists 分页列表
     * @param <T>
     */
    public record TotalPageResult<T>(
            int page,
            int total,
            long count,
            List<T> lists
    ) {
    }
}

import io.quarkus.test.junit.QuarkusTest;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;


/**
 * 测试数据库测试单元
 */
@QuarkusTest
class TestsRepositoryTest {

    @Inject
    TestsRepository testsRepository;

    // 测试前置：插入测试数据
    @BeforeEach
    @Transactional
    void setUp() {
        // 清空表（避免测试数据污染）
        // 这里涉及修改|删除操作, 没有事务会导致异常警告 'hibernate.connection.provider_disables_autocommit' was enabled.
        testsRepository.deleteAll();

        // 插入3条测试数据
        TestsModel user1 = new TestsModel();
        user1.username = "test1";
        user1.createTime = System.currentTimeMillis() - 86400;
        user1.updateTime = System.currentTimeMillis();
        user1.enabled = true;
        testsRepository.create(user1);

        TestsModel user2 = new TestsModel();
        user2.username = "test2";
        user2.createTime = System.currentTimeMillis() - 86400;
        user2.updateTime = System.currentTimeMillis();
        user2.enabled = true;
        testsRepository.create(user2);

        TestsModel user3 = new TestsModel();
        user3.username = "test3";
        user3.enabled = true;
        user3.createTime = System.currentTimeMillis() - 86400;
        user3.updateTime = System.currentTimeMillis();
        testsRepository.create(user3);
    }


    // ==================== 基础查询测试 ====================
    @Test
    void testFindByUsername() {
        // 存在的用户
        Optional<TestsModel> existUser = testsRepository.findByUsername("test1");
        assertTrue(existUser.isPresent());
        assertEquals("test1", existUser.get().username);

        // 不存在的用户
        Optional<TestsModel> notExistUser = testsRepository.findByUsername("test_not_exist");
        assertFalse(notExistUser.isPresent());
    }

    // ==================== 增删改测试 ====================
    @Test
    void testCreate() {
        // 新增用户
        TestsModel newUser = new TestsModel();
        newUser.username = "test4";
        newUser.createTime = System.currentTimeMillis() - 86400;
        newUser.updateTime = System.currentTimeMillis();
        newUser.enabled = true;
        TestsModel savedUser = testsRepository.create(newUser);

        // 验证
        assertNotNull(savedUser.id);
        assertEquals("test4", savedUser.username);
        assertEquals(4, testsRepository.count()); // 总条数=4
    }


    @Test
    @Transactional
    void testDeleteById() {
        // 找到test2的ID并删除
        Long test2Id = testsRepository.findByUsername("test2").get().id;
        boolean deleteResult = testsRepository.deleteById(test2Id);

        // 验证
        assertTrue(deleteResult);
        assertEquals(2, testsRepository.count()); // 总条数=2
        assertFalse(testsRepository.findByUsername("test2").isPresent());
    }

}

/**
 * 建立对象实体
 * '@Entity' 用于声明该类为实体类, name 为表名, scheme 为数据库名
 * '@Table' 用于声明表名信息和其他扩展配置,
 * 注意1: 看官方例子的成员权限都是 public, 可以简化引入其他扩展和减少手动编写 getter/setter
 * 注意2: 留意 PanacheEntity 父类定义, 底层帮你实现默认主键, 如果想自定义主键就要去按照父类那样重写
 * 注意2: 采用自定义序列就不应该继承 PanacheEntity, 而是需要继承 PanacheEntityBase
 */
@Entity
@Table(name = "tests")
public class TestsModel extends PanacheEntityBase {
    /**
     * 但是默认的主键不是递增生成(这里默认主键生成需要额外创建表全局管理)
     * 声明采用自增ID策略
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Long id;


    // 其他略

    /**
     * 格式化字符串
     */
    public String toString() {
        String var10000 = this.getClass().getSimpleName();
        return var10000 + "<" + this.id + ">";
    }
}