导入数据到neo4j

于 2024-04-22 08:33:13 发布
阅读量153 收藏
点赞数 3
分类专栏： 大数据/neo4j 文章标签： neo4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65099052/article/details/138057915
版权

title: 导入数据到neo4j
date: 2023-10-08 13:35:49
categories:

  • 大数据技术
    tags:

代码

package neo4j;

import org.neo4j.driver.v1.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;


public class Neo4jDataImport {
    public static void main(String[] args) {
        try (Driver driver = GraphDatabase.driver( "bolt://localhost:7687", AuthTokens.basic( "neo4j", "123456" ) )) {
            // 读取数据集并创建节点
            try (Session session = driver.session()) {
                String csvFile = "input/data_low.csv"; // 数据集文件路径

                //区域
                Set<String> uniqueAddresses = new HashSet<>();
                //房屋布局
                Set<String> uniqueLayouts = new HashSet<>();
                //建筑风格
                Set<String> uniqueBuildingTypes = new HashSet<>();
                // 朝向
                Set<String> uniqueOrientations = new HashSet<>();
                //装修风格
                Set<String> uniqueDecorations = new HashSet<>();
             // 获取电梯数量，去重
                Set<String> uniqueElevatorCounts = new HashSet<>();
             // 获取供暖方式，去重
                Set<String> uniqueHeatingMethods = new HashSet<>();
             // 获取房屋用途，去重
                Set<String> uniqueHouseUses = new HashSet<>();
             // 获取房屋产权，去重
                Set<String> uniquePropertyOwnerships = new HashSet<>();
             // 获取楼层描述，去重
                Set<String> uniqueFloorDescriptions = new HashSet<>();
             // 获取总楼层，去重
                Set<Integer> uniqueTotalFloors = new HashSet<>();
             // 获取总价格，去重
                Set<Double> uniqueTotalPrices = new HashSet<>();
             // 获取单价，去重
                Set<Double> uniqueUnitPrices = new HashSet<>();

                
                


                try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
                    String line;
                    while ((line = br.readLine()) != null) {
                        String[] data = line.split(","); // 假定CSV文件使用逗号分隔

                        // 获取房屋地址，去重
                        String address = data[1];
                        uniqueAddresses.add(address);
                        
                        // 获取房屋布局，去重
                        String layout = data[4].trim(); // 去除空格
                        uniqueLayouts.add(layout);
                        
                        // 获取建筑类型，去重
                        String buildingType = data[6].trim(); // 去除空格
                        uniqueBuildingTypes.add(buildingType);
                        
                        // 获取朝向，去重
                        String orientation = data[7].trim(); // 去除空格
                        uniqueOrientations.add(orientation);
                        
                        // 获取装修风格，去重
                        String decoration = data[8].trim(); // 去除空格
                        uniqueDecorations.add(decoration);
                        
                        // 获取电梯数量，去重
                        String elevatorCount = data[9].trim(); // 去除空格
                        uniqueElevatorCounts.add(elevatorCount);
                        
                         // 获取供暖方式，去重
                        String heatingMethod = data[10].trim(); // 去除空格
                        uniqueHeatingMethods.add(heatingMethod);
                        // 获取房屋用途，去重
                        String houseUse = data[11].trim(); // 去除空格
                        uniqueHouseUses.add(houseUse);
                        
                     // 获取房屋产权，去重
                        String propertyOwnership = data[12].trim(); // 去除空格
                        uniquePropertyOwnerships.add(propertyOwnership);
                        
                        // 获取楼层描述，去重
                        String floorDescription = data[13].trim(); // 去除空格
                        uniqueFloorDescriptions.add(floorDescription);
                        
                        // 获取总楼层，需要将字符串转为整数类型，去重
                        try {
                            int totalFloors = Integer.parseInt(data[14].trim()); // 去除空格并转为整数
                            uniqueTotalFloors.add(totalFloors);
                        } catch (NumberFormatException e) {
                            // 处理无效的整数值
                            // 可以选择跳过或进行其他处理
                            // 跳过无效值并记录日志
                            System.err.println("Invalid total floors value: " + data[14].trim() + " at line: " + line);
                            continue;
                        }
                                         

                     // 获取总价格，需要将字符串转为双精度类型，去重
                        try {
                            double totalPrice = Double.parseDouble(data[2].trim()); // 去除空格并转为双精度
                            uniqueTotalPrices.add(totalPrice);
                            double unitPrice = Double.parseDouble(data[3].trim()); // 去除空格并转为双精度
                            uniqueUnitPrices.add(unitPrice);
                        } catch (NumberFormatException e) {
                            // 处理无效的双精度值
                            // 可以选择跳过或进行其他处理
                            // 例如：记录日志、设置默认值或报告无效值
                            // 在这个示例中，我们将无效值设置为0.0
                            System.err.println("Invalid total price value: " + data[2]);
                            System.err.println("Invalid unit price value: " + data[3]);
                            uniqueTotalPrices.add(0.0); // 设置默认值
                            uniqueUnitPrices.add(0.0);
                        }



                     // 创建房屋节点
                        session.writeTransaction(new TransactionWork<Void>() {
                            @Override
                            public Void execute(Transaction tx) {
                                double price = 0.0; // 默认价格，可以根据需要修改默认值
                                double unitPrice = 0.0; // 默认单价，可以根据需要修改默认值
                                
                                try {
                                    price = Double.parseDouble(data[2]); // 尝试将价格字段转为双精度类型
                                    unitPrice = Double.parseDouble(data[3]);
                                } catch (NumberFormatException e) {
                                    System.err.println("Invalid price value: " + data[2]);
                                    System.err.println("Invalid unitPrice value: " + data[3]);
                                }

                                tx.run("CREATE (house:House { id: $id, address: $address, price: $price, unit_price: $unitPrice, layout: $layout, " +
                                        "rental_area: $rentalArea, building_type: $buildingType, orientation: $orientation, decoration: $decoration, " +
                                        "elevator_style: $elevatorCount, heating_system: $heatingMethod, transaction_type: $houseUse, " +
                                        "property: $propertyOwnership, floor_description: $floorDescription, total_floors: $totalFloors})",
                                        Values.parameters("id", data[0], "address", address, "price", price, "unitPrice", unitPrice,
                                                "layout", data[4], "rentalArea", Double.parseDouble(data[5]), "buildingType", data[6], "orientation", data[7],
                                                "decoration", data[8], "elevatorCount", data[9], "heatingMethod", data[10], "houseUse", data[11],
                                                "propertyOwnership", data[12], "floorDescription", data[13], "totalFloors", Integer.parseInt(data[14])));
                                return null;
                            }
                        });


                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                


                // 创建房屋地址节点和建立关系
                for (String uniqueAddress : uniqueAddresses) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (address:Address {name: $name})", Values.parameters("name", uniqueAddress));
                            return null;
                        }
                    });

                    // 建立房屋与地址之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {address: $address}), (address:Address {name: $name}) CREATE (house)-[:LOCATED_AT]->(address)",
                                    Values.parameters("address", uniqueAddress, "name", uniqueAddress));
                            return null;
                        }
                    });
                        
                }
                
             // 创建房屋布局节点和建立房屋与布局之间的关系
                for (String uniqueLayout : uniqueLayouts) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (layout:Layout {name: $name})", Values.parameters("name", uniqueLayout));
                            return null;
                        }
                    });

                    // 建立房屋与布局之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {layout: $layout}), (layout:Layout {name: $name}) CREATE (house)-[:HAS_LAYOUT]->(layout)",
                                    Values.parameters("layout", uniqueLayout, "name", uniqueLayout));
                            return null;
                        }
                    });
                }
                
                // 创建建筑类型节点和建立房屋与建筑类型之间的关系
                for (String uniqueBuildingType : uniqueBuildingTypes) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (buildingType:BuildingType {name: $name})", Values.parameters("name", uniqueBuildingType));
                            return null;
                        }
                    });

                    // 建立房屋与建筑类型之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {building_type: $buildingType}), (buildingType:BuildingType {name: $name}) CREATE (house)-[:HAS_BUILDING_TYPE]->(buildingType)",
                                    Values.parameters("buildingType", uniqueBuildingType, "name", uniqueBuildingType));
                            return null;
                        }
                    });
                }
                 
                // 创建朝向节点和建立房屋与朝向之间的关系
                for (String uniqueOrientation : uniqueOrientations) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (orientation:Orientation {name: $name})", Values.parameters("name", uniqueOrientation));
                            return null;
                        }
                    });

                    // 建立房屋与朝向之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {orientation: $orientation}), (orientation:Orientation {name: $name}) CREATE (house)-[:HAS_ORIENTATION]->(orientation)",
                                    Values.parameters("orientation", uniqueOrientation, "name", uniqueOrientation));
                            return null;
                        }
                    });
                }
                
             // 创建装修风格节点和建立房屋与装修风格之间的关系
                for (String uniqueDecoration : uniqueDecorations) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (decoration:DecorationStyle {name: $name})", Values.parameters("name", uniqueDecoration));
                            return null;
                        }
                    });

                    // 建立房屋与装修风格之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {decoration: $decoration}), (decoration:DecorationStyle {name: $name}) CREATE (house)-[:HAS_DECORATION]->(decoration)",
                                    Values.parameters("decoration", uniqueDecoration, "name", uniqueDecoration));
                            return null;
                        }
                    });
                }
                
             // 创建电梯数量节点和建立房屋与电梯数量之间的关系
                for (String uniqueElevatorCount : uniqueElevatorCounts) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (elevatorCount:ElevatorCount {name: $name})", Values.parameters("name", uniqueElevatorCount));
                            return null;
                        }
                    });

                    // 建立房屋与电梯数量之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {elevator_style: $elevatorCount}), (elevatorCount:ElevatorCount {name: $name}) CREATE (house)-[:HAS_ELEVATOR_COUNT]->(elevatorCount)",
                                    Values.parameters("elevatorCount", uniqueElevatorCount, "name", uniqueElevatorCount));
                            return null;
                        }
                    });
                }
                
             // 创建供暖方式节点和建立房屋与供暖方式之间的关系
                for (String uniqueHeatingMethod : uniqueHeatingMethods) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (heatingMethod:HeatingMethod {name: $name})", Values.parameters("name", uniqueHeatingMethod));
                            return null;
                        }
                    });

                    // 建立房屋与供暖方式之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {heating_system: $heatingMethod}), (heatingMethod:HeatingMethod {name: $name}) CREATE (house)-[:HAS_HEATING_METHOD]->(heatingMethod)",
                                    Values.parameters("heatingMethod", uniqueHeatingMethod, "name", uniqueHeatingMethod));
                            return null;
                        }
                    });
                }
                
             // 创建房屋用途节点和建立房屋与用途之间的关系
                for (String uniqueHouseUse : uniqueHouseUses) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (houseUse:HouseUse {name: $name})", Values.parameters("name", uniqueHouseUse));
                            return null;
                        }
                    });

                    // 建立房屋与用途之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {use: $houseUse}), (houseUse:HouseUse {name: $name}) CREATE (house)-[:HAS_HOUSE_USE]->(houseUse)",
                                    Values.parameters("houseUse", uniqueHouseUse, "name", uniqueHouseUse));
                            return null;
                        }
                    });
                }
                
             // 创建房屋产权节点和建立房屋与产权之间的关系
                for (String uniquePropertyOwnership : uniquePropertyOwnerships) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (propertyOwnership:PropertyOwnership {name: $name})", Values.parameters("name", uniquePropertyOwnership));
                            return null;
                        }
                    });

                    // 建立房屋与产权之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {property: $propertyOwnership}), (propertyOwnership:PropertyOwnership {name: $name}) CREATE (house)-[:HAS_PROPERTY_OWNERSHIP]->(propertyOwnership)",
                                    Values.parameters("propertyOwnership", uniquePropertyOwnership, "name", uniquePropertyOwnership));
                            return null;
                        }
                    });
                }
                
             // 创建楼层描述节点和建立房屋与楼层描述之间的关系
                for (String uniqueFloorDescription : uniqueFloorDescriptions) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (floorDescription:FloorDescription {name: $name})", Values.parameters("name", uniqueFloorDescription));
                            return null;
                        }
                    });

                    // 建立房屋与楼层描述之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {floor_description: $floorDescription}), (floorDescription:FloorDescription {name: $name}) CREATE (house)-[:HAS_FLOOR_DESCRIPTION]->(floorDescription)",
                                    Values.parameters("floorDescription", uniqueFloorDescription, "name", uniqueFloorDescription));
                            return null;
                        }
                    });
                }
                
             // 创建总楼层节点和建立房屋与总楼层之间的关系
                for (int uniqueTotalFloor : uniqueTotalFloors) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (totalFloor:TotalFloor {level: $level})", Values.parameters("level", uniqueTotalFloor));
                            return null;
                        }
                    });

                    // 建立房屋与总楼层之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {total_floors: $totalFloor}), (totalFloor:TotalFloor {level: $level}) CREATE (house)-[:HAS_TOTAL_FLOOR]->(totalFloor)",
                                    Values.parameters("totalFloor", uniqueTotalFloor, "level", uniqueTotalFloor));
                            return null;
                        }
                    });
                }

             // 创建总价格节点和建立房屋与价格之间的关系
                for (double uniqueTotalPrice : uniqueTotalPrices) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (totalPrice:TotalPrice {amount: $amount})", Values.parameters("amount", uniqueTotalPrice));
                            return null;
                        }
                    });

                    // 建立房屋与价格之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {price: $price}), (totalPrice:TotalPrice {amount: $amount}) CREATE (house)-[:HAS_TOTAL_PRICE]->(totalPrice)",
                                    Values.parameters("price", uniqueTotalPrice, "amount", uniqueTotalPrice));
                            return null;
                        }
                    });
                }
                
             // 创建单价节点和建立房屋与单价之间的关系
                for (double uniqueUnitPrice : uniqueUnitPrices) {
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("CREATE (unitPrice:UnitPrice {amount: $amount})", Values.parameters("amount", uniqueUnitPrice));
                            return null;
                        }
                    });

                    // 建立房屋与单价之间的关系
                    session.writeTransaction(new TransactionWork<Void>() {
                        @Override
                        public Void execute(Transaction tx) {
                            tx.run("MATCH (house:House {unit_price: $unitPrice}), (unitPrice:UnitPrice {amount: $amount}) CREATE (house)-[:HAS_UNIT_PRICE]->(unitPrice)",
                                    Values.parameters("unitPrice", uniqueUnitPrice, "amount", uniqueUnitPrice));
                            return null;
                        }
                    });
                }
            }
            
        }
    }
}
Elik-hb
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Neo4j：入门基础（二）~ 数据导入Neo4J
满腹的小不甘
11-15 3461
Neo4j入门基础
JAVA-Neo4j库导入数据，并配置关系；
m0_51496483的博客
01-20 480
public static void main(String[] args) throws SQLException { //将要导入的数据先查出来放入内存中 List<Map<String, String>> martLogData = GBaseConnection.getMartLogData(); System.out.println("1、数据条数： " + martLogData.size()); //创建Neo4j链
neo4j批量数据导入
03-01
neo4j基于嵌入式的测试数据生成与导入源代码 数据生成代码在源代码文件夹src/test/java中
Neo4j数据导入-大量导入(含CSV)
Mrkaizi的博客
07-09 1765
如何将大规模数据导入Neo4j 项目需要基于Neo4j开发，由于数据量较大（数千万节点），因此对当前数据插入的方法进行了分析和对比。 我本地使用的Neo4j版本为： 可选方案 目前主要有以下几种数据插入方式： Cypher CREATE 语句，为每一条数据写一个CREATE Cypher LOAD CSV 语句，将数据转成CSV格式，通过LOAD CSV读取数据。 官方提供的Java API —— Batch Inserter 大牛编写的 Batch Import 工具 官方提供的 neo4j-impo
【知识图谱构建】从Mysql读取数据批量导入到Neo4j图数据库中
12-21
一 连接Mysql数据库，读取数据 ReadMysql2.py 代码如下： 注意：填写自己的数据库名字和密码！！！ # -*- coding: utf-8 -*- """ Created on 2020/3/21 @author: GaoRongxuan """ import pymysql def read_mysql(sql): ''' 从mysql数据库中读取数据 :param sql: sql查询语句 :return: rows 查询结果 ''' #打开数据库连接 dbconn = pymysql.con
Neo4j数据导入与可视化
01-27
本文重点介绍了Neo4j基础，Neo4j属性图数据模型，使用 本文来自简书，由火龙果软件Anna编辑、推荐。 Neo4j是一个高性能的NoSQL图形数据库，它将结构化数据存储在网络上而不是表中。它是一个嵌入式的、基于磁盘的、...
Neo4j大量CSV数据导入测试数据
05-05
3. **创建模式**：在导入数据之前，需要定义数据模型，即节点和关系的类型。这可以通过Cypher查询语言完成，例如创建节点类型`Person`和`Order`，以及它们之间的`PURCHASED`关系。 4. **编写导入脚本**：使用Cypher...
java导入数据 neo4j_Neo4j导入数据的几种方法-阿里云开发者社区
weixin_39609718的博客
12-20 391
create语句CREATE (a:Person {name: '张三', sex: '男'})如利用create批量写入，这里我使用的是scala+spark，代码如下：object Neo4jConnect {def main(args: Array[String]):Unit = {//数据库连接val spark=SparkSession.builder().appName("play")...
4.java从表格中获取数据 并写入neo4j
qq_43539524的博客
12-05 135
Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j的用户名","neo4j的密码"));if(cell.getCellType()==CELL_TYPE_STRING){//内容为String类型。if(cell.getCellType()==CELL_TYPE_STRING){//内容为String类型。
如何将大规模数据导入Neo4j
03-10
如何将大规模数据导入Neo4j
Neo4j+java实现的excel导入基本通讯录软件
12-29
Neo4j入门的基础小程序，java实现，代码简单易懂（注意安装neo4j2.0，netBeans打开，并且导入工程中的包）带基本界面，实现excel通讯录导入和查找。暂时是最基础的版本，后期版本是美化界面并且添加了插入删除等功能的，等待稍迟些上传，本人新手，大家包涵。
【Ne4j图数据库入门笔记2】数据导入详解
最新发布
陈小哥cw
04-19 1631
如上所述，某些应用程序有特殊的格式设置，使文档看起来更美观，但这些隐藏的额外代码是普通文件阅读器和脚本无法处理的。组的第一个文件或单独的单行文件中的标题行是必需的。对于将任何类型的数据导入到任何系统，数据质量也可能是一个问题，因此本节将介绍其中的一些潜在困难和克服这些困难的方法。可以跳过 CSV 文件中的 null 或空字段，或将其替换为 LOAD CSV中的默认值。为了改进在图形中插入或更新唯一实体（使用 MERGE 或 MATCH 更新），您可以为计划合并或匹配的每个标签和属性创建声明的索引和约束。
Java初始化大量数据到Neo4j中(二)
weixin_49456013的博客
09-27 1928
接Java初始化大量数据到Neo4j中(一)继续探索，之前用create命令导入大量数据发现太过耗时，查阅资料说大量数据初始化到Neo4j需要使用。业务数据说明可以参加Java初始化大量数据到Neo4j中(一)，这里主要是将处理好的节点数据和关系数据分别导出为csv。uniqueValue:ID 冒号前面可以随便写，冒号后端必须是ID,标识全局id，不可重复。CsvUtil用的是Hutool中的工具类，引入下面依赖即可。:START_ID:开始节点的唯一值。:END_ID:结束节点的唯一值。
Java初始化大量数据到Neo4j中(一)
weixin_49456013的博客
09-27 1773
之后执行controller接口，进行数据抽取和导入Neo4j，我开发的时候用的环境，大约有7w个节点，120w条关系。我开发的思路是：1.先将所有的表中数据取出来做为节点 2.根据关系表将这个数据的关系查出来之后组装语句将数据添加到Neo4j中。我刚开始开发的时候，由于对Neo4j的了解并没有很多，第一想到的是用代码通用组装create语句进行创建节点以及关系。业务说明：系统中有很多实体表，每个实体表中有自己的数据，不同实体有一张关系表进行维护。使用Java代码组装CQL语句，用原生session进行。
neo4j 使用之数据导入初探
csl136520054的博客
11-16 3454
平台：windows10 neo4j下载安装（较为简单，不做赘述）参考： 数据导入： 一、通过csv文件导入： 导入关系： LOAD CSV FROM "file:/index_rel.csv" AS row MATCH (p:IndexWh),(o:IndexWh) WHERE p.id = row[0] and o.id=row[1] CREATE (p)-[r:IndexRel{type:row[2]}]->(o); 导入数据： load csv from "file:///index_wh.
Neo4j导入数据的5种方式详解配图
热门推荐
qianmojl的博客
04-27 2万+
一、前言 Neo4j导入数据的方式有： 使用LOAD CSV导入数据 使用APOC导入数据 使用编程语言（Java，python，js，C#，Go）导入数据 使用neo4j-admin工具导入数据 使用应用导入数据 使用ETL工具导入数据 具体选择哪种导入方法取决于： 数据量大小 使用者对导入方法的轻松度感受 有多少时间来导入 各种导入方法的精力-效率图像如下图： 横坐标表示导入的效率，LOAD CSV导入比较慢，而neo4j-admin工具导入比较快。 纵坐标表示人耗费的精力，LOAD CSV比较
neo4j 查询同一节点的两个上级_neo4j 笔记（安装及基本操作）
weixin_39859061的博客
11-20 489
一 、安装Neo4j先装java注意：Neo4j 4.0 要求java必须是jdk11及以上，所以要更新java。我首先尝试了直接装 jdk13，也按要求修改了环境变量，但 java -verison 显示我的版本还是jdk8。所以我把java全部卸载了，没有保留其他版本的java，再重新装，就ok了。2. 配置neo4j很简单，从官网下载需要的版本：https://neo4j.com/downl...
使用py2neo导入数据到neo4j时发生AttributeError: 'NoneType' object has no attribute 'pool'
12-06
在使用py2neo导入数据到neo4j时，如果出现AttributeError: 'NoneType' object has no attribute 'pool'的错误，可能是由于连接池未正确初始化导致的。可以尝试在连接neo4j数据库之前，先初始化连接池，例如： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Elik-hb

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值