@finos/legend-graph 31.1.10 → 31.2.1

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ExecutionPlanBuilder.ts

@@ -86,7 +86,54 @@ import { JavaPlatformImplementation } from '../../../../../../../graph/metamodel
 import { V1_JavaPlatformImplementation } from '../../../model/executionPlan/nodes/V1_JavaPlatformImplementation.js';
 import type { V1_JavaClass } from '../../../model/executionPlan/nodes/V1_JavaClass.js';
 import { JavaClass } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/JavaClass.js';
-import { V1_buildValueSpecification } from './helpers/V1_ValueSpecificationBuilderHelper.js';
+import {
+  V1_buildValueSpecification,
+  V1_buildGraphFetchTree,
+  V1_ValueSpecificationBuilder,
+} from './helpers/V1_ValueSpecificationBuilderHelper.js';
+import { V1_GlobalGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_GlobalGraphFetchExecutionNode.js';
+import { GlobalGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/GlobalGraphFetchExecutionNode.js';
+import type { V1_XStorePropertyFetchDetails } from '../../../model/packageableElements/mapping/xStore/V1_XStorePropertyFetchDetails.js';
+import { XStorePropertyFetchDetails } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/xStore/XStorePropertyFetchDetails.js';
+import { V1_StoreMappingGlobalGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_StoreMappingGlobalGraphFetchExecutionNode.js';
+import { StoreMappingGlobalGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/StoreMappingGlobalGraphFetchExecutionNode.js';
+import { V1_ProcessingContext } from './helpers/V1_ProcessingContext.js';
+import { V1_RelationalClassQueryTempTableGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_RelationalClassQueryTempTableGraphFetchExecutionNode.js';
+import { RelationalClassQueryTempTableGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalClassQueryTempTableGraphFetchExecutionNode.js';
+import type { LocalGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/LocalGraphFetchExecutionNode.js';
+import type { RelationalGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalGraphFetchExecutionNode.js';
+import { V1_RelationalRootQueryTempTableGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_RelationalRootQueryTempTableGraphFetchExecutionNode.js';
+import { RelationalRootQueryTempTableGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalRootQueryTempTableGraphFetchExecutionNode.js';
+import { Class } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Class.js';
+import { V1_RootGraphFetchTree } from '../../../model/valueSpecification/raw/classInstance/graph/V1_RootGraphFetchTree.js';
+import type { V1_TempTableStrategy } from '../../../model/executionPlan/nodes/V1_TempTableStrategy.js';
+import type { TempTableStrategy } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/TempTableStrategy.js';
+import { PureExpressionPlatformExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/PureExpressionPlatformExecutionNode.js';
+import { V1_PureExpressionPlatformExecutionNode } from '../../../model/executionPlan/nodes/V1_PureExpressionPlatformExecutionNode.js';
+import { V1_PartialClassResultType } from '../../../model/executionPlan/results/V1_PartialClassResultType.js';
+import { PartialClassResultType } from '../../../../../../../graph/metamodel/pure/executionPlan/result/PartialClassResultType.js';
+import type { V1_SetImplementationPtr } from '../../../model/executionPlan/results/V1_SetImplementationPtr.js';
+import { SetImplementationPtr } from '../../../../../../../graph/metamodel/pure/executionPlan/result/SetImplementationPtr.js';
+import { PropertyMapping } from '../../../../../../../graph/metamodel/pure/executionPlan/result/PropertyMapping.js';
+import type { V1_PropertyMapping } from '../../../model/executionPlan/results/V1_PropertyMapping.js';
+import type { V1_PropertyWithParameters } from '../../../model/executionPlan/results/V1_PropertyWithParameters.js';
+import { PropertyWithParameters } from '../../../../../../../graph/metamodel/pure/executionPlan/result/PropertyWithParameters.js';
+import { V1_InMemoryRootGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_InMemoryRootGraphFetchExecutionNode.js';
+import { InMemoryRootGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryRootGraphFetchExecutionNode.js';
+import { V1_InMemoryPropertyGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_InMemoryPropertyGraphFetchExecutionNode.js';
+import { InMemoryPropertyGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryPropertyGraphFetchExecutionNode.js';
+import { V1_LoadFromResultSetAsValueTuplesTempTableStrategy } from '../../../model/executionPlan/nodes/V1_LoadFromResultSetAsValueTuplesTempTableStrategy.js';
+import { V1_LoadFromSubQueryTempTableStrategy } from '../../../model/executionPlan/nodes/V1_LoadFromSubQueryTempTableStrategy.js';
+import { V1_LoadFromTempFileTempTableStrategy } from '../../../model/executionPlan/nodes/V1_LoadFromTempFileTempTableStrategy.js';
+import { LoadFromResultSetAsValueTuplesTempTableStrategy } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromResultSetAsValueTuplesTempTableStrategy.js';
+import { LoadFromSubQueryTempTableStrategy } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromSubQueryTempTableStrategy.js';
+import { LoadFromTempFileTempTableStrategy } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromTempFileTempTableStrategy.js';
+import { V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode.js';
+import { RelationalCrossRootQueryTempTableGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalCrossRootQueryTempTableGraphFetchExecutionNode.js';
+import type { InMemoryGraphFetchExecutionNode } from '../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryGraphFetchExecutionNode.js';
+import { V1_InMemoryGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_InMemoryGraphFetchExecutionNode.js';
+import { V1_RelationalGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_RelationalGraphFetchExecutionNode.js';
+import type { V1_LocalGraphFetchExecutionNode } from '../../../model/executionPlan/nodes/V1_LocalGraphFetchExecutionNode.js';
 
 export const V1_parseDataType = (val: string): RelationalDataType => {
   const getTypeParams = (typeVal: string): number[] =>
@@ -210,6 +257,62 @@ const buildTDSResultType = (
   return metamodel;
 };
 
+const buildPropertyMapping = (
+  protocol: V1_PropertyMapping,
+): PropertyMapping => {
+  const metamodel = new PropertyMapping();
+  metamodel.property = protocol.property;
+  metamodel.type = protocol.type;
+  metamodel.enumMapping = protocol.enumMapping;
+  return metamodel;
+};
+
+const buildSetImplementation = (
+  protocol: V1_SetImplementationPtr,
+): SetImplementationPtr => {
+  const metamodel = new SetImplementationPtr();
+  metamodel.class = protocol.class;
+  metamodel.mapping = protocol.mapping;
+  metamodel.id = protocol.id;
+  metamodel.propertyMappings =
+    protocol.propertyMappings.map(buildPropertyMapping);
+  return metamodel;
+};
+
+const buildPropertiesWithParameters = (
+  protocol: V1_PropertyWithParameters,
+  context: V1_GraphBuilderContext,
+): PropertyWithParameters => {
+  const metamodel = new PropertyWithParameters();
+  metamodel.property = protocol.property;
+  metamodel.parameters = protocol.parameters.map((parameter) =>
+    parameter.accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        context,
+        new V1_ProcessingContext(''),
+        [],
+        false,
+      ),
+    ),
+  );
+  return metamodel;
+};
+
+const buildPartialClassResultType = (
+  protocol: V1_PartialClassResultType,
+  context: V1_GraphBuilderContext,
+): PartialClassResultType => {
+  const metamodel = new PartialClassResultType();
+  metamodel.type = context.resolveType(protocol.class);
+  metamodel.setImplementations = protocol.setImplementations.map(
+    buildSetImplementation,
+  );
+  metamodel.propertiesWithParameters = protocol.propertiesWithParameters.map(
+    (p) => buildPropertiesWithParameters(p, context),
+  );
+  return metamodel;
+};
+
 const buildResultType = (
   protocol: V1_ResultType,
   context: V1_GraphBuilderContext,
@@ -223,6 +326,8 @@ const buildResultType = (
     return buildDataTypeResultType(protocol, context);
   } else if (protocol instanceof V1_TDSResultType) {
     return buildTDSResultType(protocol, context);
+  } else if (protocol instanceof V1_PartialClassResultType) {
+    return buildPartialClassResultType(protocol, context);
   }
   throw new UnsupportedOperationError(
     `Can't build execution node result type`,
@@ -285,7 +390,15 @@ const buildBaseExecutionNode = (
   metamodel.executionNodes = protocol.executionNodes.map((node) =>
     buildExecutionNode(node, context),
   );
-  metamodel.implementation = protocol.implementation;
+  metamodel.authDependent = protocol.authDependent;
+  if (
+    protocol.implementation &&
+    protocol.implementation instanceof V1_JavaPlatformImplementation
+  ) {
+    metamodel.implementation = buildPlatformImplementation(
+      protocol.implementation,
+    );
+  }
 };
 
 const buildSQLExecutionNode = (
@@ -364,6 +477,464 @@ const buildSequenceExecutionNode = (
   return metamodel;
 };
 
+const buildLoadFromResultSetAsValueTuplesTempTableStrategy = (
+  protocol: V1_LoadFromResultSetAsValueTuplesTempTableStrategy,
+  context: V1_GraphBuilderContext,
+): LoadFromResultSetAsValueTuplesTempTableStrategy => {
+  const metamodel = new LoadFromResultSetAsValueTuplesTempTableStrategy();
+  metamodel.createTempTableNode = buildExecutionNode(
+    protocol.createTempTableNode,
+    context,
+  );
+  metamodel.dropTempTableNode = buildExecutionNode(
+    protocol.dropTempTableNode,
+    context,
+  );
+  metamodel.loadTempTableNode = buildExecutionNode(
+    protocol.loadTempTableNode,
+    context,
+  );
+  metamodel.tupleBatchSize = protocol.tupleBatchSize;
+  return metamodel;
+};
+
+const buildLoadFromSubQueryTempTableStrategy = (
+  protocol: V1_LoadFromSubQueryTempTableStrategy,
+  context: V1_GraphBuilderContext,
+): LoadFromSubQueryTempTableStrategy => {
+  const metamodel = new LoadFromSubQueryTempTableStrategy();
+  metamodel.createTempTableNode = buildExecutionNode(
+    protocol.createTempTableNode,
+    context,
+  );
+  metamodel.dropTempTableNode = buildExecutionNode(
+    protocol.dropTempTableNode,
+    context,
+  );
+  metamodel.loadTempTableNode = buildExecutionNode(
+    protocol.loadTempTableNode,
+    context,
+  );
+  return metamodel;
+};
+
+const buildLoadFromTempFileTempTableStrategy = (
+  protocol: V1_LoadFromTempFileTempTableStrategy,
+  context: V1_GraphBuilderContext,
+): LoadFromTempFileTempTableStrategy => {
+  const metamodel = new LoadFromTempFileTempTableStrategy();
+  metamodel.createTempTableNode = buildExecutionNode(
+    protocol.createTempTableNode,
+    context,
+  );
+  metamodel.dropTempTableNode = buildExecutionNode(
+    protocol.dropTempTableNode,
+    context,
+  );
+  metamodel.loadTempTableNode = buildExecutionNode(
+    protocol.loadTempTableNode,
+    context,
+  );
+  return metamodel;
+};
+
+const buildTempTableStrategy = (
+  protocol: V1_TempTableStrategy,
+  context: V1_GraphBuilderContext,
+): TempTableStrategy => {
+  if (protocol instanceof V1_LoadFromResultSetAsValueTuplesTempTableStrategy) {
+    return buildLoadFromResultSetAsValueTuplesTempTableStrategy(
+      protocol,
+      context,
+    );
+  }
+  if (protocol instanceof V1_LoadFromSubQueryTempTableStrategy) {
+    return buildLoadFromSubQueryTempTableStrategy(protocol, context);
+  }
+  if (protocol instanceof V1_LoadFromTempFileTempTableStrategy) {
+    return buildLoadFromTempFileTempTableStrategy(protocol, context);
+  }
+  throw new UnsupportedOperationError(
+    `Can't build temp table strategy`,
+    protocol,
+  );
+};
+
+const buildRelationalClassQueryTempTableGraphFetchExecutionNode = (
+  protocol: V1_RelationalClassQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): RelationalClassQueryTempTableGraphFetchExecutionNode => {
+  const metamodel = new RelationalClassQueryTempTableGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.nodeIndex = protocol.nodeIndex;
+  metamodel.parentIndex = protocol.parentIndex;
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildRelationalGraphFetchExecutionNode(child, context, parentClass),
+  );
+  metamodel.tempTableName = protocol.tempTableName;
+  metamodel.processedTempTableName = protocol.tempTableName;
+  metamodel.columns = protocol.columns.map(buildSQLResultColumn);
+  if (protocol.tempTableStrategy) {
+    metamodel.tempTableStrategy = buildTempTableStrategy(
+      protocol.tempTableStrategy,
+      context,
+    );
+  }
+  return metamodel;
+};
+
+const buildRelationalRootQueryTempTableGraphFetchExecutionNode = (
+  protocol: V1_RelationalRootQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): RelationalRootQueryTempTableGraphFetchExecutionNode => {
+  const metamodel = new RelationalRootQueryTempTableGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.nodeIndex = protocol.nodeIndex;
+  metamodel.parentIndex = protocol.parentIndex;
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildRelationalGraphFetchExecutionNode(child, context, parentClass),
+  );
+  metamodel.tempTableName = protocol.tempTableName;
+  metamodel.processedTempTableName = protocol.tempTableName;
+  metamodel.columns = protocol.columns.map(buildSQLResultColumn);
+  if (protocol.tempTableStrategy) {
+    metamodel.tempTableStrategy = buildTempTableStrategy(
+      protocol.tempTableStrategy,
+      context,
+    );
+  }
+  metamodel.batchSize = protocol.batchSize;
+  metamodel.checked = protocol.checked;
+  return metamodel;
+};
+
+const buildRelationalCrossRootQueryTempTableGraphFetchExecutionNode = (
+  protocol: V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): RelationalCrossRootQueryTempTableGraphFetchExecutionNode => {
+  const metamodel =
+    new RelationalCrossRootQueryTempTableGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.nodeIndex = protocol.nodeIndex;
+  metamodel.parentIndex = protocol.parentIndex;
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildRelationalGraphFetchExecutionNode(child, context, parentClass),
+  );
+  metamodel.tempTableName = protocol.tempTableName;
+  metamodel.processedTempTableName = protocol.tempTableName;
+  metamodel.columns = protocol.columns.map(buildSQLResultColumn);
+  if (protocol.tempTableStrategy) {
+    metamodel.tempTableStrategy = buildTempTableStrategy(
+      protocol.tempTableStrategy,
+      context,
+    );
+  }
+  metamodel.parentTempTableName = protocol.parentTempTableName;
+  metamodel.processedParentTempTableName =
+    protocol.processedParentTempTableName;
+  metamodel.parentTempTableColumns =
+    protocol.parentTempTableColumns.map(buildSQLResultColumn);
+  if (protocol.parentTempTableStrategy) {
+    metamodel.parentTempTableStrategy = buildTempTableStrategy(
+      protocol.parentTempTableStrategy,
+      context,
+    );
+  }
+  return metamodel;
+};
+
+function buildRelationalGraphFetchExecutionNode(
+  protocol: V1_RelationalGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): RelationalGraphFetchExecutionNode {
+  if (
+    protocol instanceof
+    V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalCrossRootQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  } else if (
+    protocol instanceof V1_RelationalRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalRootQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  } else if (
+    protocol instanceof V1_RelationalClassQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalClassQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't build RelationalGraphFetchExecutionNode`,
+    protocol,
+  );
+}
+
+const buildPureExpressionPlatformExecutionNode = (
+  protocol: V1_PureExpressionPlatformExecutionNode,
+  context: V1_GraphBuilderContext,
+): PureExpressionPlatformExecutionNode => {
+  const metamodel = new PureExpressionPlatformExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.pure = protocol.pure;
+  return metamodel;
+};
+
+const buildInMemoryPropertyGraphFetchExecutionNode = (
+  protocol: V1_InMemoryPropertyGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): InMemoryPropertyGraphFetchExecutionNode => {
+  const metamodel = new InMemoryPropertyGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.nodeIndex = protocol.nodeIndex;
+  metamodel.parentIndex = protocol.parentIndex;
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildInMemoryGraphFetchExecutionNode(child, context, parentClass),
+  );
+  return metamodel;
+};
+
+const buildInMemoryRootGraphFetchExecutionNode = (
+  protocol: V1_InMemoryRootGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): InMemoryRootGraphFetchExecutionNode => {
+  const metamodel = new InMemoryRootGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  metamodel.nodeIndex = protocol.nodeIndex;
+  metamodel.parentIndex = protocol.parentIndex;
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildInMemoryGraphFetchExecutionNode(child, context, parentClass),
+  );
+  metamodel.batchSize = protocol.batchSize;
+  metamodel.checked = protocol.checked;
+  metamodel.filter = protocol.filter;
+  return metamodel;
+};
+
+function buildInMemoryGraphFetchExecutionNode(
+  protocol: V1_InMemoryGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): InMemoryGraphFetchExecutionNode {
+  if (protocol instanceof V1_InMemoryRootGraphFetchExecutionNode) {
+    return buildInMemoryRootGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  } else if (protocol instanceof V1_InMemoryPropertyGraphFetchExecutionNode) {
+    return buildInMemoryPropertyGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't build InMemoryGraphFetchExecutionNode`,
+    protocol,
+  );
+}
+
+const buildLocalGraphFetchExecutionNode = (
+  protocol: V1_LocalGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): LocalGraphFetchExecutionNode => {
+  if (protocol instanceof V1_RelationalGraphFetchExecutionNode) {
+    return buildRelationalGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  } else if (protocol instanceof V1_InMemoryGraphFetchExecutionNode) {
+    return buildInMemoryGraphFetchExecutionNode(protocol, context, parentClass);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform LocalGraphFetchExecutionNode`,
+    protocol,
+  );
+};
+
+const buildGlobalGraphFetchExecutionNode = (
+  protocol: V1_GlobalGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): GlobalGraphFetchExecutionNode => {
+  const metamodel = new GlobalGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildGlobalGraphFetchExecutionNodeHelper(child, context, parentClass),
+  );
+  metamodel.localGraphFetchExecutionNode = buildLocalGraphFetchExecutionNode(
+    protocol.localGraphFetchExecutionNode,
+    context,
+    parentClass,
+  );
+  metamodel.parentIndex = protocol.parentIndex;
+  metamodel.enableConstraints = protocol.enableConstraints;
+  metamodel.checked = protocol.checked;
+  metamodel.localTreeIndices = protocol.localTreeIndices;
+  metamodel.dependencyIndices = protocol.dependencyIndices;
+  return metamodel;
+};
+
+const buildXStorePropertyFetchDetails = (
+  protocol: V1_XStorePropertyFetchDetails,
+): XStorePropertyFetchDetails => {
+  const metamodel = new XStorePropertyFetchDetails();
+  metamodel.supportsCaching = protocol.supportsCaching;
+  metamodel.propertyPath = protocol.propertyPath;
+  metamodel.sourceMappingId = protocol.sourceMappingId;
+  metamodel.sourceSetId = protocol.sourceSetId;
+  metamodel.targetMappingId = protocol.targetMappingId;
+  metamodel.targetSetId = protocol.targetSetId;
+  metamodel.subTree = protocol.subTree;
+  metamodel.targetPropertiesOrdered = protocol.targetPropertiesOrdered;
+  return metamodel;
+};
+
+const buildStoreMappingGlobalGraphFetchExecutionNode = (
+  protocol: V1_StoreMappingGlobalGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): StoreMappingGlobalGraphFetchExecutionNode => {
+  const metamodel = new StoreMappingGlobalGraphFetchExecutionNode();
+  buildBaseExecutionNode(metamodel, protocol, context);
+  if (protocol.graphFetchTree instanceof V1_RootGraphFetchTree) {
+    parentClass = context.resolveClass(protocol.graphFetchTree.class).value;
+  }
+  metamodel.graphFetchTree = V1_buildGraphFetchTree(
+    protocol.graphFetchTree,
+    context,
+    guaranteeType(parentClass, Class),
+    [],
+    new V1_ProcessingContext(''),
+    true,
+  );
+  metamodel.children = protocol.children.map((child) =>
+    buildGlobalGraphFetchExecutionNodeHelper(child, context, parentClass),
+  );
+  metamodel.localGraphFetchExecutionNode = buildLocalGraphFetchExecutionNode(
+    protocol.localGraphFetchExecutionNode,
+    context,
+    parentClass,
+  );
+  metamodel.parentIndex = protocol.parentIndex;
+  metamodel.enableConstraints = protocol.enableConstraints;
+  metamodel.checked = protocol.checked;
+  metamodel.localTreeIndices = protocol.localTreeIndices;
+  metamodel.dependencyIndices = protocol.dependencyIndices;
+  metamodel.store = protocol.store;
+  if (protocol.xStorePropertyFetchDetails) {
+    metamodel.xStorePropertyFetchDetails = buildXStorePropertyFetchDetails(
+      protocol.xStorePropertyFetchDetails,
+    );
+  }
+  metamodel.xStorePropertyMapping = protocol.xStorePropertyMapping;
+  return metamodel;
+};
+
+function buildGlobalGraphFetchExecutionNodeHelper(
+  protocol: V1_GlobalGraphFetchExecutionNode,
+  context: V1_GraphBuilderContext,
+  parentClass?: Class | undefined,
+): GlobalGraphFetchExecutionNode {
+  if (protocol instanceof V1_StoreMappingGlobalGraphFetchExecutionNode) {
+    return buildStoreMappingGlobalGraphFetchExecutionNode(
+      protocol,
+      context,
+      parentClass,
+    );
+  } else if (protocol instanceof V1_GlobalGraphFetchExecutionNode) {
+    return buildGlobalGraphFetchExecutionNode(protocol, context, parentClass);
+  }
+  throw new UnsupportedOperationError(
+    `Can't build GlobalGraphFetchExecutionNode`,
+    protocol,
+  );
+}
+
 function buildExecutionNode(
   protocol: V1_ExecutionNode,
   context: V1_GraphBuilderContext,
@@ -385,6 +956,38 @@ function buildExecutionNode(
     return buildConstantExecutionNode(protocol, context);
   } else if (protocol instanceof V1_SequenceExecutionNode) {
     return buildSequenceExecutionNode(protocol, context);
+  } else if (protocol instanceof V1_StoreMappingGlobalGraphFetchExecutionNode) {
+    return buildStoreMappingGlobalGraphFetchExecutionNode(protocol, context);
+  } else if (protocol instanceof V1_GlobalGraphFetchExecutionNode) {
+    return buildGlobalGraphFetchExecutionNode(protocol, context);
+  } else if (
+    protocol instanceof
+    V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalCrossRootQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+    );
+  } else if (
+    protocol instanceof V1_RelationalRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalRootQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+    );
+  } else if (
+    protocol instanceof V1_RelationalClassQueryTempTableGraphFetchExecutionNode
+  ) {
+    return buildRelationalClassQueryTempTableGraphFetchExecutionNode(
+      protocol,
+      context,
+    );
+  } else if (protocol instanceof V1_PureExpressionPlatformExecutionNode) {
+    return buildPureExpressionPlatformExecutionNode(protocol, context);
+  } else if (protocol instanceof V1_InMemoryRootGraphFetchExecutionNode) {
+    return buildInMemoryRootGraphFetchExecutionNode(protocol, context);
+  } else if (protocol instanceof V1_InMemoryPropertyGraphFetchExecutionNode) {
+    return buildInMemoryPropertyGraphFetchExecutionNode(protocol, context);
   }
   throw new UnsupportedOperationError(`Can't build execution node`, protocol);
 }