aai-core/src/main/java/org/openecomp/aai/serialization/engines/query/GremlinPipelineQueryEngine.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 /*
  22 package org.openecomp.aai.serialization.engines.query;
  23
  24 import java.util.HashSet;
  25 import java.util.List;
  26 import java.util.Set;
  27
  28 import org.openecomp.aai.db.AAIProperties;
  29 import org.openecomp.aai.query.builder.QueryBuilder;
  30 import org.openecomp.aai.serialization.engines.TransactionalGraphEngine;
  31 import com.tinkerpop.blueprints.Direction;
  32 import com.tinkerpop.blueprints.TransactionalGraph;
  33 import com.tinkerpop.blueprints.Vertex;
  34 import com.tinkerpop.gremlin.java.GremlinPipeline;
  35 import com.tinkerpop.pipes.IdentityPipe;
  36 import com.tinkerpop.pipes.PipeFunction;
  37 import com.tinkerpop.pipes.branch.LoopPipe;
  38
  39 public class GremlinPipelineQueryEngine extends QueryEngine {
  40
  41         public GremlinPipelineQueryEngine(TransactionalGraphEngine graphEngine) {
  42                 super(graphEngine);
  43         }
  44
  45         @Override
  46         public List<Vertex> executeQuery(TransactionalGraph g, QueryBuilder query) {
  47                 List<Vertex> results = null;
  48                 Vertex start = query.getStart();
  49                 if (start != null) {
  50                         results = ((GremlinPipeline)query.getQuery()).cast(Vertex.class).toList();
  51                 } else {
  52                         GremlinPipeline pipe = new GremlinPipeline(g);
  53                         results = process(pipe, (GremlinPipeline)query.getQuery());
  54
  55                 }
  56                 return results;
  57         }
  58
  59         @Override
  60         public List<Vertex> executeParentQuery(TransactionalGraph g, QueryBuilder query) {
  61                 List<Vertex> results = null;
  62                 Vertex start = query.getStart();
  63                 if (start != null) {
  64                         results = ((GremlinPipeline)query.getParentQuery()).cast(Vertex.class).toList();
  65                 } else {
  66                         GremlinPipeline pipe = new GremlinPipeline(g);
  67                         results = process(pipe, (GremlinPipeline)query.getParentQuery());
  68
  69                 }
  70                 return results;
  71         }
  72
  73         @Override
  74         public List<Vertex> findParents(Vertex start) {
  75                 GremlinPipeline<Vertex, Vertex> pipe = new GremlinPipeline(start).as("x").inE()
  76                                 .has("isParent", true).outV().loop("x", new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
  77
  78                                         @Override
  79                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
  80                                                 GremlinPipeline<Vertex, Long> pipe = new GremlinPipeline<>(argument.getObject());
  81                                                 return pipe.inE().has("isParent", true).count() == 1 || argument.getLoops() < 100;
  82                                         }
  83
  84                                 }, new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
  85
  86                                         @Override
  87                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
  88                                                 return true;
  89                                         }
  90
  91                                 });
  92
  93                 List<Vertex> results = pipe.toList();
  94                 results.add(0, start);
  95                 return results;
  96         }
  97
  98         @Override
  99         public List<Vertex> findChildren(Vertex start) {
 100                 Set<Vertex> seen = new HashSet<>();
 101                 seen.add(start);
 102                 GremlinPipeline<Vertex, Vertex> pipe = new GremlinPipeline(start).as("x").outE().has("isParent", true).inV()
 103                                 .except(seen).store(seen).loop("x", new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
 104
 105                                         @Override
 106                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
 107                                                 GremlinPipeline<Vertex, Long> pipe = new GremlinPipeline<>(argument.getObject());
 108                                                 return pipe.outE().has("isParent", true).count() >= 1 || argument.getLoops() < 100;
 109                                         }
 110
 111                                 }, new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
 112
 113                                         @Override
 114                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
 115                                                 return true;
 116                                         }
 117
 118                                 });
 119
 120                 List<Vertex> results = pipe.toList();
 121                 results.add(0, start);
 122                 return results;
 123         }
 124
 125         @Override
 126         public List<Vertex> findDeletable(Vertex start) {
 127                 Set<Vertex> seen = new HashSet<>();
 128                 seen.add(start);
 129                 GremlinPipeline<Vertex, Vertex> pipe = new GremlinPipeline<Vertex, Vertex>(start).as("x").outE().or(
 130                                 new GremlinPipeline(new IdentityPipe()).has("isParent", true),
 131                                 new GremlinPipeline(new IdentityPipe()).has("hasDelTarget", true)).inV()
 132                                 .except(seen).store(seen).loop("x", new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
 133
 134                                         @Override
 135                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
 136                                                 GremlinPipeline<Vertex, Long> pipe = new GremlinPipeline<>(argument.getObject());
 137                                                 return pipe.outE().or(
 138                                                                 new GremlinPipeline(new IdentityPipe()).has("isParent", true),
 139                                                                 new GremlinPipeline(new IdentityPipe()).has("hasDelTarget", true)).count() >= 1 || argument.getLoops() < 100;
 140                                         }
 141
 142                                 }, new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
 143
 144                                         @Override
 145                                         public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
 146                                                 return true;
 147                                         }
 148
 149                                 });
 150                 List<Vertex> results = pipe.toList();
 151                 results.add(0, start);
 152
 153                 return results;
 154         }
 155
 156         private List<Vertex> process(GremlinPipeline start, GremlinPipeline pipe) {
 157
 158
 159                 return start.add(pipe).cast(Vertex.class).toList();
 160         }
 161
 162         @Override
 163         public List<Vertex> findRelatedVertices(Vertex start, Direction direction, String label, String nodeType) {
 164                 GremlinPipeline<Vertex, Vertex> pipe = new GremlinPipeline<Vertex, Vertex>(start);
 165                 switch (direction) {
 166                         case OUT:
 167                                 pipe.out(label);
 168                                 break;
 169                         case IN:
 170                                 pipe.in(label);
 171                                 break;
 172                         case BOTH:
 173                                 pipe.both(label);
 174                                 break;
 175                          default:
 176                                 break;
 177                 }
 178
 179                 pipe.has(AAIProperties.NODE_TYPE, nodeType).dedup();
 180                 List<Vertex> result = pipe.toList();
 181                 return result;
 182         }
 183
 184 }
 185 */