@finos/legend-graph 31.1.10 → 31.2.0

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/executionPlan/V1_ExecutionPlanTransformer.ts

@@ -67,6 +67,50 @@ import type { PlatformImplementation } from '../../../../../../../../graph/metam
 import type { V1_PlatformImplementation } from '../../../../model/executionPlan/nodes/V1_PlatformImplementation.js';
 import { JavaPlatformImplementation } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/JavaPlatformImplementation.js';
 import { V1_JavaPlatformImplementation } from '../../../../model/executionPlan/nodes/V1_JavaPlatformImplementation.js';
+import { GlobalGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/GlobalGraphFetchExecutionNode.js';
+import { V1_GlobalGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_GlobalGraphFetchExecutionNode.js';
+import type { XStorePropertyFetchDetails } from '../../../../../../../../graph/metamodel/pure/packageableElements/mapping/xStore/XStorePropertyFetchDetails.js';
+import { V1_XStorePropertyFetchDetails } from '../../../../model/packageableElements/mapping/xStore/V1_XStorePropertyFetchDetails.js';
+import { StoreMappingGlobalGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/StoreMappingGlobalGraphFetchExecutionNode.js';
+import { V1_StoreMappingGlobalGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_StoreMappingGlobalGraphFetchExecutionNode.js';
+import {
+  V1_transformGraphFetchTree,
+  V1_transformRootValueSpecification,
+} from '../V1_ValueSpecificationTransformer.js';
+import type { V1_LocalGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_LocalGraphFetchExecutionNode.js';
+import type { V1_RelationalGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_RelationalGraphFetchExecutionNode.js';
+import { RelationalClassQueryTempTableGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalClassQueryTempTableGraphFetchExecutionNode.js';
+import { V1_RelationalClassQueryTempTableGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_RelationalClassQueryTempTableGraphFetchExecutionNode.js';
+import { RelationalRootQueryTempTableGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalRootQueryTempTableGraphFetchExecutionNode.js';
+import { V1_RelationalRootQueryTempTableGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_RelationalRootQueryTempTableGraphFetchExecutionNode.js';
+import type { TempTableStrategy } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/TempTableStrategy.js';
+import type { V1_TempTableStrategy } from '../../../../model/executionPlan/nodes/V1_TempTableStrategy.js';
+import { PureExpressionPlatformExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/PureExpressionPlatformExecutionNode.js';
+import { V1_PureExpressionPlatformExecutionNode } from '../../../../model/executionPlan/nodes/V1_PureExpressionPlatformExecutionNode.js';
+import { V1_PropertyMapping } from '../../../../model/executionPlan/results/V1_PropertyMapping.js';
+import type { PropertyMapping } from '../../../../../../../../graph/metamodel/pure/executionPlan/result/PropertyMapping.js';
+import type { SetImplementationPtr } from '../../../../../../../../graph/metamodel/pure/executionPlan/result/SetImplementationPtr.js';
+import { V1_SetImplementationPtr } from '../../../../model/executionPlan/results/V1_SetImplementationPtr.js';
+import { PartialClassResultType } from '../../../../../../../../graph/metamodel/pure/executionPlan/result/PartialClassResultType.js';
+import { V1_PartialClassResultType } from '../../../../model/executionPlan/results/V1_PartialClassResultType.js';
+import type { PropertyWithParameters } from '../../../../../../../../graph/metamodel/pure/executionPlan/result/PropertyWithParameters.js';
+import { V1_PropertyWithParameters } from '../../../../model/executionPlan/results/V1_PropertyWithParameters.js';
+import { InMemoryPropertyGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryPropertyGraphFetchExecutionNode.js';
+import { V1_InMemoryPropertyGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_InMemoryPropertyGraphFetchExecutionNode.js';
+import { InMemoryRootGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryRootGraphFetchExecutionNode.js';
+import { V1_InMemoryRootGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_InMemoryRootGraphFetchExecutionNode.js';
+import { InMemoryGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/InMemoryGraphFetchExecutionNode.js';
+import type { V1_InMemoryGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_InMemoryGraphFetchExecutionNode.js';
+import { LoadFromResultSetAsValueTuplesTempTableStrategy } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromResultSetAsValueTuplesTempTableStrategy.js';
+import { V1_LoadFromResultSetAsValueTuplesTempTableStrategy } from '../../../../model/executionPlan/nodes/V1_LoadFromResultSetAsValueTuplesTempTableStrategy.js';
+import { LoadFromSubQueryTempTableStrategy } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromSubQueryTempTableStrategy.js';
+import { V1_LoadFromSubQueryTempTableStrategy } from '../../../../model/executionPlan/nodes/V1_LoadFromSubQueryTempTableStrategy.js';
+import { LoadFromTempFileTempTableStrategy } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/LoadFromTempFileTempTableStrategy.js';
+import { V1_LoadFromTempFileTempTableStrategy } from '../../../../model/executionPlan/nodes/V1_LoadFromTempFileTempTableStrategy.js';
+import { RelationalCrossRootQueryTempTableGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalCrossRootQueryTempTableGraphFetchExecutionNode.js';
+import { V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode } from '../../../../model/executionPlan/nodes/V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode.js';
+import type { LocalGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/LocalGraphFetchExecutionNode.js';
+import { RelationalGraphFetchExecutionNode } from '../../../../../../../../graph/metamodel/pure/executionPlan/nodes/RelationalGraphFetchExecutionNode.js';
 
 // ---------------------------------------- Result Type ----------------------------------------
 
@@ -105,6 +149,55 @@ const transformTDSResultType = (
   return protocol;
 };
 
+const transformPropertyMapping = (
+  metamodel: PropertyMapping,
+): V1_PropertyMapping => {
+  const protocol = new V1_PropertyMapping();
+  protocol.property = metamodel.property;
+  protocol.type = metamodel.type;
+  protocol.enumMapping = metamodel.enumMapping;
+  return protocol;
+};
+
+const transformSetImplementation = (
+  metamodel: SetImplementationPtr,
+): V1_SetImplementationPtr => {
+  const protocol = new V1_SetImplementationPtr();
+  protocol.class = metamodel.class;
+  protocol.mapping = metamodel.mapping;
+  protocol.id = metamodel.id;
+  protocol.propertyMappings = metamodel.propertyMappings.map(
+    transformPropertyMapping,
+  );
+  return protocol;
+};
+
+const transformPropertiesWithParameters = (
+  metamodel: PropertyWithParameters,
+): V1_PropertyWithParameters => {
+  const protocol = new V1_PropertyWithParameters();
+  protocol.property = metamodel.property;
+  protocol.parameters = metamodel.parameters.map(
+    V1_transformRootValueSpecification,
+  );
+  return protocol;
+};
+
+const transformPartialClassResultType = (
+  metamodel: PartialClassResultType,
+  context: V1_GraphTransformerContext,
+): V1_PartialClassResultType => {
+  const protocol = new V1_PartialClassResultType();
+  protocol.class = metamodel.type.valueForSerialization ?? '';
+  protocol.setImplementations = metamodel.setImplementations.map(
+    transformSetImplementation,
+  );
+  protocol.propertiesWithParameters = metamodel.propertiesWithParameters.map(
+    transformPropertiesWithParameters,
+  );
+  return protocol;
+};
+
 const transformResultType = (
   metamodel: ResultType,
   context: V1_GraphTransformerContext,
@@ -117,6 +210,8 @@ const transformResultType = (
     return transformDataTypeResultType(metamodel, context);
   } else if (metamodel instanceof TDSResultType) {
     return transformTDSResultType(metamodel, context);
+  } else if (metamodel instanceof PartialClassResultType) {
+    return transformPartialClassResultType(metamodel, context);
   }
   throw new UnsupportedOperationError(
     `Can't transform execution node result type`,
@@ -174,7 +269,12 @@ const transformBaseExecutionNode = (
   protocol.executionNodes = metamodel.executionNodes.map((node) =>
     V1_transformExecutionNode(node, context),
   );
-  protocol.implementation = metamodel.implementation;
+  protocol.authDependent = metamodel.authDependent;
+  if (metamodel.implementation) {
+    protocol.implementation = transformPlatformImplementation(
+      metamodel.implementation,
+    );
+  }
 };
 
 const transformSQLExecutionNode = (
@@ -254,6 +354,408 @@ const transformRelationalTDSInstantiationExecutionNode = (
   return protocol;
 };
 
+const transformLoadFromResultSetAsValueTuplesTempTableStrategy = (
+  metamodel: LoadFromResultSetAsValueTuplesTempTableStrategy,
+  context: V1_GraphTransformerContext,
+): V1_LoadFromResultSetAsValueTuplesTempTableStrategy => {
+  const protocol = new V1_LoadFromResultSetAsValueTuplesTempTableStrategy();
+  protocol.createTempTableNode = V1_transformExecutionNode(
+    metamodel.createTempTableNode,
+    context,
+  );
+  protocol.dropTempTableNode = V1_transformExecutionNode(
+    metamodel.dropTempTableNode,
+    context,
+  );
+  protocol.loadTempTableNode = V1_transformExecutionNode(
+    metamodel.loadTempTableNode,
+    context,
+  );
+  protocol.tupleBatchSize = metamodel.tupleBatchSize;
+  return protocol;
+};
+
+const transformLoadFromSubQueryTempTableStrategy = (
+  metamodel: LoadFromSubQueryTempTableStrategy,
+  context: V1_GraphTransformerContext,
+): V1_LoadFromSubQueryTempTableStrategy => {
+  const protocol = new V1_LoadFromSubQueryTempTableStrategy();
+  protocol.createTempTableNode = V1_transformExecutionNode(
+    metamodel.createTempTableNode,
+    context,
+  );
+  protocol.dropTempTableNode = V1_transformExecutionNode(
+    metamodel.dropTempTableNode,
+    context,
+  );
+  protocol.loadTempTableNode = V1_transformExecutionNode(
+    metamodel.loadTempTableNode,
+    context,
+  );
+  return protocol;
+};
+
+const transformLoadFromTempFileTempTableStrategy = (
+  metamodel: LoadFromTempFileTempTableStrategy,
+  context: V1_GraphTransformerContext,
+): V1_LoadFromTempFileTempTableStrategy => {
+  const protocol = new V1_LoadFromTempFileTempTableStrategy();
+  protocol.createTempTableNode = V1_transformExecutionNode(
+    metamodel.createTempTableNode,
+    context,
+  );
+  protocol.dropTempTableNode = V1_transformExecutionNode(
+    metamodel.dropTempTableNode,
+    context,
+  );
+  protocol.loadTempTableNode = V1_transformExecutionNode(
+    metamodel.loadTempTableNode,
+    context,
+  );
+  return protocol;
+};
+
+const transformTempTableStrategy = (
+  metamodel: TempTableStrategy,
+  context: V1_GraphTransformerContext,
+): V1_TempTableStrategy => {
+  if (metamodel instanceof LoadFromResultSetAsValueTuplesTempTableStrategy) {
+    return transformLoadFromResultSetAsValueTuplesTempTableStrategy(
+      metamodel,
+      context,
+    );
+  }
+  if (metamodel instanceof LoadFromSubQueryTempTableStrategy) {
+    return transformLoadFromSubQueryTempTableStrategy(metamodel, context);
+  }
+  if (metamodel instanceof LoadFromTempFileTempTableStrategy) {
+    return transformLoadFromTempFileTempTableStrategy(metamodel, context);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform temp table strategy`,
+    metamodel,
+  );
+};
+
+const transformRelationalClassQueryTempTableGraphFetchExecutionNode = (
+  metamodel: RelationalClassQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_RelationalClassQueryTempTableGraphFetchExecutionNode => {
+  const protocol =
+    new V1_RelationalClassQueryTempTableGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.nodeIndex = metamodel.nodeIndex;
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformRelationalGraphFetchExecutionNode(child, context),
+  );
+  protocol.tempTableName = metamodel.tempTableName;
+  protocol.processedTempTableName = metamodel.tempTableName;
+  protocol.columns = metamodel.columns.map(transformSQLResultColumn);
+  if (metamodel.tempTableStrategy) {
+    protocol.tempTableStrategy = transformTempTableStrategy(
+      metamodel.tempTableStrategy,
+      context,
+    );
+  }
+  return protocol;
+};
+
+const transformRelationalRootQueryTempTableGraphFetchExecutionNode = (
+  metamodel: RelationalRootQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_RelationalRootQueryTempTableGraphFetchExecutionNode => {
+  const protocol = new V1_RelationalRootQueryTempTableGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.nodeIndex = metamodel.nodeIndex;
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformRelationalGraphFetchExecutionNode(child, context),
+  );
+  protocol.tempTableName = metamodel.tempTableName;
+  protocol.processedTempTableName = metamodel.tempTableName;
+  protocol.columns = metamodel.columns.map(transformSQLResultColumn);
+  if (metamodel.tempTableStrategy) {
+    protocol.tempTableStrategy = transformTempTableStrategy(
+      metamodel.tempTableStrategy,
+      context,
+    );
+  }
+  protocol.batchSize = metamodel.batchSize;
+  protocol.checked = metamodel.checked;
+  return protocol;
+};
+
+const transformRelationalCrossRootQueryTempTableGraphFetchExecutionNode = (
+  metamodel: RelationalCrossRootQueryTempTableGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode => {
+  const protocol =
+    new V1_RelationalCrossRootQueryTempTableGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.nodeIndex = metamodel.nodeIndex;
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformRelationalGraphFetchExecutionNode(child, context),
+  );
+  protocol.tempTableName = metamodel.tempTableName;
+  protocol.processedTempTableName = metamodel.tempTableName;
+  protocol.columns = metamodel.columns.map(transformSQLResultColumn);
+  if (metamodel.tempTableStrategy) {
+    protocol.tempTableStrategy = transformTempTableStrategy(
+      metamodel.tempTableStrategy,
+      context,
+    );
+  }
+  protocol.parentTempTableName = metamodel.parentTempTableName;
+  protocol.processedParentTempTableName =
+    metamodel.processedParentTempTableName;
+  protocol.parentTempTableColumns = metamodel.parentTempTableColumns.map(
+    transformSQLResultColumn,
+  );
+  if (metamodel.parentTempTableStrategy) {
+    protocol.parentTempTableStrategy = transformTempTableStrategy(
+      metamodel.parentTempTableStrategy,
+      context,
+    );
+  }
+  return protocol;
+};
+
+function transformRelationalGraphFetchExecutionNode(
+  metamodel: RelationalGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_RelationalGraphFetchExecutionNode {
+  if (
+    metamodel instanceof
+    RelationalCrossRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalCrossRootQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (
+    metamodel instanceof RelationalRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalRootQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (
+    metamodel instanceof RelationalClassQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalClassQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform RelationalGraphFetchExecutionNode`,
+    metamodel,
+  );
+}
+
+const transformPureExpressionPlatformExecutionNode = (
+  metamodel: PureExpressionPlatformExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_PureExpressionPlatformExecutionNode => {
+  const protocol = new V1_PureExpressionPlatformExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.pure = metamodel.pure;
+  return protocol;
+};
+
+const transformInMemoryPropertyGraphFetchExecutionNode = (
+  metamodel: InMemoryPropertyGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_InMemoryPropertyGraphFetchExecutionNode => {
+  const protocol = new V1_InMemoryPropertyGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.nodeIndex = metamodel.nodeIndex;
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformInMemoryGraphFetchExecutionNode(child, context),
+  );
+  return protocol;
+};
+
+const transformInMemoryRootGraphFetchExecutionNode = (
+  metamodel: InMemoryRootGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_InMemoryRootGraphFetchExecutionNode => {
+  const protocol = new V1_InMemoryRootGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.nodeIndex = metamodel.nodeIndex;
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformInMemoryGraphFetchExecutionNode(child, context),
+  );
+  protocol.batchSize = metamodel.batchSize;
+  protocol.checked = metamodel.checked;
+  protocol.filter = metamodel.filter;
+  return protocol;
+};
+
+function transformInMemoryGraphFetchExecutionNode(
+  metamodel: InMemoryGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_InMemoryGraphFetchExecutionNode {
+  if (metamodel instanceof InMemoryRootGraphFetchExecutionNode) {
+    return transformInMemoryRootGraphFetchExecutionNode(metamodel, context);
+  } else if (metamodel instanceof InMemoryPropertyGraphFetchExecutionNode) {
+    return transformInMemoryPropertyGraphFetchExecutionNode(metamodel, context);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform InMemoryGraphFetchExecutionNode`,
+  );
+}
+
+const transformLocalGraphFetchExecutionNode = (
+  metamodel: LocalGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_LocalGraphFetchExecutionNode => {
+  if (metamodel instanceof RelationalGraphFetchExecutionNode) {
+    return transformRelationalGraphFetchExecutionNode(metamodel, context);
+  } else if (metamodel instanceof InMemoryGraphFetchExecutionNode) {
+    return transformInMemoryGraphFetchExecutionNode(metamodel, context);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform LocalGraphFetchExecutionNode`,
+    metamodel,
+  );
+};
+
+const transformGlobalGraphFetchExecutionNode = (
+  metamodel: GlobalGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_GlobalGraphFetchExecutionNode => {
+  const protocol = new V1_GlobalGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformGlobalGraphFetchExecutionNodeHelper(child, context),
+  );
+  protocol.localGraphFetchExecutionNode = transformLocalGraphFetchExecutionNode(
+    metamodel.localGraphFetchExecutionNode,
+    context,
+  );
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.enableConstraints = metamodel.enableConstraints;
+  protocol.checked = metamodel.checked;
+  protocol.localTreeIndices = metamodel.localTreeIndices;
+  protocol.dependencyIndices = metamodel.dependencyIndices;
+  return protocol;
+};
+
+const transformXStorePropertyFetchDetails = (
+  metamodel: XStorePropertyFetchDetails,
+): V1_XStorePropertyFetchDetails => {
+  const protocol = new V1_XStorePropertyFetchDetails();
+  protocol.supportsCaching = metamodel.supportsCaching;
+  protocol.propertyPath = metamodel.propertyPath;
+  protocol.sourceMappingId = metamodel.sourceMappingId;
+  protocol.sourceSetId = metamodel.sourceSetId;
+  protocol.targetMappingId = metamodel.targetMappingId;
+  protocol.targetSetId = metamodel.targetSetId;
+  protocol.subTree = metamodel.subTree;
+  protocol.targetPropertiesOrdered = metamodel.targetPropertiesOrdered;
+  return protocol;
+};
+
+const transformStoreMappingGlobalGraphFetchExecutionNode = (
+  metamodel: StoreMappingGlobalGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_StoreMappingGlobalGraphFetchExecutionNode => {
+  const protocol = new V1_StoreMappingGlobalGraphFetchExecutionNode();
+  transformBaseExecutionNode(metamodel, protocol, context);
+  protocol.graphFetchTree = V1_transformGraphFetchTree(
+    metamodel.graphFetchTree,
+    [],
+    new Map<string, unknown[]>(),
+    false,
+    false,
+  );
+  protocol.children = metamodel.children.map((child) =>
+    transformGlobalGraphFetchExecutionNodeHelper(child, context),
+  );
+  protocol.localGraphFetchExecutionNode = transformLocalGraphFetchExecutionNode(
+    metamodel.localGraphFetchExecutionNode,
+    context,
+  );
+  protocol.parentIndex = metamodel.parentIndex;
+  protocol.enableConstraints = metamodel.enableConstraints;
+  protocol.checked = metamodel.checked;
+  protocol.localTreeIndices = metamodel.localTreeIndices;
+  protocol.dependencyIndices = metamodel.dependencyIndices;
+  protocol.store = metamodel.store;
+  if (metamodel.xStorePropertyFetchDetails) {
+    protocol.xStorePropertyFetchDetails = transformXStorePropertyFetchDetails(
+      metamodel.xStorePropertyFetchDetails,
+    );
+  }
+  protocol.xStorePropertyMapping = metamodel.xStorePropertyMapping;
+  return protocol;
+};
+
+function transformGlobalGraphFetchExecutionNodeHelper(
+  metamodel: GlobalGraphFetchExecutionNode,
+  context: V1_GraphTransformerContext,
+): V1_GlobalGraphFetchExecutionNode {
+  if (metamodel instanceof StoreMappingGlobalGraphFetchExecutionNode) {
+    return transformStoreMappingGlobalGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (metamodel instanceof GlobalGraphFetchExecutionNode) {
+    return transformGlobalGraphFetchExecutionNode(metamodel, context);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform GlobalGraphFetchExecutionNode`,
+    metamodel,
+  );
+}
+
 export function V1_transformExecutionNode(
   metamodel: ExecutionNode,
   context: V1_GraphTransformerContext,
@@ -267,6 +769,13 @@ export function V1_transformExecutionNode(
     return transformSQLExecutionNode(metamodel, context);
   } else if (metamodel instanceof RelationalTDSInstantiationExecutionNode) {
     return transformRelationalTDSInstantiationExecutionNode(metamodel, context);
+  } else if (metamodel instanceof StoreMappingGlobalGraphFetchExecutionNode) {
+    return transformStoreMappingGlobalGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (metamodel instanceof GlobalGraphFetchExecutionNode) {
+    return transformGlobalGraphFetchExecutionNode(metamodel, context);
   } else if (metamodel instanceof FunctionParametersValidationNode) {
     return transformFunctionParametersValidationExecutionNode(
       metamodel,
@@ -278,6 +787,34 @@ export function V1_transformExecutionNode(
     return transformConstantExecutionNode(metamodel, context);
   } else if (metamodel instanceof SequenceExecutionNode) {
     return transformSequenceExecutionNode(metamodel, context);
+  } else if (
+    metamodel instanceof
+    RelationalCrossRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalCrossRootQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (
+    metamodel instanceof RelationalRootQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalRootQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (
+    metamodel instanceof RelationalClassQueryTempTableGraphFetchExecutionNode
+  ) {
+    return transformRelationalClassQueryTempTableGraphFetchExecutionNode(
+      metamodel,
+      context,
+    );
+  } else if (metamodel instanceof PureExpressionPlatformExecutionNode) {
+    return transformPureExpressionPlatformExecutionNode(metamodel, context);
+  } else if (metamodel instanceof InMemoryRootGraphFetchExecutionNode) {
+    return transformInMemoryRootGraphFetchExecutionNode(metamodel, context);
+  } else if (metamodel instanceof InMemoryPropertyGraphFetchExecutionNode) {
+    return transformInMemoryPropertyGraphFetchExecutionNode(metamodel, context);
   }
   throw new UnsupportedOperationError(
     `Can't transform execution node`,