aai-core/src/main/java/org/openecomp/aai/query/builder/GraphTraversalBuilder.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 package org.openecomp.aai.query.builder;
  22
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.LinkedHashMap;
  26 import java.util.List;
  27 import java.util.Optional;
  28 import java.util.Set;
  29
  30 import org.apache.tinkerpop.gremlin.process.traversal.P;
  31 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
  32 import org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin;
  33 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  34 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  35 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  36 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
  37 import org.apache.tinkerpop.gremlin.structure.Direction;
  38 import org.apache.tinkerpop.gremlin.structure.Vertex;
  39
  40 import org.openecomp.aai.db.props.AAIProperties;
  41 import org.openecomp.aai.exceptions.AAIException;
  42 import org.openecomp.aai.introspection.Introspector;
  43 import org.openecomp.aai.introspection.Loader;
  44 import org.openecomp.aai.schema.enums.ObjectMetadata;
  45 import org.openecomp.aai.schema.enums.PropertyMetadata;
  46 import org.openecomp.aai.serialization.db.EdgeRule;
  47 import org.openecomp.aai.serialization.db.EdgeRules;
  48 import org.openecomp.aai.serialization.db.EdgeType;
  49 import org.openecomp.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
  50
  51 /**
  52  * The Class GraphTraversalBuilder.
  53  */
  54 public abstract class GraphTraversalBuilder extends QueryBuilder {
  55
  56         protected GraphTraversal<Vertex, Vertex> traversal = null;
  57         protected Admin<Vertex, Vertex> completeTraversal = null;
  58         private EdgeRules edgeRules = EdgeRules.getInstance();
  59
  60         protected int parentStepIndex = 0;
  61         protected int containerStepIndex = 0;
  62         protected int stepIndex = 0;
  63
  64         /**
  65          * Instantiates a new graph traversal builder.
  66          *
  67          * @param loader the loader
  68          */
  69         public GraphTraversalBuilder(Loader loader, GraphTraversalSource source) {
  70                 super(loader, source);
  71
  72                 traversal = __.start();
  73
  74         }
  75
  76         /**
  77          * Instantiates a new graph traversal builder.
  78          *
  79          * @param loader the loader
  80          * @param start the start
  81          */
  82         public GraphTraversalBuilder(Loader loader, GraphTraversalSource source, Vertex start) {
  83                 super(loader, source, start);
  84
  85                 traversal = __.start();
  86
  87         }
  88
  89         /**
  90          * @{inheritDoc}
  91          */
  92         @Override
  93         public QueryBuilder getVerticesByIndexedProperty(String key, Object value) {
  94
  95                 return this.getVerticesByProperty(key, value);
  96         }
  97
  98         /**
  99          * @{inheritDoc}
 100          */
 101         @Override
 102         public QueryBuilder getVerticesByIndexedProperty(String key, List<?> values) {
 103                 return this.getVerticesByProperty(key, values);
 104         }
 105
 106         /**
 107          * @{inheritDoc}
 108          */
 109         @Override
 110         public QueryBuilder getVerticesByProperty(String key, Object value) {
 111
 112                 //this is because the index is registered as an Integer
 113                 value = this.correctObjectType(value);
 114
 115                 traversal.has(key, value);
 116
 117                 stepIndex++;
 118                 return this;
 119         }
 120
 121         /**
 122          * @{inheritDoc}
 123          */
 124         @Override
 125         public QueryBuilder getVerticesByProperty(final String key, final List<?> values) {
 126
 127                 //this is because the index is registered as an Integer
 128                 List<Object> correctedValues = new ArrayList<>();
 129                 for (Object item : values) {
 130                         correctedValues.add(this.correctObjectType(item));
 131                 }
 132
 133                 traversal.has(key, P.within(correctedValues));
 134
 135                 stepIndex++;
 136                 return this;
 137         }
 138
 139         /**
 140          * @{inheritDoc}
 141          */
 142         @Override
 143         public QueryBuilder getChildVerticesFromParent(String parentKey, String parentValue, String childType) {
 144                 traversal.has(parentKey, parentValue).has(AAIProperties.NODE_TYPE, childType);
 145                 stepIndex++;
 146                 return this;
 147         }
 148
 149         /**
 150          * @{inheritDoc}
 151          */
 152         @Override
 153         public QueryBuilder getTypedVerticesByMap(String type, LinkedHashMap<String, String> map) {
 154
 155                 for (String key : map.keySet()) {
 156                         traversal.has(key, map.get(key));
 157                         stepIndex++;
 158                 }
 159                 traversal.has(AAIProperties.NODE_TYPE, type);
 160                 stepIndex++;
 161                 return this;
 162         }
 163
 164         /**
 165          * @{inheritDoc}
 166          */
 167         @Override
 168         public QueryBuilder createDBQuery(Introspector obj) {
 169                 this.createKeyQuery(obj);
 170                 this.createContainerQuery(obj);
 171                 return this;
 172         }
 173
 174         /**
 175          * @{inheritDoc}
 176          */
 177         @Override
 178         public QueryBuilder createKeyQuery(Introspector obj) {
 179                 Set<String> keys = obj.getKeys();
 180                 Object val;
 181                 for (String key : keys) {
 182                         val = obj.getValue(key);
 183                         Optional<String> metadata = obj.getPropertyMetadata(key, PropertyMetadata.DB_ALIAS);
 184                         if (metadata.isPresent()) {
 185                                 //use the db name for the field rather than the object model
 186                                 key = metadata.get();
 187                         }
 188                         if (val != null) {
 189                                 //this is because the index is registered as an Integer
 190                                 if (val.getClass().equals(Long.class)) {
 191                                         traversal.has(key,new Integer(val.toString()));
 192                                 } else {
 193                                         traversal.has(key, val);
 194                                 }
 195                                 stepIndex++;
 196                         }
 197                 }
 198                 return this;
 199         }
 200
 201         @Override
 202         public QueryBuilder exactMatchQuery(Introspector obj) {
 203                 this.createKeyQuery(obj);
 204                 allPropertiesQuery(obj);
 205                 this.createContainerQuery(obj);
 206                 return this;
 207         }
 208
 209         private void allPropertiesQuery(Introspector obj) {
 210                 Set<String> props = obj.getProperties();
 211                 Set<String> keys = obj.getKeys();
 212                 Object val;
 213                 for (String prop : props) {
 214                         if (obj.isSimpleType(prop) && !keys.contains(prop)) {
 215                                 val = obj.getValue(prop);
 216                                 if (val != null) {
 217                                         Optional<String> metadata = obj.getPropertyMetadata(prop, PropertyMetadata.DB_ALIAS);
 218                                         if (metadata.isPresent()) {
 219                                                 //use the db name for the field rather than the object model
 220                                                 prop = metadata.get();
 221                                         }
 222                                         //this is because the index is registered as an Integer
 223                                         if (val != null && val.getClass().equals(Long.class)) {
 224                                                 traversal.has(prop,new Integer(val.toString()));
 225                                         } else {
 226                                                 traversal.has(prop, val);
 227                                         }
 228                                         stepIndex++;
 229                                 }
 230                         }
 231                 }
 232         }
 233
 234         /**
 235          * @{inheritDoc}
 236          */
 237         @Override
 238
 239         public QueryBuilder createContainerQuery(Introspector obj) {
 240                 String type = obj.getChildDBName();
 241                 String abstractType = obj.getMetadata(ObjectMetadata.ABSTRACT);
 242                 if (abstractType != null) {
 243                         String[] inheritors = obj.getMetadata(ObjectMetadata.INHERITORS).split(",");
 244                         traversal.has(AAIProperties.NODE_TYPE, P.within(inheritors));
 245                 } else {
 246                         traversal.has(AAIProperties.NODE_TYPE, type);
 247                 }
 248                 stepIndex++;
 249                 markContainer();
 250                 return this;
 251         }
 252
 253         /**
 254          * @throws NoEdgeRuleFoundException
 255          * @throws AAIException
 256          * @{inheritDoc}
 257          */
 258         @Override
 259         public QueryBuilder createEdgeTraversal(EdgeType type, Introspector parent, Introspector child) throws AAIException, NoEdgeRuleFoundException {
 260                 String isAbstractType = parent.getMetadata(ObjectMetadata.ABSTRACT);
 261                 if ("true".equals(isAbstractType)) {
 262                         markParentBoundary();
 263                         traversal.union(handleAbstractEdge(type, parent, child));
 264                         stepIndex += 1;
 265                 } else {
 266                         this.edgeQuery(type, parent, child);
 267                 }
 268                 return this;
 269
 270         }
 271
 272         private Traversal<Vertex, Vertex>[] handleAbstractEdge(EdgeType type, Introspector abstractParent, Introspector child) throws AAIException, NoEdgeRuleFoundException {
 273                 String childName = child.getDbName();
 274                 String inheritorMetadata = abstractParent.getMetadata(ObjectMetadata.INHERITORS);
 275                 String[] inheritors = inheritorMetadata.split(",");
 276                 Traversal<Vertex, Vertex>[] unionTraversals = new Traversal[inheritors.length];
 277                 int traversalIndex = 0;
 278                 for (int i = 0; i < inheritors.length; i++) {
 279                         String inheritor = inheritors[i];
 280                         if (edgeRules.hasEdgeRule(inheritor, childName) || edgeRules.hasEdgeRule(childName, inheritor)) {
 281                                 EdgeRule rule = edgeRules.getEdgeRule(type, inheritor, childName);
 282                                 GraphTraversal<Vertex, Vertex> innerTraversal = __.start();
 283                                 if (rule.getDirection().equals(Direction.OUT)) {
 284                                         innerTraversal.out(rule.getLabel());
 285                                 } else {
 286                                         innerTraversal.in(rule.getLabel());
 287                                 }
 288                                 innerTraversal.has(AAIProperties.NODE_TYPE, childName);
 289                                 unionTraversals[traversalIndex] = innerTraversal;
 290                                 traversalIndex++;
 291                         }
 292                 }
 293                 if (traversalIndex < inheritors.length) {
 294                         Traversal<Vertex, Vertex>[] temp = Arrays.copyOfRange(unionTraversals, 0, traversalIndex);
 295                         unionTraversals = temp;
 296                 }
 297                 return unionTraversals;
 298         }
 299         /**
 300          * @throws NoEdgeRuleFoundException
 301          * @throws AAIException
 302          * @{inheritDoc}
 303          */
 304         @Override
 305         public QueryBuilder createEdgeTraversal(EdgeType type, Vertex parent, Introspector child) throws AAIException, NoEdgeRuleFoundException {
 306
 307                 String nodeType = parent.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 308                 Introspector parentObj = loader.introspectorFromName(nodeType);
 309                 this.edgeQuery(type, parentObj, child);
 310                 return this;
 311
 312         }
 313
 314         /**
 315          * @{inheritDoc}
 316          */
 317         @Override
 318         public QueryBuilder union(QueryBuilder... builder) {
 319                 GraphTraversal<Vertex, Vertex>[] traversals = new GraphTraversal[builder.length];
 320                 for (int i = 0; i < builder.length; i++) {
 321                         traversals[i] = (GraphTraversal<Vertex, Vertex>)builder[i].getQuery();
 322                 }
 323                 this.traversal.union(traversals);
 324                 stepIndex++;
 325
 326                 return this;
 327         }
 328
 329         /**
 330          * @{inheritDoc}
 331          */
 332         @Override
 333         public QueryBuilder where(QueryBuilder... builder) {
 334                 GraphTraversal<Vertex, Vertex>[] traversals = new GraphTraversal[builder.length];
 335                 for (int i = 0; i < builder.length; i++) {
 336                         this.traversal.where((GraphTraversal<Vertex, Vertex>)builder[i].getQuery());
 337                         stepIndex++;
 338                 }
 339
 340                 return this;
 341         }
 342
 343         /**
 344          * Edge query.
 345          *
 346          * @param outType the out type
 347          * @param inType the in type
 348          * @throws NoEdgeRuleFoundException
 349          * @throws AAIException
 350          */
 351         private void edgeQuery(EdgeType type, Introspector outObj, Introspector inObj) throws AAIException, NoEdgeRuleFoundException {
 352                 String outType = outObj.getDbName();
 353                 String inType = inObj.getDbName();
 354
 355                 if (outObj.isContainer()) {
 356                         outType = outObj.getChildDBName();
 357                 }
 358                 if (inObj.isContainer()) {
 359                         inType = inObj.getChildDBName();
 360                 }
 361                 markParentBoundary();
 362                 EdgeRule rule = edgeRules.getEdgeRule(type, outType, inType);
 363                 if (rule.getDirection().equals(Direction.OUT)) {
 364                         traversal.out(rule.getLabel());
 365                 } else {
 366                         traversal.in(rule.getLabel());
 367                 }
 368                 stepIndex++;
 369                 this.createContainerQuery(inObj);
 370         }
 371
 372         @Override
 373         public QueryBuilder limit(long amount) {
 374                 traversal.limit(amount);
 375                 return this;
 376         }
 377
 378         /**
 379          * @{inheritDoc}
 380          */
 381         @Override
 382         public <T> T getQuery() {
 383                 return (T)this.traversal;
 384         }
 385
 386         /**
 387          * @{inheritDoc}
 388          */
 389         @Override
 390         public QueryBuilder getParentQuery() {
 391
 392                 return cloneQueryAtStep(parentStepIndex);
 393         }
 394
 395         @Override
 396         public QueryBuilder getContainerQuery() {
 397
 398                 if (this.parentStepIndex == 0) {
 399                         return removeQueryStepsBetween(0, containerStepIndex);
 400                 } else {
 401                         return cloneQueryAtStep(containerStepIndex);
 402                 }
 403         }
 404
 405         /**
 406          * @{inheritDoc}
 407          */
 408         @Override
 409         public void markParentBoundary() {
 410                 parentStepIndex = stepIndex;
 411         }
 412
 413         @Override
 414         public void markContainer() {
 415                 containerStepIndex = stepIndex;
 416         }
 417
 418
 419         /**
 420          * @{inheritDoc}
 421          */
 422         @Override
 423         public Vertex getStart() {
 424                 return this.start;
 425         }
 426
 427         protected int getParentStepIndex() {
 428                 return parentStepIndex;
 429         }
 430
 431         protected int getContainerStepIndex() {
 432                 return containerStepIndex;
 433         }
 434
 435         protected int getStepIndex() {
 436                 return stepIndex;
 437         }
 438
 439         protected abstract QueryBuilder cloneQueryAtStep(int index);
 440         /**
 441          * end is exclusive
 442          *
 443          * @param start
 444          * @param end
 445          * @return
 446          */
 447         protected abstract QueryBuilder removeQueryStepsBetween(int start, int end);
 448
 449         private void executeQuery() {
 450
 451                 Admin<Vertex, Vertex> admin;
 452                 if (start != null) {
 453                         admin = source.V(start).asAdmin();
 454                 } else {
 455                         admin = source.V().asAdmin();
 456
 457                 }
 458
 459                 TraversalHelper.insertTraversal(admin.getEndStep(), traversal.asAdmin(), admin);
 460
 461                 this.completeTraversal = admin;
 462         }
 463
 464         @Override
 465         public boolean hasNext() {
 466                 if (this.completeTraversal == null) {
 467                         executeQuery();
 468                 }
 469
 470                 return this.completeTraversal.hasNext();
 471         }
 472
 473         @Override
 474         public Vertex next() {
 475                 if (this.completeTraversal == null) {
 476                         executeQuery();
 477                 }
 478
 479                 return this.completeTraversal.next();
 480         }
 481
 482         @Override
 483         public List<Vertex> toList() {
 484                 if (this.completeTraversal == null) {
 485                         executeQuery();
 486                 }
 487
 488                 return this.completeTraversal.toList();
 489         }
 490
 491 }