通过postgresql的Ltree字段类型实现目录结构的基本操作

这篇具有很好参考价值的文章主要介绍了通过postgresql的Ltree字段类型实现目录结构的基本操作。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

通过postgresql的Ltree字段类型实现目录结构的基本操作

将这种具有目录结构的excel表存储到数据库中,可以采用树型结构存储通过postgresql的Ltree字段类型实现目录结构的基本操作,postgresql,数据库,Ltree,postgresql实现目录树

DROP TABLE IF EXISTS "public"."directory_tree";
CREATE TABLE "public"."directory_tree" (
  "id" varchar(100) COLLATE "pg_catalog"."default",
  "path" "public"."ltree",
  "name" varchar(100) COLLATE "pg_catalog"."default" NOT NULL,
  "description" text COLLATE "pg_catalog"."default",
  "updated_at" timestamp(6) DEFAULT now(),
  "created_at" timestamp(6) DEFAULT now()
)
;

-- ----------------------------
-- Records of directory_tree
-- ----------------------------
INSERT INTO "public"."directory_tree" VALUES ('04e19944aa1d3d8bc13971b4488a4e0d', '04e19944aa1d3d8bc13971b4488a4e0d', 'root', 'root', '2023-08-09 02:11:35.145821', '2023-08-09 02:11:35.145821');

上面是建一张表,并且插入一条根节点。这里我们的id是mybatisPuls提供的UUID,并且我们的path字段采用祖id+爷id+父id+子id的结构。这是处理excel表格的工具类

package com.cdcas.utils;

import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.*;

/**
 * @author jiao xn
 * @date 2023/4/20 22:44
 * @description
 */
@Component
public class ExcelUtil {
    /**
     * 根据文件地址,读取指定 Excel 文件的内容,并以对象数组的方式返回
     *
     * @param excelFilePath Excel 文件地址
     * @param sheetIndex 指定 Sheet 的索引值,从 0 开始
     * @param startLine 开始读取的行:从0开始
     * @param tailLine 去除最后读取的行
     * @return Excel 文件内容,对象数组
     */
    public List<Map<String, String>> readExcelFile(String excelFilePath, Integer sheetIndex, Integer startLine
            , Integer tailLine) {
        Workbook workbook = this.generateWorkbook(excelFilePath);
        return this.readExcelSheetToObject(workbook, sheetIndex, startLine, tailLine);
    }

    /**
     * 从 MultipartFile 中读取 Excel 文件的内容,并以对象数组的方式返回
     *
     * @param multipartFile MultipartFile 对象,一般是从前端接收
     * @param sheetIndex 指定 Sheet 的索引值,从 0 开始
     * @param startLine 开始读取的行:从0开始
     * @param tailLine 去除最后读取的行
     * @return Excel 文件内容,对象数组
     */
    public List<Map<String, String>> readExcelFile(MultipartFile multipartFile, Integer sheetIndex, Integer startLine
            , Integer tailLine) {
        Workbook workbook = this.generateWorkbook(multipartFile);
        return this.readExcelSheetToObject(workbook, sheetIndex, startLine, tailLine);
    }

