AMBARI-20215. Select operators should not appear before fetch (pallavkul)

contrib/views/hive20/src/main/resources/ui/app/utils/hive-explainer/processor.js

@@ -260,3 +260,70 @@ export function getEdgesWithCorrectedUnion(edges) {
       });
 
 }
+
+// DANGER: impure function
+// DANGER: breaks if there is a many-one / one-many connection
+export function getAdjustedVerticesAndEdges(vertices, edges) {
+
+  vertices
+    .filter(cVertex => ['Select Operator', 'HASHTABLEDUMMY', 'File Output Operator'].indexOf(getFirstOperatorOf(cVertex)._operator) >= 0)
+    .map(cVertex => edges.filter(cEdge => cEdge._target === cVertex._vertex))
+    .forEach(cEdges => {
+      const source = vertices.find(cVertex => cEdges.some(tcEdge => cVertex._vertex === tcEdge._source));
+      const target = vertices.find(cVertex => cEdges.some(tcEdge => cVertex._vertex === tcEdge._target));
+
+      const operatorLastOfSource = getLastOperatorOf(source);
+      const operatorFirstOfTarget = getFirstOperatorOf(target);
+
+      operatorLastOfSource._groups = [
+        ...(operatorLastOfSource._groups || [doCloneAndOmit(operatorLastOfSource, ['_groups'])]),
+        ...(operatorFirstOfTarget._groups || [doCloneAndOmit(operatorFirstOfTarget, ['_groups'])]),
+      ];
+      target._children = operatorFirstOfTarget._children;
+
+      target._isGroupedWith = source._vertex;
+    });
+
+  // cleanup
+  const adjustedVertices = vertices.filter(cVertex => cVertex._children.length > 0);
+  const cleanedVertices = vertices.filter(cVertex => cVertex._children.length === 0);
+  console.log(cleanedVertices);
+
+  const adjustedEdges =
+    edges
+      .reduce((accumulator, cEdge) => {
+        const cleanedAtSourceVertex = cleanedVertices.find(cVertex => cEdge._source === cVertex._vertex);
+        const cleanedAtTargetVertex = cleanedVertices.find(cVertex => cEdge._target === cVertex._vertex);
+        if(cleanedAtSourceVertex) {
+          // do not add edge back
+          // add new edge instead
+          accumulator.push(Object.assign({}, cEdge, {
+            _source: cleanedAtSourceVertex._isGroupedWith,
+            _target: cEdge._target
+          }));
+        } else if(cleanedAtTargetVertex) {
+          // do not add edge back
+        } else {
+          accumulator.push(cEdge);
+        }
+        return accumulator;
+      }, []);
+
+  return ({
+    adjustedVertices,
+    adjustedEdges
+  });
+}
+
+
+function getLastOperatorOf(vertex) {
+  let operator = vertex._children[0];
+  while(operator._children.length > 0) {
+    operator = operator._children[0];
+  }
+  return operator;
+}
+
+function getFirstOperatorOf(vertex) {
+  return vertex._children[0];
+}

contrib/views/hive20/src/main/resources/ui/app/utils/hive-explainer/renderer.js

@@ -18,7 +18,7 @@
 
 export default function doRender(data, selector, onRequestDetail) {
 
-  const width = '1200', height = '960';
+  const width = '1600', height = '800';
 
   d3.select(selector).select('*').remove();
   const svg =

contrib/views/hive20/src/main/resources/ui/app/utils/hive-explainer/transformer.js

@@ -17,37 +17,42 @@
  */
 
 import doEnhance from './enhancer';
-import {getProcessedVertices, getEdgesWithCorrectedUnion} from './processor';
+import {getProcessedVertices, getEdgesWithCorrectedUnion, getAdjustedVerticesAndEdges} from './processor';
 
 export default function doTransform(data) {
   const plan = getTezPlan(data);
   const fetch = getFetchPlan(data);
 
-  const vertices = [
+  let vertices = [
     ...getVertices(plan),
     getFetchVertex(fetch)
   ];
 
-  const tezEdges = getEdges(plan, vertices);
-  const edgesWithCorrectedUnion = getEdgesWithCorrectedUnion(tezEdges);
-  const edges = getEdgesWithFetch(edgesWithCorrectedUnion, vertices);
+  let edges = getEdges(plan, vertices);
+  edges = getEdgesWithCorrectedUnion(edges);
+  edges = getEdgesWithFetch(edges, vertices);
 
-  const enhancedVertices = doEnhance(vertices);
+  vertices = doEnhance(vertices);
 
-  const processedVertices = getProcessedVertices(enhancedVertices, edges);
+  vertices = getProcessedVertices(vertices, edges);
 
-  const verticesWithIndexOfChildren = getVerticesWithIndexOfChildren(processedVertices);
+  const {adjustedVertices, adjustedEdges} = getAdjustedVerticesAndEdges(vertices, edges);
+  vertices = adjustedVertices;
+  edges = adjustedEdges;
 
-  const tree = getVertexTree(edges);
-  const connections = getConnections(verticesWithIndexOfChildren, edges);
-  const treeWithOffsetY = getTreeWithOffsetAndHeight(tree, verticesWithIndexOfChildren, connections);
+  vertices = getVerticesWithIndexOfChildren(vertices);
 
-  const nodes = getNodes(verticesWithIndexOfChildren);
+  let tree = getVertexTree(edges);
+
+  const connections = getConnections(vertices, edges);
+  tree = getTreeWithOffsetAndHeight(tree, vertices, connections);
+
+  const nodes = getNodes(vertices);
 
   return ({
-    vertices: verticesWithIndexOfChildren,
+    vertices,
     edges,
-    tree: treeWithOffsetY,
+    tree,
     nodes,
     connections,
   });