JAVA下唯一一款搞定OLTP+OLAP的強型別查詢這就是最好用的ORM相見恨晚

薛家明發表於2024-04-30
Java型別ORM

JAVA下唯一一款搞定OLTP+OLAP的強型別查詢這就是最好用的ORM相見恨晚

介紹

首先非常感謝 FreeSQL 提供的部分原始碼,讓我借鑑了不少功能點,整體設計並沒有參考FreeSQL(因為java壓根沒有expression所以沒辦法參考)只是在資料庫方言上FreeSQL提供的SQL讓我少走了很多彎路,所以才讓easy-query可以走的這麼迅速

醜話說在前頭,這是java下面唯一一款可以完全替代SQL的強型別ORM,完美支援OLTP和OLAP語法篩選記住是唯一一款

想體驗完整版請檢視文件部落格篇幅有限見諒本次僅展示OLTP的物件關聯查詢

easy-query

文件地址 https://xuejmnet.github.io/easy-query-doc/ (為什麼沒有gitee的文件因為gitee pages掛掉了目前沒辦法更新)

GITHUB地址 https://github.com/xuejmnet/easy-query

GITEE地址 https://gitee.com/xuejm/easy-query

java下面唯一一款支援強型別OLTP和OLAP語法並且支援分表分庫的最好用的ORM,為什麼是最好用的OLTP那麼我們先來看一個簡單的例子

  • 使用者、角色、選單典型的多對多關聯關係(隱式子查詢)
  • 其中使用者和使用者所在地址為一對一關係(隱式join)

@Table("t_user")
@Data
@EntityProxy
public class SysUser implements ProxyEntityAvailable<SysUser , SysUserProxy> {
    @Column(primaryKey = true)
    private String id;
    private String name;
    private LocalDateTime createTime;

    @Navigate(value = RelationTypeEnum.ManyToMany,
            mappingClass = UserRole.class,
            selfMappingProperty = "userId",
            targetMappingProperty = "roleId")
    private List<SysRole> roles;

    @Navigate(value = RelationTypeEnum.OneToOne,targetProperty = "userId")
    private SysUserAddress address;

    @Override
    public Class<SysUserProxy> proxyTableClass() {
        return SysUserProxy.class;
    }
}


@Table("t_role")
@Data
@EntityProxy
public class SysRole implements ProxyEntityAvailable<SysRole, SysRoleProxy> {
    @Column(primaryKey = true)
    private String id;
    private String name;
    private LocalDateTime createTime;

    @Navigate(value = RelationTypeEnum.ManyToMany,
            mappingClass = UserRole.class,
            selfMappingProperty = "roleId",
            targetMappingProperty = "userId")
    private List<SysUser> users;

    @Navigate(value = RelationTypeEnum.ManyToMany,
            mappingClass = RoleMenu.class,
            selfMappingProperty = "roleId",
            targetMappingProperty = "menuId")
    private List<SysMenu> menus;

    @Override
    public Class<SysRoleProxy> proxyTableClass() {
        return SysRoleProxy.class;
    }
}


@Table("t_user_role")
@Data
@EntityProxy
public class UserRole implements ProxyEntityAvailable<UserRole , UserRoleProxy> {
    @Column(primaryKey = true)
    private String id;
    private String userId;
    private String roleId;

    @Override
    public Class<UserRoleProxy> proxyTableClass() {
        return UserRoleProxy.class;
    }
}


@Table("t_menu")
@Data
@EntityProxy
public class SysMenu implements ProxyEntityAvailable<SysMenu , SysMenuProxy> {
    @Column(primaryKey = true)
    private String id;
    private String name;
    private String route;
    private String icon;

    @Navigate(value = RelationTypeEnum.ManyToMany,
            mappingClass = RoleMenu.class,
            selfMappingProperty = "menuId",
            targetMappingProperty = "roleId")
    private List<SysRole> roles;

    @Override
    public Class<SysMenuProxy> proxyTableClass() {
        return SysMenuProxy.class;
    }
}


@Table("t_role_menu")
@Data
@EntityProxy
public class RoleMenu implements ProxyEntityAvailable<RoleMenu , RoleMenuProxy> {
    @Column(primaryKey = true)
    private String id;
    private String roleId;
    private String menuId;

    @Override
    public Class<RoleMenuProxy> proxyTableClass() {
        return RoleMenuProxy.class;
    }
}
@Table("t_user_address")
@Data
@EntityProxy
public class SysUserAddress implements ProxyEntityAvailable<SysUserAddress , SysUserAddressProxy> {
    @Column(primaryKey = true)
    private String id;
    private String userId;
    private String province;
    private String city;
    private String area;
    private String addr;

    @Override
    public Class<SysUserAddressProxy> proxyTableClass() {
        return SysUserAddressProxy.class;
    }
}

