aai-core/src/main/java/org/openecomp/aai/query/builder/GremlinQueryBuilder.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.HashMap;
  25 import java.util.LinkedHashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29
  30 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  31 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  32 import org.apache.tinkerpop.gremlin.structure.Direction;
  33 import org.apache.tinkerpop.gremlin.structure.Vertex;
  34
  35 import org.openecomp.aai.db.props.AAIProperties;
  36 import org.openecomp.aai.exceptions.AAIException;
  37 import org.openecomp.aai.introspection.Introspector;
  38 import org.openecomp.aai.introspection.Loader;
  39 import org.openecomp.aai.restcore.search.GremlinGroovyShellSingleton;
  40 import org.openecomp.aai.schema.enums.ObjectMetadata;
  41 import org.openecomp.aai.serialization.db.EdgeRule;
  42 import org.openecomp.aai.serialization.db.EdgeRules;
  43 import org.openecomp.aai.serialization.db.EdgeType;
  44 import org.openecomp.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
  45 import com.google.common.base.Joiner;
  46
  47 /**
  48  * The Class GremlinQueryBuilder.
  49  */
  50 public abstract class GremlinQueryBuilder extends QueryBuilder {
  51
  52         private EdgeRules edgeRules = EdgeRules.getInstance();
  53         private GremlinGroovyShellSingleton gremlinGroovy = GremlinGroovyShellSingleton.getInstance();
  54         private GraphTraversal<?, ?> completeTraversal = null;
  55         protected List<String> list = null;
  56
  57         protected int parentStepIndex = 0;
  58         protected int containerStepIndex = 0;
  59         protected int stepIndex = 0;
  60
  61         /**
  62          * Instantiates a new gremlin query builder.
  63          *
  64          * @param loader the loader
  65          */
  66         public GremlinQueryBuilder(Loader loader, GraphTraversalSource source) {
  67                 super(loader, source);
  68                 list = new ArrayList<String>();
  69         }
  70
  71         /**
  72          * Instantiates a new gremlin query builder.
  73          *
  74          * @param loader the loader
  75          * @param start the start
  76          */
  77         public GremlinQueryBuilder(Loader loader, GraphTraversalSource source, Vertex start) {
  78                 super(loader, source, start);
  79                 list = new ArrayList<String>();
  80         }
  81
  82         /**
  83          * @{inheritDoc}
  84          */
  85         @Override
  86         public QueryBuilder createDBQuery(Introspector obj) {
  87                 this.createKeyQuery(obj);
  88                 this.createContainerQuery(obj);
  89                 return this;
  90         }
  91
  92         @Override
  93         public QueryBuilder exactMatchQuery(Introspector obj) {
  94                 // TODO not implemented because this is implementation is no longer used
  95                 this.createKeyQuery(obj);
  96                 //allPropertiesQuery(obj);
  97                 this.createContainerQuery(obj);
  98                 return this;
  99         }
 100
 101         /**
 102          * @{inheritDoc}
 103          */
 104         @Override
 105         public QueryBuilder getVerticesByIndexedProperty(String key, Object value) {
 106                 return this.getVerticesByProperty(key, value);
 107         }
 108
 109         /**
 110          * @{inheritDoc}
 111          */
 112         @Override
 113         public QueryBuilder getVerticesByIndexedProperty(String key, List<?> values) {
 114                 return this.getVerticesByProperty(key, values);
 115         }
 116
 117         /**
 118          * @{inheritDoc}
 119          */
 120         @Override
 121         public QueryBuilder getVerticesByProperty(String key, Object value) {
 122
 123                 String term = "";
 124                 if (value != null && !value.getClass().getName().equals("java.lang.String")) {
 125                         term = value.toString();
 126                 } else {
 127                         term = "'" + value + "'";
 128                 }
 129                 list.add(".has('" + key + "', " + term + ")");
 130                 stepIndex++;
 131                 return this;
 132         }
 133
 134         /**
 135          * @{inheritDoc}
 136          */
 137         @Override
 138         public QueryBuilder getVerticesByProperty(String key, List<?> values) {
 139
 140                 String term = "";
 141                 String predicate = "P.within(#!#argument#!#)";
 142                 List<String> arguments = new ArrayList<>();
 143                 for (Object item : values) {
 144                         if (item != null && !item.getClass().getName().equals("java.lang.String")) {
 145                                 arguments.add(item.toString());
 146                         } else {
 147                                 arguments.add("'" + item + "'");
 148                         }
 149                 }
 150                 String argument = Joiner.on(",").join(arguments);
 151                 predicate = predicate.replace("#!#argument#!#", argument);
 152                 list.add(".has('" + key + "', " + predicate + ")");
 153                 stepIndex++;
 154                 return this;
 155         }
 156
 157
 158         /**
 159          * @{inheritDoc}
 160          */
 161         @Override
 162         public QueryBuilder getChildVerticesFromParent(String parentKey, String parentValue, String childType) {
 163                 /*
 164                 String query = ".has('aai-node-type', '" + childType + "')";
 165
 166                 return this.processGremlinQuery(parentKey, parentValue, query);
 167                 */
 168                 //TODO
 169                 return this;
 170         }
 171
 172         /**
 173          * @{inheritDoc}
 174          */
 175         @Override
 176         public QueryBuilder getTypedVerticesByMap(String type, LinkedHashMap<String, String> map) {
 177
 178                 for (String key : map.keySet()) {
 179                         list.add(".has('" + key + "', '" + map.get(key) + "')");
 180                         stepIndex++;
 181                 }
 182                 list.add(".has('aai-node-type', '" + type + "')");
 183                 stepIndex++;
 184                 return this;
 185         }
 186
 187         /**
 188          * @{inheritDoc}
 189          */
 190         @Override
 191         public QueryBuilder createKeyQuery(Introspector obj) {
 192                 Set<String> keys = obj.getKeys();
 193
 194                 for (String key : keys) {
 195
 196                         this.getVerticesByProperty(key, obj.<Object>getValue(key));
 197
 198                 }
 199                 return this;
 200         }
 201
 202         /**
 203          * @throws NoEdgeRuleFoundException
 204          * @throws AAIException
 205          * @{inheritDoc}
 206          */
 207         @Override
 208         public QueryBuilder createEdgeTraversal(EdgeType type, Introspector parent, Introspector child) throws AAIException, NoEdgeRuleFoundException {
 209                 String parentName = parent.getDbName();
 210                 String childName = child.getDbName();
 211                 if (parent.isContainer()) {
 212                         parentName = parent.getChildDBName();
 213                 }
 214                 if (child.isContainer()) {
 215                         childName = child.getChildDBName();
 216                 }
 217                 this.edgeQuery(type, parentName, childName);
 218                 return this;
 219
 220         }
 221
 222         /**
 223          * @throws NoEdgeRuleFoundException
 224          * @throws AAIException
 225          * @{inheritDoc}
 226          */
 227         @Override
 228         public QueryBuilder createEdgeTraversal(EdgeType type, Vertex parent, Introspector child) throws AAIException, NoEdgeRuleFoundException {
 229                 String nodeType = parent.<String>property(AAIProperties.NODE_TYPE).orElse(null);
 230                 this.edgeQuery(type, nodeType, child.getDbName());
 231
 232                 return this;
 233
 234         }
 235
 236         /**
 237          * Edge query.
 238          *
 239          * @param outType the out type
 240          * @param inType the in type
 241          * @throws NoEdgeRuleFoundException
 242          * @throws AAIException
 243          */
 244         private void edgeQuery(EdgeType type, String outType, String inType) throws AAIException, NoEdgeRuleFoundException {
 245                 markParentBoundary();
 246                 EdgeRule rule = edgeRules.getEdgeRule(type, outType, inType);
 247                 if (rule.getDirection().equals(Direction.OUT)) {
 248                         list.add(".out('" + rule.getLabel() + "')");
 249                 } else {
 250                         list.add(".in('" + rule.getLabel() + "')");
 251                 }
 252                 list.add(".has('" + AAIProperties.NODE_TYPE + "', '" + inType + "')");
 253                 stepIndex += 2;
 254         }
 255         @Override
 256         public QueryBuilder limit(long amount) {
 257                 list.add(".limit(" + amount + ")");
 258                 return this;
 259         }
 260         /**
 261          * @{inheritDoc}
 262          */
 263         @Override
 264         public QueryBuilder createContainerQuery(Introspector obj) {
 265                 String type = obj.getChildDBName();
 266                 String abstractType = obj.getMetadata(ObjectMetadata.ABSTRACT);
 267                 if (abstractType != null) {
 268                         String[] inheritors = obj.getMetadata(ObjectMetadata.INHERITORS).split(",");
 269                         String[] wrapped = new String[inheritors.length];
 270                         StringBuilder command = new StringBuilder();
 271                         command.append("P.within(");
 272                         for (int i = 0; i < inheritors.length; i++) {
 273                                 wrapped[i] = "'" + inheritors[i] + "'";
 274                         }
 275                         command.append(Joiner.on(",").join(wrapped));
 276                         command.append(")");
 277                         list.add(".has('aai-node-type', " + command + ")");
 278
 279                 } else {
 280                         list.add(".has('aai-node-type', '" + type + "')");
 281                 }
 282                 stepIndex++;
 283                 this.markContainer();
 284                 return this;
 285         }
 286
 287         @Override
 288         public QueryBuilder union(QueryBuilder... builder) {
 289                 markParentBoundary();
 290                 String[] traversals = new String[builder.length];
 291                 StringBuilder command = new StringBuilder();
 292                 for (int i = 0; i < builder.length; i++) {
 293                         traversals[i] = "__" + (String)builder[i].getQuery();
 294                 }
 295                 command.append(".union(");
 296                 command.append(Joiner.on(",").join(traversals));
 297                 command.append(")");
 298                 list.add(command.toString());
 299                 stepIndex++;
 300
 301                 return this;
 302         }
 303
 304         @Override
 305         public QueryBuilder where(QueryBuilder... builder) {
 306                 markParentBoundary();
 307                 List<String> traversals = new ArrayList<>();
 308                 for (int i = 0; i < builder.length; i++) {
 309                         traversals.add(".where(__" + (String)builder[i].getQuery() + ")");
 310                         stepIndex++;
 311                 }
 312                 list.addAll(traversals);
 313
 314
 315                 return this;
 316         }
 317
 318         /**
 319          * @{inheritDoc}
 320          */
 321         @Override
 322         public QueryBuilder getParentQuery() {
 323                 return cloneQueryAtStep(parentStepIndex);
 324         }
 325
 326         @Override
 327         public QueryBuilder getContainerQuery() {
 328                 return cloneQueryAtStep(containerStepIndex);
 329         }
 330
 331         /**
 332          * @{inheritDoc}
 333          */
 334         @Override
 335         public <T> T getQuery() {
 336                 StringBuilder sb = new StringBuilder();
 337
 338                 for (String piece : this.list) {
 339                         sb.append(piece);
 340                 }
 341
 342                 return (T)sb.toString();
 343         }
 344
 345         /**
 346          * @{inheritDoc}
 347          */
 348         @Override
 349         public void markParentBoundary() {
 350                 parentStepIndex = stepIndex;
 351         }
 352
 353         @Override
 354         public void markContainer() {
 355                 this.containerStepIndex = stepIndex;
 356         }
 357
 358         protected abstract QueryBuilder cloneQueryAtStep(int index);
 359         /**
 360          * @{inheritDoc}
 361          */
 362         @Override
 363         public Vertex getStart() {
 364                 return this.start;
 365         }
 366
 367         protected int getParentStepIndex() {
 368                 return parentStepIndex;
 369         }
 370
 371         protected int getContainerStepIndex() {
 372                 return containerStepIndex;
 373         }
 374
 375         protected int getStepIndex() {
 376                 return stepIndex;
 377         }
 378
 379         private void executeQuery() {
 380                 String queryString = "g" + Joiner.on("").join(list);
 381                 Map<String, Object> params = new HashMap<>();
 382                 if (this.start == null) {
 383                         params.put("g", source.V());
 384                 } else {
 385                         params.put("g", source.V(this.start));
 386                 }
 387                 this.completeTraversal = this.gremlinGroovy.executeTraversal(queryString, params);
 388         }
 389         @Override
 390         public boolean hasNext() {
 391                 if (this.completeTraversal == null) {
 392                         executeQuery();
 393                 }
 394
 395                 return this.completeTraversal.hasNext();
 396         }
 397
 398         @Override
 399         public Vertex next() {
 400                 if (this.completeTraversal == null) {
 401                         executeQuery();
 402                 }
 403
 404                 return (Vertex)this.completeTraversal.next();
 405         }
 406
 407         @Override
 408         public List<Vertex> toList() {
 409                 if (this.completeTraversal == null) {
 410                         executeQuery();
 411                 }
 412
 413                 return (List<Vertex>)this.completeTraversal.toList();
 414         }
 415
 416 }