精华内容
下载资源
问答
  • mysql 树形结构查询

    2014-04-29 16:20:37
    mysql 树形结构查询,使用存储过程,实现mysql的树形结构查询
  • java中 遍历mysql中的树形结构
  • mysql如何实现树状结构数据列表

    万次阅读 2020-11-04 17:04:18
    1.数据库设计 CREATE TABLE `expense_type` ( `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '费用类型唯一主键ID', `NAME` varchar(100) DEFAULT NULL COMMENT '费用...查询出来的结构即为树状结构(理论上无穷级数)

    1.数据库设计

    CREATE TABLE `expense_type` (
      `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '费用类型唯一主键ID',
      `NAME` varchar(100) DEFAULT NULL COMMENT '费用类型名称',
      `PID` int(11) DEFAULT NULL,
      `IS_DEL` varchar(20) DEFAULT '0' COMMENT '0为未删除,1为已删除,默认为0',
      PRIMARY KEY (`ID`) USING BTREE,
      KEY `isDel` (`IS_DEL`) USING BTREE COMMENT '假删除字段索引'
    ) ENGINE=InnoDB AUTO_INCREMENT=92 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
    

    2.service层代码

    @Override
        public RestResponse getAllExpenseType() {
            List<ExpenseType> expenseTypes = expenseTypeMapper.selectList();//查询此表的所有数据sql即可
            expenseTypes = generateTree(expenseTypes);
            return RestResponse.success(expenseTypes);
        }
    
       
        private List<ExpenseType> generateTree(List<ExpenseType> expenseTypeList) {
            List<ExpenseType> orgList = new ArrayList<>();
            for (ExpenseType sysMenu : expenseTypeList) {
                if (sysMenu.getPid() == null) {
                    orgList.add(sysMenu);
                    addSubs(sysMenu, expenseTypeList);
                }
            }
            return orgList;
        }
    
        private ExpenseType addSubs(ExpenseType org, List<ExpenseType> list) {
            for (ExpenseType sysOrg : list) {
                if (org.getId().equals(sysOrg.getPid())) {
                    org.getSubs().add(addSubs(sysOrg, list));
                }
            }
            return org;
        }
    

    3.查询出来的结构即为树状结构(理论上无穷级数)

    展开全文
  • mysql 递归查询 树型结构 代码逻辑
  • 1.支持根据子级 查询到 其所有父级 2.支持根据父级分页 1.创建存储函数 # 根据父级查所有子级 CREATE FUNCTION `queryChildrensId`(orgid char(255)) RETURNS varchar(4000) CHARSET utf8 BEGIN DECLARE oTemp ...

    1.支持根据子级 查询到 其所有父级
    2.支持根据父级查询到所有子级
    2.支持根据父级分页

    1.创建存储函数

    # 根据父级查所有子级
    CREATE  FUNCTION `queryChildrensId`(orgid char(255)) RETURNS varchar(4000) CHARSET utf8
    BEGIN
    DECLARE oTemp VARCHAR(4000);
    DECLARE oTempChild VARCHAR(4000);
     
    SET oTemp = '';
    SET oTempChild = orgid;
     
    WHILE oTempChild IS NOT NULL
    DO
    SET oTemp = CONCAT(oTemp,',',oTempChild);
    SELECT GROUP_CONCAT(pro_id) INTO oTempChild FROM pro_project_info WHERE FIND_IN_SET(parent_id,oTempChild) > 0 and status != -1;
    END WHILE;
    RETURN oTemp;
    END
    
    # 根据子级查询所有父级
    CREATE DEFINER=`company-manage`@`%` FUNCTION `queryParentsId`(rootId varchar(100)) RETURNS varchar(1000) CHARSET latin1
    BEGIN   
    DECLARE fid varchar(100) default '';   
    DECLARE str varchar(1000) default rootId;   
      
    WHILE rootId is not null  do   
        SET fid =(SELECT parent_id FROM pro_project_info WHERE pro_id = rootId);   
        IF fid is not null and fid != -1 THEN   
            SET str = concat(str, ',', fid);   
            SET rootId = fid;   
        ELSE   
            SET rootId = fid;   
        END IF;   
    END WHILE;   
    return str;  
    END
    

    2.sql

    SELECT
    	a.*
    FROM
    	pro_project_info a
    	JOIN (
    SELECT
    	a.pid,
    	GROUP_CONCAT( a.pids ) pids 
    FROM
    	(
    SELECT
    	a.*,
    	concat( queryParentsId ( a.pro_id ), queryChildrensId ( a.pro_id ) ) pids,
    	SUBSTRING_INDEX( queryParentsId ( a.pro_id ), ',', - 1 ) pid 
    FROM
    	pro_project_info a 
    WHERE
    	a.STATUS != - 1 
    	) a 
    WHERE
    	a.pid IN ( SELECT pro_id FROM pro_project_info WHERE STATUS != - 1 AND parent_id = - 1 ORDER BY update_time DESC ) 
    GROUP BY
    	a.pid 
    ORDER BY
    	a.update_time DESC 
    	LIMIT 0,
    	10 
    	) d ON FIND_IN_SET( a.pro_id, d.pids ) 
    GROUP BY
    	a.pro_id 
    ORDER BY
    	a.update_time DESC;
    

    3.将结果封装成树形数据

     /**
         * - listToTree
         * - <p>方法说明<p>
         * - 将JSONArray数组转为树状结构
         * - @param arr 需要转化的数据
         * - @param id 数据唯一的标识键值
         * - @param pid 父id唯一标识键值
         * - @param child 子节点键值
         * - @return JSONArray
         */
        public static JSONArray listToTree(JSONArray arr, String id, String pid, String child) {
            JSONArray r = new JSONArray();
            JSONObject hash = new JSONObject();
            //将数组转为Object的形式,key为数组中的id
            for (int i = 0; i < arr.size(); i++) {
                JSONObject json = (JSONObject) arr.get(i);
                hash.put(json.getString(id), json);
            }
            //遍历结果集
            for (int j = 0; j < arr.size(); j++) {
                //单条记录
                JSONObject aVal = (JSONObject) arr.get(j);
                //在hash中取出key为单条记录中pid的值
                JSONObject hashVP = (JSONObject) hash.get(aVal.get(pid).toString());
                //如果记录的pid存在,则说明它有父节点,将她添加到孩子节点的集合中
                if (hashVP != null) {
                    //检查是否有child属性
                    if (hashVP.get(child) != null) {
                        JSONArray ch = (JSONArray) hashVP.get(child);
                        ch.add(aVal);
                        hashVP.put(child, ch);
                    } else {
                        JSONArray ch = new JSONArray();
                        ch.add(aVal);
                        hashVP.put(child, ch);
                    }
                } else {
                    r.add(aVal);
                }
            }
            return r;
        }
    
    展开全文
  • 对于数据库中的树形结构数据,如部门表,有时候,我们需要知道某部门的所有下属部分或者某部分的所有上级部门,这时候就需要用到mysql的递归查询 最近在做项目迁移,Oracle版本的迁到Mysql版本,遇到有些oracle的...
  • 树列表查询JAVA+MYSQL

    千次阅读 2020-01-15 16:57:04
    使用sql将根节点下所有子节点都查询出来返回给Java端,只根据parentId查询,没有Level等级的需求 select node_id,parent_id,ischild from ( select t1.node_id, parent_id, if(find_in_set(parent_id, @pids) ...

    项目中用到的服务器返回给前端树列表代码实现

    使用sql将根节点下所有子节点都查询出来返回给Java端,只根据parentId查询,没有Level等级的需求

    select node_id,parent_id,ischild from 
    (
    	select 
    	t1.node_id,
    	parent_id,
        if(find_in_set(parent_id, @pids) > 0, @pids := concat(@pids,',',node_id), 'not found') as ischild
    				from (select t.node_id,t.parent_id from t_rbac_node t order by parent_id, node_id) t1, 
        (select @pids := 10 id) t2							
    )t3 
    where ischild != 'not found'
    union all 
    #连上根节点自己
    select node_id,parent_id,null from t_rbac_node where node_id=10
    

    java代码使用递归的方法将数据库返回的数据组装成tree

    @Override
        public NodeTreeVO getNodeTree(Integer parentId,int[] level) throws Exception {
            Map<String,Object> paramMap=new HashMap<String,Object>();
            paramMap.put("parentId",parentId);
            paramMap.put("level",level);
            List<NodeTreeVO> nodeRoleRespVOS = nodeDOMapper.selectNodeTree(paramMap);
            return getNodeTree(nodeRoleRespVOS,parentId);
        }
    
    
        /**
         * @Description 组装结果
         * @author xpWang
         * @date 2020/1/15 16:52
         */
        private NodeTreeVO getNodeTree(List<NodeTreeVO> dblist,Integer parentId){
            List<NodeTreeVO> result=new ArrayList<NodeTreeVO>();
            NodeTreeVO root=null;
            //获取根节点
            int index=0;
            for(;index<dblist.size();index++){
                if (parentId==dblist.get(index).getNodeId()){
                    root=dblist.get(index);
                    break;
                }
            }
            if (root==null){
                return null;
            }
            dblist.remove(index);
            result.add(root);
            getNodeTree(result,dblist);
            return root;
        }
    
        /**
         * @Description 将dblist里面的数据插入到resultlist下,递归调用
         * @author xpWang
         * @date 2020/1/15 16:53
         */
        public List<NodeTreeVO> getNodeTree(List<NodeTreeVO> result,List<NodeTreeVO> dblist){
            for(NodeTreeVO node:result){
                for (int i=0;i<dblist.size();i++){
                    NodeTreeVO nodeTreeVO=dblist.get(i);
                    if (dblist.get(i).getParentId()==node.getNodeId()){
                        node.addNode(dblist.get(i));
                        dblist.remove(i);
                        i--;
                    }
                }
                getNodeTree(node.getChildren(),dblist);
            }
            return result;
        }
    

    返回给前端的DTO

    @Data
    public class NodeTreeVO extends NodeDO {
        private List<NodeTreeVO> children=new ArrayList<NodeTreeVO>();
        public void addNode(NodeTreeVO node){
            children.add(node);
        }
    }
    
    展开全文
  • 把字母表示的图状数据结构转换为树状数据结构 采用DefaultMutableTreeNode类的方式建立一个图状数据结构,顶点为字母A、B、C等,你也可以自己设计。可以帮助你把一个复杂的网状关系变成一个条理化的树状关系,并通过...
  • 主要给大家介绍了关于利用java+mysql递归实现拼接树形JSON列表的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面跟着小编来一起看看吧。
  • 做项目时,遇到这样一个业务,需要将某个数据库表中的基本数据转化为树形结构返回给前端(基础数据中分为三级:主线、一级、二级),这些数据在存储时分别存储了父级数据的id,并且每一级又分两个主线。 我的做法是...

    一、说明:

    做项目时,遇到这样一个业务,需要将某个数据库表中的基本数据转化为树形结构返回给前端(基础数据中分为三级:主线、一级、二级),这些数据在存储时分别存储了父级数据的id,并且每一级又分两个主线。
    我的做法是按照需求将数据查出,然后在后端利用递归进行树形结构转换。

    数据库表结构:

    在这里插入图片描述

    前端返回数据

    public class ProjectLineModel {
    
        /**
         * 主线id
         */
        @ApiModelProperty(value = "主线id")
        private String lineid;
    
    
        /**
         * 主线名称
         */
        @ApiModelProperty(value = "主线名称")
        private String lineName;
    
    
        /**
         * 一级项目(主线中嵌套一级项目model)
         */
        @Transient
        private List<ProjectOneModel> listOne;
    
    
    }
    
    
    public class ProjectOneModel {
    
        /**
         * 项目id
         */
        @ApiModelProperty(value = "项目id")
        @Column(name = "id")
        private String projectId;
    
        /**
         * 项目名称
         */
        @ApiModelProperty(value = "项目名称")
        private String projectName;
    
        /**
         * 父级id
         */
        @ApiModelProperty(value = "父级id")
        private String parent;
    
    
        /**
         * 项目级别
         */
        @ApiModelProperty(value = "项目级别")
        private int level;
    
        /**
         * 优先级
         */
        @ApiModelProperty(value = "优先级")
        private int priority;
    
        /**
         * 下一级级项目(一级项目嵌套二级项目、但由于一二级项目的model相同这里就用了一个)
         */
        @Transient
        private List<ProjectOneModel> listNext;
    
    }
    

    二、解决方法

    service代码

    实现方法:

     public  List<ProjectLineModel>  selectAllProject(int pageNo, int pageSize) {
    
    //      实例化树形结构
      List<ProjectLineModel> lineModelList;
    
    //       查询主线
       List<ProjectLineModel> lineProject = participationDao.selectLineProject(0);
    //       查询一二级项目
       List<ProjectOneModel> oneAndTwoProject = participationDao.selectOneAndTwoProject();
    
    //       遍历主线,添加主线model中list的内容(应用java8新特性 流)
       lineModelList=lineProject.stream()
               .map(line -> line.setListOne(setChildProject(line.getLineid(),oneAndTwoProject)))
               .collect(Collectors.toList());
               
      return lineModelList;
     }
    
    

    递归方法:

     /**
      * 递归方法实现树形结构
      * @param ParentId  父级项目id
      * @param oneAndTwoProject   所有一二级项目
      * @return
      */
     public List<ProjectOneModel> setChildProject(String ParentId, List<ProjectOneModel> oneAndTwoProject) {
    
    //      定义一级项目model
      List<ProjectOneModel> ProjectList1 = new ArrayList<>();
    
    //      为一级项目添加内容
      ProjectList1= oneAndTwoProject.stream()
              .filter(pro -> pro.getParent().equals(ParentId))
              .collect(Collectors.toList());
    
      if (ProjectList1.size() == 0) {
       return null;
      }
      //      为二级项目添加内容,添加一级项目中list的内容
      ProjectList1.stream()
              .map(child ->child.setListNext(setChildProject(child.getProjectId(), oneAndTwoProject)))
              .collect(Collectors.toList());
    
      return ProjectList1;
    

    结果:

    {
      "code": "0000",
      "message": "查询成功",
      "data": [
        {
          "lineid": "1137190657425674241",
          "lineName": "计算机",
          "listOne": [
            {
              "projectId": "1147028439530016771",
              "projectName": "入门",
              "parent": "1137190657425674241",
              "level": 1,
              "priority": 0,
              "listNext": [
                {
                  "projectId": "1151648863681298433",
                  "projectName": "开学典礼",
                  "parent": "1147028439530016771",
                  "level": 2,
                  "priority": 0
                },
                {
                  "projectId": "1151648863886819329",
                  "projectName": "快捷键和搜索引擎使用",
                  "parent": "1147028439530016771",
                  "level": 2,
                  "priority": 1
                },
                {
                  "projectId": "1151648864042008578",
                  "projectName": "进制的转换、计算机组成原理、三八译码器",
                  "parent": "1147028439530016771",
                  "level": 2,
                  "priority": 3
                },,,,,,,,
               
    
    展开全文
  • Java 类目树形结构查询1. 初始化数据库1.1 类目表初始化2. 构建项目2.1 项目结构2.2 代码文件...
  • java 处理mysql获取树形的数据 目录 处理一: 使用对象的方式 TreeModel TreeModelList ... Mysql 是没办法用oracle的connect by prior了,直接数据库进行查询,因此考虑用java递归遍历,获取到树形的数据..
  • Mysql快速实现递归树状查询 【前言】今天一个好朋友问我的这个问题,以前也没有用到过,恰好有时间,就帮他研究了一下,纯属“现学现卖”,正好在过程中,自己也能学习一下!个人感觉,其实一点也不难,不过是“闻...
  • 1.查询计划 2.分析计划 连接类型 三:索引的使用与选择 1.索引的使用以及优化 (1) MYSQL中的索引原理 (2) 4中树结构在索引中的应用(附红黑树) 2、树结构选择合适的索引。 3、mysql中建立索引的规范 4、...
  • java结构的层级查询

    2021-02-07 17:36:29
    最近在做项目的过程中,需要做一个分类,设计出来的表结构查询层级的时候只需要用到父级id,也就是这个分类的上层分类,设计出来的分类层级是不限定级数的,也就是说可能有123456级。 规定一级的父id为0,二级为...
  • 父子结构的excel(java)导入数据库,页面上展示成树状结构 excel数据结构 java代码 Controller层 我这里传入的参数除了文件,有一个id,id为页面上的目录上的一个节点id,可理解为我导入的目录实在某一个节点下展现...
  • ztree树形结构+mysql完整,包含完整的数据库表以及点击事件
  • springboot + mybatis plus + mysql 树形结构查询 背景 实际开发过程中经常需要查询节点树,根据指定节点获取子节点列表,以下记录了获取节点树的操作,以备不时之需。 使用场景 可以用于系统部门组织机构、商品分类、...
  • 众所周知mysql没有oracle 的递归查询,如果Java代码中查询的话。列表页几十条数据。在每个节点层数不定时,其实时间都花费在数据库的连接上。 又不想mysql增加自定义函数(个人觉得不利于数据迁移)。所以学习了...
  • Java递归实现树状结构

    千次阅读 2016-10-07 15:00:16
    只是简单实现树状结构,后续进行补充。package com.tree.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql....
  • mysql中递归树状结构

    2011-10-10 17:20:36
    java"] 在Oracle 中我们知道有一个 Hierarchical Queries 通过CONNECT BY 我们可以方便的查了所有当前节点下的所有子节点。但很遗憾,在MySQL的目前版本中还没有对应的功能。 在MySQL中如果是有限的...
  • SELECT id, code, name, parent_id FROM ( SELECT t1.id, t1.parent_id, t1.name, t1.code, IF ( find_in_set(parent_id, @pids) > 0, @pids := concat(@pids, ','...OR code = '10045'
  • 查询数据库树形结构数据并构造成树形数据 @author DENG @param parameMap @return 返回值 */ private List queryMenuData(Map, Object> parameMap) { // 查询顶级数据 List<RespMenuScoreDto> ...
  • Java树形结构

    万次阅读 2017-12-23 20:00:30
    mysql取表结构java树形结构,递归
  • 基于这个认知,我决定每一层的数都用一条SQL,然后查询结果用JAVA循环来构造树形结构。 还是层高为2的树形结构为例子,构造过程如下: 1、select * from xx where parent_id=0; //查询出父节点..
  • 崇德易城市数据
  • 如下mysql查询函数即可实现根据一个节点查询所有的子节点,根据一个子节点查询所有的父节点。对于数据量较大的时候(我这里测试的1万条左右)。查询效率非常慢。建议在java代码中进行处理。 CREATE FUNCTION `...
  • java-List数据封装成树状结构

    千次阅读 2019-01-31 17:44:32
    关于怎么样将List数据封装成树状结构,在网上非常多的文章,我自己也写了一个小方法,在这里做下笔记,方便自己以后查看。 package com.su.mybatis.mysql.controller; import java.util.ArrayList; import java....
  • 这篇博文来讨论一下在mysql中运用树形结构进行设计,并进行查询的方式 背景 最近在做公司的一个工业相关的项目,其中有一个需求,做一个BOM(Bill of Material 物料清单)的实现。关于BOM这里不做过多解释,大家自行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,571
精华内容 1,828
关键字:

java树状结构查询mysql

java 订阅
mysql 订阅