對應關係為使用者和角色是多對多,角色和選單也是多對多

案例1

查詢杭州或紹興的使用者


        List<SysUser> userInHz = easyEntityQuery.queryable(SysUser.class)
                .where(s -> {
                    //隱式子查詢會自動join使用者表和地址表
                    s.or(()->{
                        s.address().city().eq("杭州市");
                        s.address().city().eq("紹興市");
                    });
                }).toList();
SELECT
    t.`id`,
    t.`name`,
    t.`create_time` 
FROM
    `t_user` t 
LEFT JOIN
    `t_user_address` t1 
        ON t1.`user_id` = t.`id` 
WHERE
    (
        t1.`city` = '杭州市' 
        OR t1.`city` = '紹興市'
    )

查詢使用者叫做小明的返回小明的姓名和小明所在地址


        List<Draft2<String, String>> userNameAndAddr = easyEntityQuery.queryable(SysUser.class)
                .where(s -> {
                    s.name().eq("小明");
                }).select(s -> Select.DRAFT.of(
                        s.name(),
                        s.address().addr()//隱式join因為使用者返回了地址標的地址資訊
                )).toList();

SELECT
    t.`name` AS `value1`,
    t1.`addr` AS `value2` 
FROM
    `t_user` t 
LEFT JOIN
    `t_user_address` t1 
        ON t1.`user_id` = t.`id` 
WHERE
    t.`name` = '小明'

查詢使用者叫做小明的返回使用者的姓名地址和角色數量


    List<Draft3<String, String, Long>> userNameAndAddrAndRoleCount = easyEntityQuery.queryable(SysUser.class)
            .where(s -> {
                s.name().eq("小明");
            }).select(s -> Select.DRAFT.of(
                    s.name(),
                    s.address().addr(),
                    s.roles().count()//隱式子查詢返回使用者擁有的角色數量
            )).toList();
            
SELECT
    t.`name` AS `value1`,
    t1.`addr` AS `value2`,
    (SELECT
        COUNT(*) 
    FROM
        `t_role` t3 
    WHERE
        EXISTS (
            SELECT
                1 
            FROM
                `t_user_role` t4 
            WHERE
                t4.`role_id` = t3.`id` 
                AND t4.`user_id` = t.`id` LIMIT 1
        )
    ) AS `value3` 
FROM
    `t_user` t 
LEFT JOIN
    `t_user_address` t1 
        ON t1.`user_id` = t.`id` 
WHERE
    t.`name` = '小明'

案例2

查詢使用者下面存在角色是收貨員的使用者


        List<SysUser> 收貨員 = easyEntityQuery.queryable(SysUser.class)
                .where(s -> {
                    //篩選條件為角色集合裡面有角色名稱叫做收貨員的
                    s.roles().where(role -> {
                        role.name().eq("收貨員");
                    }).any();
                }).toList();

SELECT
    t.`id`,
    t.`name`,
    t.`create_time` 
FROM
    `t_user` t 
WHERE
    EXISTS (
        SELECT
            1 
        FROM
            `t_role` t1 
        WHERE
            EXISTS (
                SELECT
                    1 
                FROM
                    `t_user_role` t2 
                WHERE
                    t2.`role_id` = t1.`id` 
                    AND t2.`user_id` = t.`id` LIMIT 1
            ) 
            AND t1.`name` = '收貨員' LIMIT 1
        )

案例3

查詢使用者下面存在角色是XX員,並且存在個數大於5個的使用者,就是說需要滿足使用者下面的角色是xx員的起碼有5個及以上的


        List<SysUser> 收貨員 = easyEntityQuery.queryable(SysUser.class)
                .where(s -> {
                    //篩選條件為角色集合裡面有角色名稱叫做xx員的
                    s.roles().where(role -> {
                        role.name().likeMatchRight("員");
                    }).count().gt(5L);//count數量大於5個
                }).toList();


-- 第1條sql資料
SELECT
    t.`id`,
    t.`name`,
    t.`create_time` 
FROM
    `t_user` t 
WHERE
    (
        SELECT
            COUNT(*) 
        FROM
            `t_role` t1 
        WHERE
            EXISTS (
                SELECT
                    1 
                FROM
                    `t_user_role` t2 
                WHERE
                    t2.`role_id` = t1.`id` 
                    AND t2.`user_id` = t.`id` LIMIT 1
            ) 
            AND t1.`name` LIKE '%員'
        ) > 5

案例4

查詢使用者下面存在的任意角色不大於2022年建立的



LocalDateTime localDateTime = LocalDateTime.of(2022, 1, 1, 0, 0);
List<SysUser> 收貨員 = easyEntityQuery.queryable(SysUser.class)
        .where(s -> {
            //篩選條件為角色集合裡面有角色最大時間不能大於2022年的
            s.roles().max(role -> role.createTime()).lt(localDateTime);
        }).toList();

