ST5AS-41 Implement CommitIndex#workingElementVersions

Author: ivan-gomes

app/dao/impl/jpa/JpaCommitDao.java

@@ -42,7 +42,8 @@ protected JPAManager getJpaManager() {
         return jpa;
     }
 
-    private JpaElementDao elementDao = new JpaElementDao();
+    @Inject
+    private JpaElementDao elementDao;
 
     @Override
     public Optional<Commit> persist(Commit commit) {

app/dao/impl/jpa/JpaElementDao.java

@@ -4,16 +4,27 @@
 import dao.ElementDao;
 import javabean.JavaBeanHelper;
 import jpa.manager.JPAManager;
+import org.omg.sysml.internal.CommitIndex;
+import org.omg.sysml.internal.impl.CommitIndexImpl;
+import org.omg.sysml.internal.impl.CommitIndexImpl_;
 import org.omg.sysml.lifecycle.Commit;
+import org.omg.sysml.lifecycle.ElementVersion;
+import org.omg.sysml.lifecycle.impl.ElementIdentityImpl;
+import org.omg.sysml.lifecycle.impl.ElementIdentityImpl_;
+import org.omg.sysml.lifecycle.impl.ElementVersionImpl;
+import org.omg.sysml.lifecycle.impl.ElementVersionImpl_;
 import org.omg.sysml.metamodel.Element;
 import org.omg.sysml.metamodel.impl.MofObjectImpl;
 import org.omg.sysml.metamodel.impl.MofObjectImpl_;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityTransaction;
 import javax.persistence.NoResultException;
 import javax.persistence.criteria.*;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -22,7 +33,8 @@
 @Singleton
 public class JpaElementDao extends JpaDao<Element> implements ElementDao {
     // TODO Explore alternative to serializing lazy entity attributes that doesn't involve resolving all proxies one level.
-    static Consumer<Element> PROXY_RESOLVER = element -> JavaBeanHelper.getBeanPropertyValues(element).values().stream().flatMap(o -> o instanceof Collection ? ((Collection<?>) o).stream() : Stream.of(o)).forEach(o -> {});
+    static Consumer<Element> PROXY_RESOLVER = element -> JavaBeanHelper.getBeanPropertyValues(element).values().stream().flatMap(o -> o instanceof Collection ? ((Collection<?>) o).stream() : Stream.of(o)).forEach(o -> {
+    });
 
     @Inject
     private MetamodelProvider metamodelProvider;
@@ -80,17 +92,31 @@ public Set<Element> findAllByCommit(Commit commit) {
         return jpa.transact(em -> {
             // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
             Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
-            return streamFlattenedElements(c).peek(PROXY_RESOLVER).collect(Collectors.toSet());
+            return getCommitIndex(c, em).getWorkingElementVersions().stream().map(ElementVersion::getData).filter(mof -> mof instanceof Element).map(mof -> (Element) mof).collect(Collectors.toSet());
         });
     }
 
     @Override
     public Optional<Element> findByCommitAndId(Commit commit, UUID id) {
         return jpa.transact(em -> {
-            return queryCommitTree(em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId()), c ->
-                    c.getChanges().stream().filter(record -> record.getIdentity() != null && record.getIdentity().getId() != null && record.getData() instanceof Element).filter(record -> id.equals(record.getIdentity().getId())).map(record -> (Element) record.getData()).findAny(),
-                    Optional::isPresent)
-                .values().stream().filter(Optional::isPresent).map(Optional::get).peek(PROXY_RESOLVER).findAny();
+            // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
+            Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
+            CommitIndex commitIndex = getCommitIndex(c, em);
+
+            CriteriaBuilder builder = em.getCriteriaBuilder();
+            CriteriaQuery<ElementVersionImpl> query = builder.createQuery(ElementVersionImpl.class);
+            Root<CommitIndexImpl> commitIndexRoot = query.from(CommitIndexImpl.class);
+            SetJoin<CommitIndexImpl, ElementVersionImpl> workingElementVersionsJoin = commitIndexRoot.join(CommitIndexImpl_.workingElementVersions);
+            Join<ElementVersionImpl, ElementIdentityImpl> elementIdentityJoin = workingElementVersionsJoin.join(ElementVersionImpl_.identity);
+            query.select(workingElementVersionsJoin).where(
+                    builder.equal(commitIndexRoot.get(CommitIndexImpl_.id), commitIndex.getId()),
+                    builder.equal(elementIdentityJoin.get(ElementIdentityImpl_.id), id)
+            );
+            try {
+                return Optional.of(em.createQuery(query).getSingleResult()).map(ElementVersion::getData).filter(mof -> mof instanceof Element).map(mof -> (Element) mof);
+            } catch (NoResultException e) {
+                return Optional.empty();
+            }
         });
     }
 
@@ -114,13 +140,37 @@ protected <T> Map<Commit, T> queryCommitTree(Commit commit, Function<Commit, T>
         return results;
     }
 
-    protected Stream<Element> streamFlattenedElements(Commit commit) {
-        Set<UUID> visitedElements = new HashSet<>();
-        Map<Commit, Stream<Element>> results = queryCommitTree(commit,
-                c -> c.getChanges().stream().filter(record -> record.getIdentity() != null && record.getIdentity().getId() != null && record.getData() instanceof Element).filter(record -> !visitedElements.contains(record.getIdentity().getId())).peek(record -> visitedElements.add(record.getIdentity().getId())).map(record -> (Element) record.getData()));
+    protected Stream<ElementVersion> streamWorkingElementVersions(Commit commit) {
+        Set<UUID> visitedElements = ConcurrentHashMap.newKeySet();
+        Map<Commit, Stream<ElementVersion>> results = queryCommitTree(commit,
+                c -> c.getChanges().stream().filter(record -> record.getIdentity() != null && record.getIdentity().getId() != null && record.getData() != null).filter(record -> !visitedElements.contains(record.getIdentity().getId())).peek(record -> visitedElements.add(record.getIdentity().getId())));
         return results.values().stream().flatMap(Function.identity());
     }
 
+    protected CommitIndex getCommitIndex(Commit commit, EntityManager em) {
+        CriteriaBuilder builder = em.getCriteriaBuilder();
+        CriteriaQuery<CommitIndexImpl> query = builder.createQuery(CommitIndexImpl.class);
+        Root<CommitIndexImpl> root = query.from(CommitIndexImpl.class);
+        query.select(root).where(builder.equal(root.get(CommitIndexImpl_.id), commit.getId()));
+        CommitIndex commitIndex = null;
+        try {
+            commitIndex = em.createQuery(query).getSingleResult();
+        } catch (NoResultException ignored) {
+        }
+        if (commitIndex != null) {
+            return commitIndex;
+        }
+
+        commitIndex = new CommitIndexImpl();
+        commitIndex.setCommit(commit);
+        commitIndex.setWorkingElementVersions(streamWorkingElementVersions(commit).collect(Collectors.toSet()));
+        EntityTransaction transaction = em.getTransaction();
+        transaction.begin();
+        em.persist(commitIndex);
+        transaction.commit();
+        return commitIndex;
+    }
+
     private Expression<Boolean> getTypeExpression(CriteriaBuilder builder, Root<?> root) {
         return builder.or(metamodelProvider.getAllImplementationClasses().stream().filter(Element.class::isAssignableFrom).map(c -> builder.equal(root.type(), c)).toArray(Predicate[]::new));
     }

app/dao/impl/jpa/JpaRelationshipDao.java

@@ -1,13 +1,10 @@
 package dao.impl.jpa;
 
 import config.MetamodelProvider;
-import dao.ElementDao;
 import dao.RelationshipDao;
 import jpa.manager.JPAManager;
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
 import org.omg.sysml.lifecycle.Commit;
-import org.omg.sysml.lifecycle.Project;
+import org.omg.sysml.lifecycle.ElementVersion;
 import org.omg.sysml.metamodel.Element;
 import org.omg.sysml.metamodel.Relationship;
 import org.omg.sysml.metamodel.impl.MofObjectImpl;
@@ -17,7 +14,10 @@
 import javax.inject.Singleton;
 import javax.persistence.NoResultException;
 import javax.persistence.criteria.*;
-import java.util.*;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -79,11 +79,110 @@ public void deleteAll() {
     @Override
     public Set<Relationship> findAllByCommitRelatedElement(Commit commit, Element relatedElement) {
         return jpa.transact(em -> {
-            // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
-            Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
-            return elementDao.streamFlattenedElements(c).peek(System.out::println).filter(e -> e instanceof Relationship).map(e -> (Relationship) e)
+/*            Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
+            return elementDao.streamFlattenedElements(c).filter(e -> e instanceof Relationship).map(e -> (Relationship) e)
                     .filter(relationship -> Stream.concat(relationship.getSource().stream(), relationship.getTarget().stream()).map(Element::getIdentifier).anyMatch(id -> id.equals(relatedElement.getIdentifier())))
                     .collect(Collectors.toSet());
+        });*/
+
+        /*return jpa.transact(em -> {
+            CommitIndex commitIndex = elementDao.getCommitIndex(commit, em);
+
+            CriteriaBuilder builder = em.getCriteriaBuilder();
+            CriteriaQuery<ElementVersionImpl> query = builder.createQuery(ElementVersionImpl.class);
+            Root<CommitIndexImpl> commitIndexRoot = query.from(CommitIndexImpl.class);
+            SetJoin<CommitIndexImpl, ElementVersionImpl> workingElementVersionsJoin = commitIndexRoot.join(CommitIndexImpl_.workingElementVersions);
+            Join<ElementVersionImpl, MofObjectImpl> dataJoin = workingElementVersionsJoin.join(ElementVersionImpl_.identity);
+            query.select(workingElementVersionsJoin).where(
+                    builder.equal(commitIndexRoot.get(CommitIndexImpl_.id), commitIndex.getId()),
+                    builder.equal(elementIdentityJoin.get(ElementIdentityImpl_.id), id)
+            );
+            try {
+                return Optional.of(em.createQuery(query).getSingleResult()).map(ElementVersion::getData).filter(mof -> mof instanceof Element).map(mof -> (Element) mof);
+            } catch (NoResultException e) {
+                return Optional.empty();
+            }
+        });*/
+/*            Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
+            CommitIndex commitIndex = elementDao.getCommitIndex(c, em);
+
+            // Switching from Criteria API to HQL, because JPA 2 can't handle @Any for ElementVersion#data and no static metamodel is generated.
+            // https://hibernate.atlassian.net/browse/HHH-6589
+            Session session = em.unwrap(Session.class);
+
+            Query<?> query2 = session.createQuery(
+                    "select relationship, source, target " +
+                            "from RelationshipImpl as relationship " +
+                            "join relationship.source source " +
+                            "join relationship.target target " +
+                            "where relationship.id in (" +
+                                "select elementVersion.data.id " +
+                                "from org.omg.sysml.internal.impl.CommitIndexImpl as commitIndex " +
+                                "join commitIndex.workingElementVersions as elementVersion " +
+                                "where commitIndex.id = :commitIndexId" +
+                            ")");
+            query2.setParameter("commitIndexId", commitIndex.getId());
+            query2.setParameter("relatedElementIdentifier", relatedElement.getIdentifier());
+            query2.list().forEach(System.out::println);*/
+
+            // Polymorphism ruins the day again. Attributes of @Any and @ManyToAny attributes can't be used in where or join clauses as their type is not known. Mitigating with nested queries.
+            // Note that nested queries can only be used in select (but not from) and where clauses.
+
+/*            Query<Relationship> query = session.createQuery(
+                    "select relationship " +
+                            "from org.omg.sysml.internal.impl.CommitIndexImpl as commitIndex, RelationshipImpl relationship " +
+                            "join commitIndex.workingElementVersions as elementVersion " +
+                            "join elementVersion.data as data " +
+                            "join relationship.source as source " +
+                            "join relationship.target as target " +
+                            "where commitIndex.id = :commitIndexId " +
+                            "and relationship.id = data.id " +
+                            "and relationship.class in :types " +
+                            "and (source.identifier = :relatedElementIdentifier or target.identifier = :relatedElementIdentifier)",
+                    Relationship.class);
+            Query<Relationship> query = session.createQuery(
+                    "select relationship " +
+                            "from CommitIndexImpl commitIndex, ElementVersionImpl elementVersion, RelationshipImpl relationship " +
+                            "where commitIndex.id = :commitIndexId " +
+                            "and elementVersion. = ",
+                    Relationship.class);
+            );
+            query.setParameter("commitIndexId", commitIndex.getId());
+            query.setParameter("types", getTypeStream().map(Class::getCanonicalName).collect(Collectors.toList()));
+            query.setParameter("relatedElementIdentifier", relatedElement.getIdentifier());
+            return new LinkedHashSet<>(query.list());*/
+
+/*            Session session = em.unwrap(Session.class);
+            Query<UUID> uuidQuery = session.createQuery(
+                    "select elementVersion.data.id " +
+                            "from org.omg.sysml.internal.impl.CommitIndexImpl as commitIndex " +
+                            "join commitIndex.workingElementVersions as elementVersion " +
+                            "where commitIndex.id = :commitIndexId",
+                    UUID.class);
+            uuidQuery.setParameter("commitIndexId", commitIndex.getId());
+            List<UUID> uuids = uuidQuery.list();
+
+            CriteriaBuilder builder = em.getCriteriaBuilder();
+            CriteriaQuery<RelationshipImpl> query = builder.createQuery(RelationshipImpl.class);
+            Root<RelationshipImpl> relationshipRoot = query.from(RelationshipImpl.class);
+            // java.lang.IllegalArgumentException: Unable to locate Attribute  with the the given name [source] on this ManagedType [org.omg.sysml.metamodel.impl.MofObjectImpl]
+            // Polymorphism strikes again...
+            CollectionJoin<RelationshipImpl, Element> sourceJoin = relationshipRoot.joinCollection(RelationshipImpl_.SOURCE, JoinType.LEFT);
+            CollectionJoin<RelationshipImpl, Element> targetJoin = relationshipRoot.joinCollection(RelationshipImpl_.TARGET, JoinType.LEFT);
+
+            query.select(relationshipRoot).where(
+                    relationshipRoot.get(RelationshipImpl_.id).in(uuids),
+                    builder.or(
+                            builder.equal(sourceJoin.get(ElementImpl_.IDENTIFIER), relatedElement.getIdentifier()),
+                            builder.equal(targetJoin.get(ElementImpl_.IDENTIFIER), relatedElement.getIdentifier())
+                    )
+            );
+            return new LinkedHashSet<>(em.createQuery(query).getResultList());*/
+
+            // Reverting to non-relational streaming
+            // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
+            Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
+            return elementDao.getCommitIndex(c, em).getWorkingElementVersions().stream().map(ElementVersion::getData).filter(mof -> mof instanceof Relationship).map(mof -> (Relationship) mof).filter(relationship -> Stream.concat(relationship.getSource().stream(), relationship.getTarget().stream()).map(Element::getIdentifier).anyMatch(id -> id.equals(relatedElement.getIdentifier()))).collect(Collectors.toSet());
         });
     }
 

app/org/omg/sysml/internal/CommitIndex.java

@@ -0,0 +1,18 @@
+package org.omg.sysml.internal;
+
+import org.omg.sysml.lifecycle.Commit;
+import org.omg.sysml.lifecycle.ElementVersion;
+import org.omg.sysml.lifecycle.Record;
+
+import java.util.Set;
+
+public interface CommitIndex extends Record {
+
+    Commit getCommit();
+
+    void setCommit(Commit commit);
+
+    Set<ElementVersion> getWorkingElementVersions();
+
+    void setWorkingElementVersions(Set<ElementVersion> elements);
+}