图数据库Neo4j——cypher语言的简单语法

绝地灬酷狼 2021-12-15 10:29 355阅读 0赞

图数据库是一种NoSQL数据库，它是基于 **图论** 来存储实体之间的关系信息，不遵循关系数据库模型，也不使用SQL作为查询语言。其数据存储可以不需要固定的表格模式，也经常会避免使用SQL的JOIN操作，一般有水平可扩展的特征。

它的数据模型主要是以节点和关系（边）来体现，也可处理键值对。它的优点是快速解决复杂的关系问题。

图具有如下特征：

1.  包含节点和边；
2.  节点上有属性（键值对）；
3.  边有名字和方向，并总是有一个开始节点和一个结束节点；
4.  边也可以有属性。

参考文章：[https://blog.csdn.net/xlgen157387/article/details/79085901/][https_blog.csdn.net_xlgen157387_article_details_79085901]

cypher的简单语法

1、查询节点：
    返回所有节点 match (n) return n
    查询带某个标签的节点(这里是返回所有电影)
     match (movie:Movie) return movie.title
    查询关联节点(返回A导演的所有电影)
     match (director {name:'A'})--(movie) return movie.title
    2、创建节点
    创建单个/多个节点 create (n),(m)
    创建带(多个)标签的节点 create (n:Person:Swedish)
    创建同时带标签和属性的节点 create (n:Person {name:'Anders',title:'Developer'})
    创建关系并设置属性 match (a:Person),(b:Person)
                       where a.name='Node A' AND b.name='Node B'
                       create (a)-[r:RELTYPE {name:a.name+'<->'+b.name}]->(b)
                       return r
    3、删除节点关系 delete
    删除所有节点和关系 match (n) detach delete n
    删除一个节点及其所有关系 match (n {name:'Andres'}) detach delete n
    4、删除属性和标签
    删除一个属性  match (andres {name:'Andres'})
                  remove andres.age
                  return andres
    删除节点的一个/多个标签 match (n {name:'Peter'})
                            remove n:Person:Swedish
                            return n

如何用C\#与Neo4j交互呢？先要导入NuGet程序包

PM> Install-Package Neo4j.Driver -Version 1.3.0

添加引用

using Neo4j.Driver.V1;

以下是通过C\#与Neo4j交互创建节点、关系的一个案例

namespace Neo4j
    {
        public class Neo4j
        {
            private IDriver Driver;
            public void Login(string uri, string user, string password)
            {
         //连接数据库
                Driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
            }
            public bool CreateSingleNode(string lable, string name)
            {
         //创建单节点            
                using (var session = Driver.Session(AccessMode.Write))//新建会话（session）
                {
                    string query = string.Format("CREATE (n:{0} ", lable) + @"{name: $name})";
                    var result = session.WriteTransaction(tx => tx.Run(query, new { name }));//创建事务（Transaction）
                    IResultSummary rs = result.Summary;
                    return rs.Counters.NodesCreated == 1;
                }
            }
            public bool CreateRelationship(string RelationshipType, string SourceNodeName, string TargetNodeName)
            {
         //创建关系
                string query = string.Format(@"match (n),(m) where n.name=$source
                        and m.name=$target create (n)-[:{0}]->(m);", RelationshipType);
    
                using (var session = Driver.Session())
                {
                    var result = session.WriteTransaction(tx => tx.Run(query,
                        new { source = SourceNodeName, target = TargetNodeName }));
                    IResultSummary rs = result.Summary;
                    return rs.Counters.RelationshipsCreated == 1;
                }
            }
            public void MatchNodes(string lable, string name)
            {
                string query = string.Format(@"MATCH (n:{0} ", lable) + @"{name: $name})-[r]->(m) RETURN n,id(n);";
                using (var session = Driver.Session(AccessMode.Read))
                {
                    var result = session.ReadTransaction(rx => rx.Run(query, new { name }));
                    //return 子句投影的字段列表
                    IReadOnlyList<string> keys = result.Keys;
                    //查询返回的数据行
                    var rows = result.ToList();
                    foreach (var row in rows)
                    {
                        //每个数据行都包含多个数据列
                        var columns = row.Values;
                        foreach (var column in columns)
                        {
                            //每个数据列，可能是一个节点，也可能是一个标量值
                            if (column.Key == "n")
                            {
                                var node = column.Value as INode;
    
                                long NodeID = node.Id;
                                string NodeLables = string.Join(",", node.Labels.ToArray());
                                foreach (var property in node.Properties)
                                {
                                    string Property = string.Format("Property[Key:{0},Value:{1}", property.Key, property.Value);
                                }
                            }
    
                            if (column.Key == "id(n)")
                            {
                                long NodeID = long.Parse(column.Value.ToString());
                            }
                        }
                    }
                }
            }
        }
        class Program
        {       
            static void Main(string[] args)
            {
                Neo4j a = new Neo4j();
                a.Login("bolt://localhost","neo4j", "liu525");
                a.CreateSingleNode("student","liu");           
                a.CreateSingleNode("professor", "Mr.Lin");
                a.CreateRelationship("师生","Mr.Lin", "liu");
                
            }
        }
    }

转载于:https://www.cnblogs.com/liuliang1999/p/10634640.html

[https_blog.csdn.net_xlgen157387_article_details_79085901]: https://blog.csdn.net/xlgen157387/article/details/79085901/