SELECT
    t.`id`,
    t.`name`,
    t.`create_time` 
FROM
    `t_user` t 
WHERE
    (
        SELECT
            MAX(t1.`create_time`) 
        FROM
            `t_role` t1 
        WHERE
            EXISTS (
                SELECT
                    1 
                FROM
                    `t_user_role` t2 
                WHERE
                    t2.`role_id` = t1.`id` 
                    AND t2.`user_id` = t.`id` LIMIT 1
            )
        ) < '2022-01-01 00:00'

案例5

查詢每個使用者和前3個最早建立的角色(支援分頁)適用於評論和評論子表前N個


        List<SysUser> 收貨員 = easyEntityQuery.queryable(SysUser.class)
                //前面的表示式表示要返回roles後面的表示如何返回返回按時間正序的3個
                .includes(s -> s.roles(),x->{
                    x.orderBy(r->r.createTime().asc()).limit(3);
                })
                .toList();

案例6

查詢使用者小明下面的選單


//方式1多次查詢
        List<SysMenu> menus = easyEntityQuery.queryable(SysUser.class)
                .where(s -> {
                    s.name().eq("小明");
                })
                .toList(x -> x.roles().flatElement().menus().flatElement());


//方式2一次次查詢
        List<SysMenu> menus = easyEntityQuery.queryable(SysMenu.class)
                .where(s -> {
                    //判斷選單下的角色存在角色的使用者叫做小明的
                    s.roles().any(role -> {
                        role.users().any(user -> {
                            user.name().eq("小明");
                        });
                    });
                }).toList();


-- 第1條sql資料
SELECT
    t.`id`,
    t.`name`,
    t.`route`,
    t.`icon` 
FROM
    `t_menu` t 
WHERE
    EXISTS (
        SELECT
            1 
        FROM
            `t_role` t1 
        WHERE
            EXISTS (
                SELECT
                    1 
                FROM
                    `t_role_menu` t2 
                WHERE
                    t2.`role_id` = t1.`id` 
                    AND t2.`menu_id` = t.`id` LIMIT 1
            ) 
            AND EXISTS (
                SELECT
                    1 
                FROM
                    `t_user` t3 
                WHERE
                    EXISTS (
                        SELECT
                            1 
                        FROM
                            `t_user_role` t4 
                        WHERE
                            t4.`user_id` = t3.`id` 
                            AND t4.`role_id` = t1.`id` LIMIT 1
                    ) 
                    AND t3.`name` = '小明' LIMIT 1
                ) LIMIT 1
        )

案例7

自動返回使用者和使用者下的角色和角色下的選單

首先透過idea外掛EasyQueryAssistant在指定目錄建立Struct DTO

最終會生成如下dto


/**
 * this file automatically generated by easy-query struct dto mapping
 * 當前檔案是easy-query自動生成的 結構化dto 對映
 * {@link com.easy.query.test.entity.blogtest.SysUser }
 *
 * @author easy-query
 */
@Data
public class UserRoleMenuDTO {


    private String id;
    private String name;
    @Navigate(value = RelationTypeEnum.ManyToMany)
    private List<InternalRoles> roles;


    /**
     * {@link com.easy.query.test.entity.blogtest.SysRole }
     */
    @Data
    public static class InternalRoles {
        private String id;
        private String name;
        @Navigate(value = RelationTypeEnum.ManyToMany)
        private List<InternalMenus> menus;


    }


    /**
     * {@link com.easy.query.test.entity.blogtest.SysMenu }
     */
    @Data
    public static class InternalMenus {
        private String id;
        private String name;
        private String route;
        private String icon;


    }

}

查詢selectAutoInclude


        List<UserRoleMenuDTO> menus = easyEntityQuery.queryable(SysUser.class)
                .where(u -> {
                    u.name().like("小明");
                    u.createTime().rangeClosed(LocalDateTime.now().plusDays(-100),LocalDateTime.now());
                })
                .selectAutoInclude(UserRoleMenuDTO.class)
                .toList();
//透過selectAutoInclude即可對映到我們的DTO 可以返回任意物件關係

最後

這邊展示了非常強大的OLTP查詢模式,OLAP也是非常強大可以group+join，實現from (匿名sql) 也可以join (匿名sql)

一款具有強型別OLTP+OLAP的完美解決方案,並且完美支援mybatis系列的任意架構逐步構建遷移,不會產生任何衝突,因為easy-query本身就是零依賴,並且完全免費,完全開源(包括文件！！！包括文件！！！包括文件！！！)

我相信easy-query是一款可以完完全全打動您的ORM作品,也是全java唯一一款全sql替代性產品

相關文章