Cypher 描述性的图像查询语言

  1 /**
  2       * 使用cypherParser语言
  3       * @author 裴东辉
  4       * @since 2014-8-4  下午3:22:25
  5       */
  6      public void userCypherParser(){
  7         //执行一个Cypher Query的查询  
  8         GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase( "db/music.db" );
  9         try(Transaction tx = graphDb.beginTx()){ 
 10             /*API org.neo4j.cypher.javacompat.ExecutionEngine:To run a Cypher query, use this class.
 11                  ExecutionEngine(GraphDatabaseService database) Creates an execution engine around the give graph database
 12                  Method:
 13                      ExecutionResult    execute(String query)
 14                         Executes a query and returns an iterable that contains the result set
 15              */
 16             ExecutionEngine engine = new ExecutionEngine(graphDb);  
 17             //使用cypher语言进行查询-----一个描述性的图形查询语言
 18             //你参考部分的模式时，需要通过命名完成。定义的不同的命名部分就被称为标识符。
 19             //得到所有节点可以通过星号（*），同样对于关系也适用。
 20             System.out.println("----------------------------nodes----------------------------");
 21             ExecutionResult result = engine.execute( "start n=node(*) return n" );  
 22             //获取指定列的结果集  
 23             Iterator<Node> nodeIta = result.columnAs("n");
 24             Node node=null;
 25             while(nodeIta.hasNext()){
 26                 node=nodeIta.next();
 27                 info(node+"-;node name="+node.getProperty("name"));        
 28             }
 29             
 30             //关系数据
 31             System.out.println("----------------------------relationship----------------------------");
 32             //得到所有节点可以通过星号（*），同样对于关系也适用。
 33             result = engine.execute( "start n=relationship(*) return n" );  
 34             //获取指定列的结果集  
 35             Iterator<Relationship> relationshipIta = result.columnAs("n");
 36             Relationship relationship=null;
 37             while(relationshipIta.hasNext()){
 38                 relationship=relationshipIta.next();
 39                 info(relationship+"-;start node:"+relationship.getStartNode().getProperty("name"));        
 40             }
 41             
 42             //通过索引查询获取节点
 43             /*如果开始节点可以通过索引查询得到，可以如此来写：
 44                 node:indexName(key=”value”)。
 45                 查询： START n=node:nodes(name = "A") RETURN n 索引中命名为A的节点将被返回。
 46             */
 47             System.out.println("----------------------------索引查询节点----------------------------");
 48             //在此列子中存在一个节点索引叫nodes。
 49              result = engine.execute( "start n=node:nodes(name=‘歌手 1的专辑 1‘) return n" );  
 50             //获取指定列的结果集  
 51             nodeIta = result.columnAs("n");
 52             while(nodeIta.hasNext()){
 53                 node=nodeIta.next();
 54                 info(node+"-;node name="+node.getProperty("name"));        
 55             }
 56             
 57             //通过索引获取关系
 58             System.out.println("----------------------------索引查询关系----------------------------");
 59             //得到所有节点可以通过星号（*），同样对于关系也适用。
 60             result = engine.execute( "start n=relationship:relationships(publishtime=‘2014-10-10‘) return n" );  
 61             //获取指定列的结果集  
 62             relationshipIta = result.columnAs("n");
 63             while(relationshipIta.hasNext()){
 64                 relationship=relationshipIta.next();
 65                 info(relationship+"-;start node:"+relationship.getStartNode().getProperty("name"));        
 66             }
 67             
 68             //Match--http://www.uml.org.cn/sjjm/201203063.asp
 69             /*Match语句
 70                 在一个查询的匹配（match）部分申明图形（模式）。模式的申明导致一个或多个以逗号隔开的路径（path）。
 71                 节点标识符可以使用或者不是用圆括号。使用圆括号与不使用圆括号完全对等，如：
 72                 MATCH(a)-->(b) 与 MATCH a-->b 匹配模式完全相同。
 73                 模式的所有部分都直接或者间接地绑定到开始点上。
 74                 可选关系是一个可选描述模式的方法，但在真正图中可能没有匹配（节点可能没有或者没有此类关系时），将被估值为null。
 75                 与SQL中的外联结类似，如果Cypher发现一个或者多个匹配，将会全部返回。如果没有匹配，Cypher将返回null。
 76             */
 77             System.out.println("----------------------------Match查询与节点--相关节点----------------------------");
 78             //在此列子中存在一个节点索引叫nodes。
 79             //符号—意味着相关性，不需要关心方向和类型。
 80             //当对关系的方向感兴趣时，可以使用-->或<--符号，如：
 81              result = engine.execute( "start n=node(0) match (n)-->(x) return x" );  
 82             //获取指定列的结果集  
 83             nodeIta = result.columnAs("x");
 84             while(nodeIta.hasNext()){
 85                 node=nodeIta.next();
 86                 info(node+"-;node name="+node.getProperty("name"));        
 87             }
 88             
 89             //定向关系和标识符 
 90             /*如果需要关系的标识符，为了过滤关系的属性或为了返回关系，可如下例使用标识符。 
 91                 查询： 
 92                 START n=node(3) MATCH (n)-[r]->() RETURN r
 93                 所有从节点A接出的关系将被返回。
 94             */
 95             System.out.println("----------------------------Match查询与节点--这个节点所有点击的关系----------------------------");
 96             //得到所有节点可以通过星号（*），同样对于关系也适用。
 97             result = engine.execute( "start n=node(0) match (n)-[r]->() return r" );  
 98             //获取指定列的结果集  
 99             relationshipIta = result.columnAs("r");
100             while(relationshipIta.hasNext()){
101                 relationship=relationshipIta.next();
102                 info(relationship+"-;start node:"+relationship.getStartNode().getProperty("name"));        
103             }
104             
105             //通过关系类型匹配到从这个节点发出的某个关系的所有节点
106             System.out.println("----------------------------Match查询通过关系类型匹配到从这个节点发出的某个关系的所有节点----------------------------");
107              result = engine.execute( "start n=node(0) match (n)-[:PUBLISH]->(x) return x" );  
108             //获取指定列的结果集  
109             nodeIta = result.columnAs("x");
110             while(nodeIta.hasNext()){
111                 node=nodeIta.next();
112                 info(node+"-;node name="+node.getProperty("name"));        
113             }
114             
115             //通过关系类型匹配和使用标识符
116             System.out.println("----------------------------Match通过关系类型匹配和使用标识符----------------------------");
117             result = engine.execute( "start n=node(0) match (n)-[r:PUBLISH]->() return r" );  
118             //获取指定列的结果集  
119             relationshipIta = result.columnAs("r");
120             while(relationshipIta.hasNext()){
121                 relationship=relationshipIta.next();
122                 info(relationship+"-;start node:"+relationship.getStartNode().getProperty("name"));        
123             }
124             
125             //多重关系---这一下就解决了这个歌手的所有歌曲的信息
126             System.out.println("----------------------------Match 多重关系----------------------------");
127              result = engine.execute( "start n=node(0) match (n)-[:PUBLISH]->(a)-[:CONTAIN]->(x) return x" );  
128             //获取指定列的结果集  
129             nodeIta = result.columnAs("x");
130             while(nodeIta.hasNext()){
131                 node=nodeIta.next();
132                 info(node+"-;node name="+node.getProperty("name"));        
133             }
134             
135         }finally{
136             graphDb.shutdown();
137         }
138      }