org.eclipse.mdm.api.odsadapter/src/main/java/org/eclipse/mdm/api/odsadapter/lookup/EntityRequest.java - mdmbl/org.eclipse.mdm - Git at Google

 /********************************************************************************
  * Copyright (c) 2015-2020 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  ********************************************************************************/

 package org.eclipse.mdm.api.odsadapter.lookup;

 import static java.util.stream.Collectors.toList;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;

 import org.eclipse.mdm.api.base.adapter.EntityType;
 import org.eclipse.mdm.api.base.adapter.Relation;
 import org.eclipse.mdm.api.base.model.ContextComponent;
 import org.eclipse.mdm.api.base.model.ContextSensor;
 import org.eclipse.mdm.api.base.model.ContextType;
 import org.eclipse.mdm.api.base.model.Deletable;
 import org.eclipse.mdm.api.base.model.Entity;
 import org.eclipse.mdm.api.base.query.ComparisonOperator;
 import org.eclipse.mdm.api.base.query.DataAccessException;
 import org.eclipse.mdm.api.base.query.Filter;
 import org.eclipse.mdm.api.base.query.Query;
 import org.eclipse.mdm.api.base.query.QueryService;
 import org.eclipse.mdm.api.base.query.Record;
 import org.eclipse.mdm.api.base.query.Result;
 import org.eclipse.mdm.api.dflt.model.TemplateAttribute;
 import org.eclipse.mdm.api.dflt.model.TemplateComponent;
 import org.eclipse.mdm.api.dflt.model.TemplateSensor;
 import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig;
 import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig.Key;
 import org.eclipse.mdm.api.odsadapter.query.ODSModelManager;

 /**
  * Recursively loads entities for a given {@link EntityConfig} with all resolved
  * dependencies (optional, mandatory children).
  *
  * @param <T> The entity type.
  * @since 1.0.0
  * @author Viktor Stoehr, Gigatronik Ingolstadt GmbH
  */
 public class EntityRequest<T extends Entity> {

 	// ======================================================================
 	// Instance variables
 	// ======================================================================

 	final ODSModelManager odsModelManager;
 	final QueryService queryService;
 	final EntityConfig<T> entityConfig;
 	final EntityResult<T> entityResult = new EntityResult<>(this);

 	final Cache cache;

 	boolean filtered;

 	// ======================================================================
 	// Constructors
 	// ======================================================================

 	/**
 	 * Constructor.
 	 *
 	 * @param modelManager The {@link ODSModelManager}.
 	 * @param config       The {@link EntityConfig}.
 	 */
 	public EntityRequest(ODSModelManager modelManager, QueryService queryService, Key<T> key) {
 		this.odsModelManager = modelManager;
 		this.queryService = queryService;
 		this.entityConfig = modelManager.getEntityConfig(key);
 		cache = new Cache();
 	}

 	/**
 	 * Constructor.
 	 *
 	 * @param parentRequest The parent {@link EntityRequest}.
 	 * @param entityConfig  The {@link EntityConfig}.
 	 */
 	protected EntityRequest(EntityRequest<?> parentRequest, EntityConfig<T> entityConfig) {
 		odsModelManager = parentRequest.odsModelManager;
 		queryService = parentRequest.queryService;
 		cache = parentRequest.cache;
 		this.entityConfig = entityConfig;
 	}

 	// ======================================================================
 	// Public methods
 	// ======================================================================

 	/**
 	 * Loads all entities matching given name pattern.
 	 *
 	 * @param pattern Is always case sensitive and may contain wildcard characters
 	 *                as follows: "?" for one matching character and "*" for a
 	 *                sequence of matching characters.
 	 * @return A sorted {@link List} with queried entities is returned.
 	 * @throws DataAccessException Thrown if unable to load entities.
 	 */
 	public List<T> loadAll(String pattern) throws DataAccessException {
 		return load(Filter.nameOnly(entityConfig.getEntityType(), pattern)).getSortedEntities();
 	}

 	/**
 	 * Loads all entities matching given instance IDs.
 	 *
 	 * @param instanceIDs The instance IDs.
 	 * @return A sorted {@link List} with queried entities is returned.
 	 * @throws DataAccessException Thrown if unable to load entities.
 	 */
 	public List<T> loadAll(Collection<String> instanceIDs) throws DataAccessException {
 		if (instanceIDs.isEmpty()) {
 			// just to be sure...
 			return Collections.emptyList();
 		}

 		return load(Filter.idsOnly(entityConfig.getEntityType(), instanceIDs)).getSortedEntities();
 	}

 	public ODSModelManager getODSModelManager() {
 		return odsModelManager;
 	}

 	// ======================================================================
 	// Protected methods
 	// ======================================================================

 	/**
 	 * Adds foreign key select statements to given {@link Query} for each given
 	 * {@link EntityConfig}.
 	 *
 	 * @param query          The {@link Query}.
 	 * @param relatedConfigs The {@code EntityConfig}s.
 	 * @param mandatory      Flag indicates whether given {@code EntityConfig}s are
 	 *                       mandatory or not.
 	 * @return For each {@code EntityConfig} a corresponding {@code
 	 * 		RelationConfig} is returned in a {@code List}.
 	 */
 	protected List<RelationConfig> selectRelations(Query query, List<EntityConfig<?>> relatedConfigs,
 			boolean mandatory) {
 		List<RelationConfig> relationConfigs = new ArrayList<>();
 		EntityType entityType = entityConfig.getEntityType();
 		for (EntityConfig<?> relatedEntityConfig : relatedConfigs) {
 			RelationConfig relationConfig = new RelationConfig(entityType, relatedEntityConfig, mandatory);
 			query.select(relationConfig.relation.getAttribute());
 			relationConfigs.add(relationConfig);
 		}

 		return relationConfigs;
 	}

 	/**
 	 * Convenience method collects the queried {@link Record} from each
 	 * {@link Result}.
 	 *
 	 * @param results The {@code Result}s.
 	 * @return The queried {@link Record}s are returned.
 	 */
 	protected List<Record> collectRecords(List<Result> results) {
 		return results.stream().map(r -> r.getRecord(entityConfig.getEntityType())).collect(toList());
 	}

 	/**
 	 * Loads and maps related entities for each given {@link RelationConfig}.
 	 *
 	 * @param relationConfigs The {@code RelationConfig}s.
 	 * @throws DataAccessException Thrown if unable to load related entities.
 	 */
 	protected void loadRelatedEntities(List<RelationConfig> relationConfigs) throws DataAccessException {
 		for (RelationConfig relationConfig : relationConfigs) {
 			EntityConfig<?> relatedConfig = relationConfig.entityConfig;

 			boolean isContextTypeDefined = entityConfig.getContextType().isPresent();
 			for (Entity relatedEntity : new EntityRequest<>(this, relatedConfig)
 					.loadAll(relationConfig.dependants.keySet())) {
 				boolean setByContextType = !isContextTypeDefined && relatedConfig.getContextType().isPresent();
 				for (EntityRecord<?> entityRecord : relationConfig.dependants.remove(relatedEntity.getID())) {
 					setRelatedEntity(entityRecord, relatedEntity,
 							setByContextType ? relatedConfig.getContextType().get() : null);
 				}
 			}

 			if (!relationConfig.dependants.isEmpty()) {
 				// this may occur if the instance id of the related entity
 				// is defined, but the entity itself does not exist
 				throw new IllegalStateException(
 						"Unable to load related entities: " + relationConfig.dependants.toString());
 			}
 		}
 	}

 	/**
 	 * Assigns given related {@link Entity} to given {@link EntityRecord}.
 	 *
 	 * @param entityRecord  The {@code EntityRecord} which references given
 	 *                      {@code Entity}.
 	 * @param relatedEntity The related {@code Entity}.
 	 * @param contextType   Used as qualifier for relation assignment.
 	 */
 	protected void setRelatedEntity(EntityRecord<?> entityRecord, Entity relatedEntity, ContextType contextType) {
 		if (contextType == null) {
 			entityRecord.core.getMutableStore().set(relatedEntity);
 		} else {
 			entityRecord.core.getMutableStore().set(relatedEntity, contextType);
 		}

 		List<TemplateAttribute> templateAttributes = new ArrayList<>();
 		if (entityRecord.entity instanceof ContextComponent && relatedEntity instanceof TemplateComponent) {
 			templateAttributes.addAll(((TemplateComponent) relatedEntity).getTemplateAttributes());
 		} else if (entityRecord.entity instanceof ContextSensor && relatedEntity instanceof TemplateSensor) {
 			templateAttributes.addAll(((TemplateSensor) relatedEntity).getTemplateAttributes());
 		}

 		if (!templateAttributes.isEmpty()) {
 			// hide Value containers that are missing in the template
 			Set<String> names = new HashSet<>(entityRecord.core.getValues().keySet());
 			names.remove(Entity.ATTR_NAME);
 			names.remove(Entity.ATTR_MIMETYPE);
 			templateAttributes.stream().map(Entity::getName).forEach(names::remove);
 			entityRecord.core.hideValues(names);
 		}
 	}

 	// ======================================================================
 	// Private methods
 	// ======================================================================

 	/**
 	 * Loads all entities matching given {@link Filter} including all of related
 	 * entities (optional, mandatory and children).
 	 *
 	 * @param filter The {@link Filter}.
 	 * @return Returns the queried {@code EntityResult}.
 	 * @throws DataAccessException Thrown if unable to load entities.
 	 */
 	private EntityResult<T> load(Filter filter) throws DataAccessException {
 		filtered = !filter.isEmtpty() || entityConfig.isReflexive();

 		EntityType entityType = entityConfig.getEntityType();
 		Relation reflexiveRelation = entityConfig.isReflexive() ? entityType.getRelation(entityType) : null;

 		Query query = queryService.createQuery().selectAll(entityConfig.getEntityType());

 		if (entityConfig.isReflexive()) {
 			query.select(reflexiveRelation.getAttribute());
 			// entities with children have to be processed before their
 			// children!
 			query.order(entityType.getIDAttribute());
 		}

 		// prepare relations select statements
 		List<RelationConfig> optionalRelations = selectRelations(query, entityConfig.getOptionalConfigs(), false);
 		List<RelationConfig> mandatoryRelations = selectRelations(query, entityConfig.getMandatoryConfigs(), true);

 		// configure filter
 		Filter adjustedFilter = Filter.or();
 		if (filtered) {
 			// preserve current conditions
 			adjustedFilter.merge(filter);
 			if (entityConfig.isReflexive()) {
 				// extend to retrieve all reflexive child candidates
 				adjustedFilter.add(ComparisonOperator.IS_NOT_NULL.create(reflexiveRelation.getAttribute(), 0L));
 			}
 		}

 		// load entities and prepare mappings for required related entities
 		List<EntityRecord<?>> parentRecords = new ArrayList<>();
 		for (Record record : collectRecords(query.fetch(adjustedFilter))) {
 			Optional<String> reflexiveParentID = Optional.empty();
 			if (entityConfig.isReflexive()) {
 				reflexiveParentID = record.getID(reflexiveRelation);
 			}
 			EntityRecord<T> entityRecord;

 			if (entityConfig.isReflexive() && reflexiveParentID.isPresent()) {
 				Optional<EntityRecord<T>> parentRecord = entityResult.get(reflexiveParentID.get());
 				if (!parentRecord.isPresent()) {
 					// this entity's parent was not loaded -> skip
 					continue;
 				}

 				entityRecord = entityResult.add(parentRecord.get(), record);
 				parentRecords.add(parentRecord.get());
 			} else {
 				entityRecord = entityResult.add(record);
 			}

 			// collect related instance IDs
 			Stream.concat(optionalRelations.stream(), mandatoryRelations.stream())
 					.forEach(rc -> rc.add(entityRecord, record));
 		}

 		if (entityResult.isEmpty()) {
 			// no entities found -> neither related nor child entities required
 			return entityResult;
 		}

 		// load and map related entities
 		loadRelatedEntities(optionalRelations);
 		loadRelatedEntities(mandatoryRelations);

 		// sort children of parent
 		if (entityConfig.isReflexive()) {
 			@SuppressWarnings("unchecked")
 			EntityConfig<Deletable> childConfig = (EntityConfig<Deletable>) entityConfig;
 			for (EntityRecord<?> entityRecord : parentRecords) {
 				entityRecord.core.getChildrenStore().sort(childConfig.getEntityClass(), childConfig.getComparator());
 			}
 		}

 		// load children
 		for (EntityConfig<? extends Deletable> childConfig : entityConfig.getChildConfigs()) {
 			cache.add(new ChildRequest<>(this, childConfig).load());
 		}

 		return entityResult;
 	}

 }
	/********************************************************************************
	* Copyright (c) 2015-2020 Contributors to the Eclipse Foundation
	*
	* See the NOTICE file(s) distributed with this work for additional
	* information regarding copyright ownership.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	********************************************************************************/

	package org.eclipse.mdm.api.odsadapter.lookup;

	import static java.util.stream.Collectors.toList;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Optional;
	import java.util.Set;
	import java.util.stream.Stream;

	import org.eclipse.mdm.api.base.adapter.EntityType;
	import org.eclipse.mdm.api.base.adapter.Relation;
	import org.eclipse.mdm.api.base.model.ContextComponent;
	import org.eclipse.mdm.api.base.model.ContextSensor;
	import org.eclipse.mdm.api.base.model.ContextType;
	import org.eclipse.mdm.api.base.model.Deletable;
	import org.eclipse.mdm.api.base.model.Entity;
	import org.eclipse.mdm.api.base.query.ComparisonOperator;
	import org.eclipse.mdm.api.base.query.DataAccessException;
	import org.eclipse.mdm.api.base.query.Filter;
	import org.eclipse.mdm.api.base.query.Query;
	import org.eclipse.mdm.api.base.query.QueryService;
	import org.eclipse.mdm.api.base.query.Record;
	import org.eclipse.mdm.api.base.query.Result;
	import org.eclipse.mdm.api.dflt.model.TemplateAttribute;
	import org.eclipse.mdm.api.dflt.model.TemplateComponent;
	import org.eclipse.mdm.api.dflt.model.TemplateSensor;
	import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig;
	import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig.Key;
	import org.eclipse.mdm.api.odsadapter.query.ODSModelManager;

	/**
	* Recursively loads entities for a given {@link EntityConfig} with all resolved
	* dependencies (optional, mandatory children).
	*
	* @param <T> The entity type.
	* @since 1.0.0
	* @author Viktor Stoehr, Gigatronik Ingolstadt GmbH
	*/
	public class EntityRequest<T extends Entity> {

	// ======================================================================
	// Instance variables
	// ======================================================================

	final ODSModelManager odsModelManager;
	final QueryService queryService;
	final EntityConfig<T> entityConfig;
	final EntityResult<T> entityResult = new EntityResult<>(this);

	final Cache cache;

	boolean filtered;

	// ======================================================================
	// Constructors
	// ======================================================================

	/**
	* Constructor.
	*
	* @param modelManager The {@link ODSModelManager}.
	* @param config The {@link EntityConfig}.
	*/
	public EntityRequest(ODSModelManager modelManager, QueryService queryService, Key<T> key) {
	this.odsModelManager = modelManager;
	this.queryService = queryService;
	this.entityConfig = modelManager.getEntityConfig(key);
	cache = new Cache();
	}

	/**
	* Constructor.
	*
	* @param parentRequest The parent {@link EntityRequest}.
	* @param entityConfig The {@link EntityConfig}.
	*/
	protected EntityRequest(EntityRequest<?> parentRequest, EntityConfig<T> entityConfig) {
	odsModelManager = parentRequest.odsModelManager;
	queryService = parentRequest.queryService;
	cache = parentRequest.cache;
	this.entityConfig = entityConfig;
	}

	// ======================================================================
	// Public methods
	// ======================================================================

	/**
	* Loads all entities matching given name pattern.
	*
	* @param pattern Is always case sensitive and may contain wildcard characters
	* as follows: "?" for one matching character and "*" for a
	* sequence of matching characters.
	* @return A sorted {@link List} with queried entities is returned.
	* @throws DataAccessException Thrown if unable to load entities.
	*/
	public List<T> loadAll(String pattern) throws DataAccessException {
	return load(Filter.nameOnly(entityConfig.getEntityType(), pattern)).getSortedEntities();
	}

	/**
	* Loads all entities matching given instance IDs.
	*
	* @param instanceIDs The instance IDs.
	* @return A sorted {@link List} with queried entities is returned.
	* @throws DataAccessException Thrown if unable to load entities.
	*/
	public List<T> loadAll(Collection<String> instanceIDs) throws DataAccessException {
	if (instanceIDs.isEmpty()) {
	// just to be sure...
	return Collections.emptyList();
	}

	return load(Filter.idsOnly(entityConfig.getEntityType(), instanceIDs)).getSortedEntities();
	}

	public ODSModelManager getODSModelManager() {
	return odsModelManager;
	}

	// ======================================================================
	// Protected methods
	// ======================================================================

	/**
	* Adds foreign key select statements to given {@link Query} for each given
	* {@link EntityConfig}.
	*
	* @param query The {@link Query}.
	* @param relatedConfigs The {@code EntityConfig}s.
	* @param mandatory Flag indicates whether given {@code EntityConfig}s are
	* mandatory or not.
	* @return For each {@code EntityConfig} a corresponding {@code
	* RelationConfig} is returned in a {@code List}.
	*/
	protected List<RelationConfig> selectRelations(Query query, List<EntityConfig<?>> relatedConfigs,
	boolean mandatory) {
	List<RelationConfig> relationConfigs = new ArrayList<>();
	EntityType entityType = entityConfig.getEntityType();
	for (EntityConfig<?> relatedEntityConfig : relatedConfigs) {
	RelationConfig relationConfig = new RelationConfig(entityType, relatedEntityConfig, mandatory);
	query.select(relationConfig.relation.getAttribute());
	relationConfigs.add(relationConfig);
	}

	return relationConfigs;
	}

	/**
	* Convenience method collects the queried {@link Record} from each
	* {@link Result}.
	*
	* @param results The {@code Result}s.
	* @return The queried {@link Record}s are returned.
	*/
	protected List<Record> collectRecords(List<Result> results) {
	return results.stream().map(r -> r.getRecord(entityConfig.getEntityType())).collect(toList());
	}

	/**
	* Loads and maps related entities for each given {@link RelationConfig}.
	*
	* @param relationConfigs The {@code RelationConfig}s.
	* @throws DataAccessException Thrown if unable to load related entities.
	*/
	protected void loadRelatedEntities(List<RelationConfig> relationConfigs) throws DataAccessException {
	for (RelationConfig relationConfig : relationConfigs) {
	EntityConfig<?> relatedConfig = relationConfig.entityConfig;

	boolean isContextTypeDefined = entityConfig.getContextType().isPresent();
	for (Entity relatedEntity : new EntityRequest<>(this, relatedConfig)
	.loadAll(relationConfig.dependants.keySet())) {
	boolean setByContextType = !isContextTypeDefined && relatedConfig.getContextType().isPresent();
	for (EntityRecord<?> entityRecord : relationConfig.dependants.remove(relatedEntity.getID())) {
	setRelatedEntity(entityRecord, relatedEntity,
	setByContextType ? relatedConfig.getContextType().get() : null);
	}
	}

	if (!relationConfig.dependants.isEmpty()) {
	// this may occur if the instance id of the related entity
	// is defined, but the entity itself does not exist
	throw new IllegalStateException(
	"Unable to load related entities: " + relationConfig.dependants.toString());
	}
	}
	}

	/**
	* Assigns given related {@link Entity} to given {@link EntityRecord}.
	*
	* @param entityRecord The {@code EntityRecord} which references given
	* {@code Entity}.
	* @param relatedEntity The related {@code Entity}.
	* @param contextType Used as qualifier for relation assignment.
	*/
	protected void setRelatedEntity(EntityRecord<?> entityRecord, Entity relatedEntity, ContextType contextType) {
	if (contextType == null) {
	entityRecord.core.getMutableStore().set(relatedEntity);
	} else {
	entityRecord.core.getMutableStore().set(relatedEntity, contextType);
	}

	List<TemplateAttribute> templateAttributes = new ArrayList<>();
	if (entityRecord.entity instanceof ContextComponent && relatedEntity instanceof TemplateComponent) {
	templateAttributes.addAll(((TemplateComponent) relatedEntity).getTemplateAttributes());
	} else if (entityRecord.entity instanceof ContextSensor && relatedEntity instanceof TemplateSensor) {
	templateAttributes.addAll(((TemplateSensor) relatedEntity).getTemplateAttributes());
	}

	if (!templateAttributes.isEmpty()) {
	// hide Value containers that are missing in the template
	Set<String> names = new HashSet<>(entityRecord.core.getValues().keySet());
	names.remove(Entity.ATTR_NAME);
	names.remove(Entity.ATTR_MIMETYPE);
	templateAttributes.stream().map(Entity::getName).forEach(names::remove);
	entityRecord.core.hideValues(names);
	}
	}

	// ======================================================================
	// Private methods
	// ======================================================================

	/**
	* Loads all entities matching given {@link Filter} including all of related
	* entities (optional, mandatory and children).
	*
	* @param filter The {@link Filter}.
	* @return Returns the queried {@code EntityResult}.
	* @throws DataAccessException Thrown if unable to load entities.
	*/
	private EntityResult<T> load(Filter filter) throws DataAccessException {
	filtered = !filter.isEmtpty() \|\| entityConfig.isReflexive();

	EntityType entityType = entityConfig.getEntityType();
	Relation reflexiveRelation = entityConfig.isReflexive() ? entityType.getRelation(entityType) : null;

	Query query = queryService.createQuery().selectAll(entityConfig.getEntityType());

	if (entityConfig.isReflexive()) {
	query.select(reflexiveRelation.getAttribute());
	// entities with children have to be processed before their
	// children!
	query.order(entityType.getIDAttribute());
	}

	// prepare relations select statements
	List<RelationConfig> optionalRelations = selectRelations(query, entityConfig.getOptionalConfigs(), false);
	List<RelationConfig> mandatoryRelations = selectRelations(query, entityConfig.getMandatoryConfigs(), true);

	// configure filter
	Filter adjustedFilter = Filter.or();
	if (filtered) {
	// preserve current conditions
	adjustedFilter.merge(filter);
	if (entityConfig.isReflexive()) {
	// extend to retrieve all reflexive child candidates
	adjustedFilter.add(ComparisonOperator.IS_NOT_NULL.create(reflexiveRelation.getAttribute(), 0L));
	}
	}

	// load entities and prepare mappings for required related entities
	List<EntityRecord<?>> parentRecords = new ArrayList<>();
	for (Record record : collectRecords(query.fetch(adjustedFilter))) {
	Optional<String> reflexiveParentID = Optional.empty();
	if (entityConfig.isReflexive()) {
	reflexiveParentID = record.getID(reflexiveRelation);
	}
	EntityRecord<T> entityRecord;

	if (entityConfig.isReflexive() && reflexiveParentID.isPresent()) {
	Optional<EntityRecord<T>> parentRecord = entityResult.get(reflexiveParentID.get());
	if (!parentRecord.isPresent()) {
	// this entity's parent was not loaded -> skip
	continue;
	}

	entityRecord = entityResult.add(parentRecord.get(), record);
	parentRecords.add(parentRecord.get());
	} else {
	entityRecord = entityResult.add(record);
	}

	// collect related instance IDs
	Stream.concat(optionalRelations.stream(), mandatoryRelations.stream())
	.forEach(rc -> rc.add(entityRecord, record));
	}

	if (entityResult.isEmpty()) {
	// no entities found -> neither related nor child entities required
	return entityResult;
	}

	// load and map related entities
	loadRelatedEntities(optionalRelations);
	loadRelatedEntities(mandatoryRelations);

	// sort children of parent
	if (entityConfig.isReflexive()) {
	@SuppressWarnings("unchecked")
	EntityConfig<Deletable> childConfig = (EntityConfig<Deletable>) entityConfig;
	for (EntityRecord<?> entityRecord : parentRecords) {
	entityRecord.core.getChildrenStore().sort(childConfig.getEntityClass(), childConfig.getComparator());
	}
	}

	// load children
	for (EntityConfig<? extends Deletable> childConfig : entityConfig.getChildConfigs()) {
	cache.add(new ChildRequest<>(this, childConfig).load());
	}

	return entityResult;
	}

	}