    /**
     * 生成 Workbook 对象
     *
     * @param excelFilePath Excel 文件路径
     * @return Workbook 对象,允许为空
     */
    private Workbook generateWorkbook(String excelFilePath) {
        Workbook workbook;

        try {
            File excelFile = new File(excelFilePath);
            workbook = WorkbookFactory.create(excelFile);
        } catch (IOException | InvalidFormatException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

        return workbook;
    }
    /**
     * 生成 Workbook 对象
     *
     * @param multipartFile MultipartFile 对象
     * @return Workbook 对象
     */
    private Workbook generateWorkbook(MultipartFile multipartFile) {
        Workbook workbook;

        try {
            workbook = WorkbookFactory.create(multipartFile.getInputStream());
        } catch (IOException | InvalidFormatException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

        return workbook;
    }

    /**
     * 读取指定 Sheet 中的数据
     *
     * @param workbook Workbook 对象
     * @param sheetIndex 指定 Sheet 的索引值,从 0 开始
     * @param startLine 开始读取的行:从0开始
     * @param tailLine 去除最后读取的行
     * @return 指定 Sheet 的内容
     */
    private List<Map<String, String>> readExcelSheetToObject(Workbook workbook,
                                                             Integer sheetIndex, Integer startLine, Integer tailLine) {
        List<Map<String, String>> result = new ArrayList<>();

        Sheet sheet = workbook.getSheetAt(sheetIndex);

        // 获取第一行内容,作为标题内容
        Row titileRow = sheet.getRow(0);
        Map<String, String> titleContent = new LinkedHashMap<>();
        for (int i = 0; i < titileRow.getLastCellNum(); i++) {
            Cell cell = titileRow.getCell(i);
            titleContent.put(cell.getStringCellValue(), cell.getStringCellValue());
        }
        result.add(titleContent);

        // 获取正文内容
        Row row;
        for (Integer i = startLine; i < sheet.getLastRowNum() - tailLine + 1; i++) {
            row = sheet.getRow(i);
            Map<String, String> rowContent = new HashMap<>();

            for (Cell cell : row) {
                String returnStr;
                boolean isMergedCell  = this.isMergedCell(sheet, i, cell.getColumnIndex());

                if (isMergedCell) {
                    returnStr = this.getMergedRegionValue(sheet, row.getRowNum(), cell.getColumnIndex());
                } else {
                    returnStr = cell.getRichStringCellValue().getString();
                }

                rowContent.put(titileRow.getCell(cell.getColumnIndex()).getStringCellValue(), returnStr);
            }
            result.add(rowContent);
        }

        return result;
    }

    /**
     * 判断指定的单元格是否是合并单元格
     *
     * @param sheet Excel 指定的 Sheet 表
     * @param row 行下标
     * @param column 列下标
     * @return 是否为合并的单元格
     */
    private boolean isMergedCell(Sheet sheet, int row, int column) {
        int sheetMergeCount = sheet.getNumMergedRegions();
        for (int i = 0; i < sheetMergeCount; i++) {
            CellRangeAddress range = sheet.getMergedRegion(i);
            int firstColumn = range.getFirstColumn();
            int lastColumn = range.getLastColumn();
            int firstRow = range.getFirstRow();
            int lastRow = range.getLastRow();
            if(row >= firstRow && row <= lastRow && (column >= firstColumn && column <= lastColumn)){
                return true;
            }
        }
        return false;
    }

    /**
     * 获取合并单元格的值
     *
     * @param sheet 指定的值
     * @param row 行号
     * @param column 列好
     * @return 合并单元格的值
     */
    private String getMergedRegionValue(Sheet sheet, int row, int column){
        int sheetMergeCount = sheet.getNumMergedRegions();
        for(int i = 0 ; i < sheetMergeCount ; i++){
            CellRangeAddress ca = sheet.getMergedRegion(i);
            int firstColumn = ca.getFirstColumn();
            int lastColumn = ca.getLastColumn();
            int firstRow = ca.getFirstRow();
            int lastRow = ca.getLastRow();
            if(row >= firstRow && row <= lastRow && (column >= firstColumn && column <= lastColumn)) {
                Row fRow = sheet.getRow(firstRow);
                Cell fCell = fRow.getCell(firstColumn);
                return this.getCellValue(fCell) ;
            }
        }
        return null ;
    }

    /**
     * 获取单元格的值
     *
     * @param cell Cell 对象
     * @return 单元格的值
     */
    private String getCellValue(Cell cell){
        if(cell == null) {
            return "";
        }

        if(cell.getCellTypeEnum() == CellType.STRING){
            return cell.getStringCellValue();
        } else if(cell.getCellTypeEnum() == CellType.BOOLEAN){
            return String.valueOf(cell.getBooleanCellValue());
        } else if(cell.getCellTypeEnum() == CellType.FORMULA){
            return cell.getCellFormula() ;
        } else if(cell.getCellTypeEnum() == CellType.NUMERIC){
            return String.valueOf(cell.getNumericCellValue());
        }

        return "";
    }
}

下面是将生成的List<Map<String, String>> excel数据插入到excel表中的工具类

package com.cdcas;

import com.cdcas.mapper.DirectoryTreeMapper;
import com.cdcas.pojo.DirectoryTree;
import com.cdcas.utils.ExcelDataUtil;
import com.cdcas.utils.ExcelUtil;
import org.junit.jupiter.api.Test;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.CollectionUtils;

import java.io.FileInputStream;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

/**
 * @version 1.0
 * @Author zhaozhixin
 * @Date 2023/8/7 15:01
 * @注释
 */   //983
@SpringBootTest
public class Test2 {

    /**
     * 替换和插入
     *
     * @param parentPath
     * @param directoryTree
     */
    private String Insert(String parentPath, DirectoryTree directoryTree, String name) {
        directoryTree.setName(name);
        directoryTree.setDescription(parentPath);
        directoryTreeMapper.insert(directoryTree);
        directoryTree.setPath(parentPath + "." + directoryTree.getId());
        directoryTreeMapper.updateDirectoryTree(directoryTree);
        return directoryTree.getId();
    }

    /**
     * 通过名称查询父路径
     *
     * @param name
     * @return
     */
    private String getParentPathByName(String name) {
        DirectoryTree parent = directoryTreeMapper.getOneByName(name);
        return parent.getPath();
    }

    @Test
    public void get() {
        String path = directoryTreeMapper.getPath(1);
        System.out.println(path);
    }

    @Autowired
    private ExcelUtil excelUtil;

    @Autowired
    private ExcelDataUtil excelDataUtil;
    @Autowired
    private DirectoryTreeMapper directoryTreeMapper;

    @Test
    public void insert() throws Exception {
        //读取一个excel
        List<Map<String, String>> maps = excelUtil.readExcelFile("C:\\Users\\20745\\Desktop\\git库\\gitee\\pg-demo-itree\\src\\main\\resources\\国土规划目录树.xlsx", 0, 1, 0);
        maps.remove(0);
        System.out.println(maps);
        for (Map<String, String> map : maps) {
            String A1 = map.get("A1");
            String A2 = map.get("A2");
            String A3 = map.get("A3");
            String A4 = map.get("A4");
            String A5 = map.get("A5");
            String A6 = map.get("A6");
            String A7 = map.get("A7");
            String A8 = map.get("A8");
            String A9 = map.get("A9");
            StringBuilder parentPath = new StringBuilder();//用来拼接父节点id
            parentPath.append("04e19944aa1d3d8bc13971b4488a4e0d");//这是根节点id
            if (A1 != null && !"".equals(A1)) {
                    //二级节点  根节点为root
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A1;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){

                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A2 != null && !"".equals(A2)) {
                    //拿到所有同名的行
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A2;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A3 != null && !"".equals(A3)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A3;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A4 != null && !"".equals(A4)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A4;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A5 != null && !"".equals(A5)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A5;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A6 != null && !"".equals(A6)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A6;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A7 != null && !"".equals(A7)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A7;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
            if (A8 != null && !"".equals(A8)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A8;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
                }
            if (A9 != null && !"".equals(A9)) {
                    DirectoryTree directoryTree = new DirectoryTree();
                    String name = A9;
                    String id = isExtis(name, directoryTree, parentPath.toString());
                    if (id==null){
                    }else {
                        parentPath.append(".").append(id);
                    }
            }
        }
    }

    /**
     * 判断一个同名的是否存在在其它数 返回当前节点id
     * @param name
     * @param directoryTree
     * @param parentPath
     */
    private String isExtis(String name,DirectoryTree directoryTree,String parentPath){
        //最终标识  开始表明不存在
        boolean isExtis = false;
        //获取到所有的和name同名的行
        List<DirectoryTree> oneByNames = directoryTreeMapper.getListByName(name);
        //如果没有同名的直接插入
        if (CollectionUtils.isEmpty(oneByNames)){
            directoryTree.setName(name);
            directoryTree.setDescription(parentPath);
            directoryTreeMapper.insert(directoryTree);
            directoryTree.setPath(parentPath+"."+directoryTree.getId());
            directoryTreeMapper.updateDirectoryTree(directoryTree);
            return directoryTree.getId();
        }
        //如果有同名的,需要判断父路径是否相同
        String path = "";
        int lastIndexOf = 0;
        for (DirectoryTree oneByName : oneByNames) {
            if (oneByName!=null) {
                path = oneByName.getPath();
                lastIndexOf = path.lastIndexOf(".");
            }
            //重复的数据应该也要被插入进去  查出的父路径传入的父路径进行对比
            if (path.substring(0,lastIndexOf).equals(parentPath)){
                isExtis = true;
            }
        }
        //最后如果同名的数据但是父路径不相同,就需要插入进去
        if (!isExtis){
                directoryTree.setName(name);
                directoryTree.setDescription(parentPath);
                directoryTreeMapper.insert(directoryTree);
                directoryTree.setPath(parentPath+"."+directoryTree.getId());
                directoryTreeMapper.updateDirectoryTree(directoryTree);
            return directoryTree.getId();
        }
        return oneByNames.get(oneByNames.size()-1).getId();
    }
    //查看重复条数和 总条数
    @Test
    public void look() throws Exception {
        FileInputStream fileInputStream = new FileInputStream("C:\\Users\\20745\\Desktop\\git库\\gitee\\pg-demo-itree\\src\\main\\resources\\国土规划目录树.xlsx");
        List<Map<String, String>> maps = excelDataUtil.readExcel(fileInputStream);

        int count = 0;
        HashSet<String> set = new HashSet();
        for (Map<String, String> map : maps) {
            if (StringUtils.isNotBlank(map.get("A1"))) {
                set.add(map.get("A1"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A2"))) {
                set.add(map.get("A2"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A3"))) {
                set.add(map.get("A3"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A4"))) {
                set.add(map.get("A4"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A5"))) {
                set.add(map.get("A5"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A6"))) {
                set.add(map.get("A6"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A7"))) {
                set.add(map.get("A7"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A8"))) {
                set.add(map.get("A8"));
                count++;
            }
            if (StringUtils.isNotBlank(map.get("A9"))) {
                set.add(map.get("A9"));
                count++;
            }
        }
        System.out.println(count);
        System.out.println(set.size());
    }
}

最后插入的数据大概是这样通过postgresql的Ltree字段类型实现目录结构的基本操作,postgresql,数据库,Ltree,postgresql实现目录树

注意这里的path!!!!!是id拼起来的具有目录层次的!!通过postgresql的Ltree字段类型实现目录结构的基本操作,postgresql,数据库,Ltree,postgresql实现目录树

这些关于目录树的基本操作,楼主写了一个小demo放在gitee上面了。本人不会算法,里面写的很菜见谅哈哈。喜欢的点个赞谢谢<.>! gitee地址:pg-demo-itree: 基于postgresql的Itree功能实现目录树的操作 (gitee.com)文章来源地址https://www.toymoban.com/news/detail-656097.html

到了这里,关于通过postgresql的Ltree字段类型实现目录结构的基本操作的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 包含引用类型字段的自定义结构体,能作为map的key吗

    在 Go 语言中, map 是一种内置的数据类型,它提供了一种高效的方式来存储和检索数据。 map 是一种无序的键值对集合,其中每个键与一个值相关联。使用 map 数据结构可以快速地根据键找到对应的值,而无需遍历整个集合。 在 Go 语言中, map 是一种内置的数据类型,可以通

    2024年02月07日
    浏览(39)
  • Spark—通过Java、Scala API实现WordCount案例的基本操作

    实验原理 Spark的核心就是RDD,所有在RDD上的操作会被运行在Cluster上,Driver程序启动很多Workers,Workers在(分布式)文件系统中读取数据后转化为RDD(弹性分布式数据集),然后对RDD在内存中进行缓存和计算。 而RDD有两种类型的操作 ,分别是Action(返回values)和Transformations(

    2024年02月15日
    浏览(40)
  • 数据结构——单链表基本操作实现 (c++)

    单链表链式存储结构的特点是:用一组任意的存储单元存储线性表的数据元素(这里存储单元可以是连续的,也可以是不连续的),为了表示每个数据元素a与其直接后继数据元素之间的逻辑关系,除了存储信息本身外还要存储一个指示其直接后继的信息(地址). 这两部分信

    2024年02月03日
    浏览(62)
  • 数据结构——单链表上基本操作的实现

    1.按位序插入(带头结点) : ==ListInsert(L, i, e): ==在表L 中的第 i 个位置上插入指定元素 e = 找到第 i-1 个结点 ( 前驱结点 ) ,将新结点 插入其后;其中头结点可以看作第 0 个结点,故 i=1 时也适用。 typedef struct LNode{ ElemType data; struct LNode *next; }LNode, *LinkList; // 在第 i 个位置插入

    2024年01月21日
    浏览(54)
  • 【数据结构】队列基本操作的实现(C语言)

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🐌 个人主页:蜗牛牛啊 🔥 系列专栏:🛹数据结构、🛴C++ 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与

    2024年02月16日
    浏览(48)
  • 数据结构:二叉树的基本操作(用递归实现)

             本文将通过完成以下内容来展示二叉树的基本操作,代码解释标注全面而且清晰,代码书写也十分规范,适合初学者进行学习,本篇文章算是本人的一些学习记录分享,希望对有需要的小伙伴提供一些帮助~ 本文的内容为: 用递归的方法实现以下算法: 1.以二叉

    2024年02月06日
    浏览(49)
  • 【数据结构】二叉树的构建与基本操作实现

    👀 樊梓慕: 个人主页   🎥 个人专栏: 《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》 🌝 每一个不曾起舞的日子,都是对生命的辜负 目录 前言 1.前序建立二叉树 2.销毁二叉树 3.统计 4.查找值为x的节点 5.前中后序遍历 6.层序遍历 7.判断二叉树是否

    2024年02月07日
    浏览(43)
  • 【数据结构】顺序表基本操作的实现(C语言)

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🐌 个人主页:蜗牛牛啊 🔥 系列专栏:🛹数据结构、🛴C++ 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与

    2024年02月16日
    浏览(53)
  • 数据结构教程实验一顺序表基本操作的实现

    1.掌握线性表的顺序存贮结构及基本操作,深入了解顺序表的基本特性,以便在实际问题背景下灵活运用它们。 2.深入理解和灵活掌握顺序表的插入、删除等操作。 1.硬件:每个学生需配备计算机一台。 2.软件:Windows操作系统+Visual C++。     1.将建表、遍历、插入、删除分别

    2024年02月07日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包