Handle multiple jointures in subqueries

Author: arteymix

gemma-core/src/main/java/ubic/gemma/persistence/service/AbstractFilteringVoEnabledDao.java

@@ -1,6 +1,8 @@
 package ubic.gemma.persistence.service;
 
-import lombok.*;
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import lombok.With;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.time.StopWatch;
@@ -330,7 +332,17 @@ private Filter nestIfSubquery( Filter f, String propertyName ) {
                 for ( FilterablePropertyAlias fpa : filterablePropertyAliases ) {
                     if ( f.getObjectAlias().equals( fpa.getObjectAlias() ) ) {
                         // FIXME: the prefix is not always a valid path
-                        aliases = Collections.singletonList( new Subquery.Alias( fpa.prefix.substring( 0, fpa.prefix.length() - 1 ), fpa.getObjectAlias() ) );
+                        String[] parts = fpa.prefix.split( "\\." );
+                        aliases = new ArrayList<>();
+                        for ( int i = 0; i < parts.length - 1; i++ ) {
+                            String part = parts[i];
+                            aliases.add( new Subquery.Alias( i > 0 ? "alias" + i : null, part, "alias" + ( i + 1 ) ) );
+                        }
+                        if ( parts.length > 1 ) {
+                            aliases.add( new Subquery.Alias( "alias" + ( parts.length - 1 ), parts[parts.length - 1], fpa.getObjectAlias() ) );
+                        } else {
+                            aliases.add( new Subquery.Alias( null, parts[0], fpa.getObjectAlias() ) );
+                        }
                         break;
                     }
                 }

gemma-core/src/main/java/ubic/gemma/persistence/util/FilterQueryUtils.java

@@ -144,7 +144,13 @@ private static String formSubClause( Filter filter, int i ) {
                     .append( " " )
                     .append( "e" );
             for ( Subquery.Alias a : s.getAliases() ) {
-                disjunction.append( " join " ).append( "e." ).append( a.getPropertyName() ).append( " " ).append( a.getAlias() );
+                disjunction.append( " join " );
+                if ( a.getObjectAlias() == null ) {
+                    disjunction.append( "e." );
+                } else {
+                    disjunction.append( a.getObjectAlias() ).append( "." );
+                }
+                disjunction.append( a.getPropertyName() ).append( " " ).append( a.getAlias() );
             }
             disjunction.append( " where " );
             if ( s.getFilter().getObjectAlias() == null ) {

gemma-core/src/main/java/ubic/gemma/persistence/util/Subquery.java

@@ -2,6 +2,7 @@
 
 import lombok.Value;
 
+import javax.annotation.Nullable;
 import java.util.List;
 
 /**
@@ -14,6 +15,8 @@ public class Subquery {
 
     @Value
     public static class Alias {
+        @Nullable
+        String objectAlias;
         String propertyName;
         String alias;
     }

gemma-core/src/test/java/ubic/gemma/persistence/service/expression/experiment/ExpressionExperimentDaoTest.java

@@ -180,7 +180,7 @@ public void testSubquery() {
                             .hasFieldOrPropertyWithValue( "entityName", "ubic.gemma.model.expression.experiment.ExpressionExperiment" )
                             .hasFieldOrPropertyWithValue( "identifierPropertyName", "id" );
                     Assertions.assertThat( s.getAliases() )
-                            .contains( new Subquery.Alias( "allCharacteristics", "ac" ) );
+                            .contains( new Subquery.Alias( null, "allCharacteristics", "ac" ) );
                     Assertions.assertThat( s.getFilter() )
                             .hasFieldOrPropertyWithValue( "objectAlias", "ac" )
                             .hasFieldOrPropertyWithValue( "propertyName", "valueUri" )
@@ -191,6 +191,33 @@ public void testSubquery() {
                 FilterQueryUtils.formRestrictionClause( Filters.by( f ) ) );
     }
 
+    @Test
+    public void testSubqueryWithMultipleJointures() {
+        Filter f = expressionExperimentDao.getFilter( "experimentalDesign.experimentalFactors.factorValues.characteristics.valueUri", Filter.Operator.in, Collections.singleton( "http://example.com" ) );
+        Assertions.assertThat( f.getOperator() )
+                .isEqualTo( Filter.Operator.inSubquery );
+        Assertions.assertThat( f.getRequiredValue() )
+                .isNotNull()
+                .asInstanceOf( InstanceOfAssertFactories.type( Subquery.class ) )
+                .satisfies( s -> {
+                    Assertions.assertThat( s )
+                            .hasFieldOrPropertyWithValue( "entityName", "ubic.gemma.model.expression.experiment.ExpressionExperiment" )
+                            .hasFieldOrPropertyWithValue( "identifierPropertyName", "id" );
+                    Assertions.assertThat( s.getAliases() )
+                            .containsExactly( new Subquery.Alias( null, "experimentalDesign", "alias1" ),
+                                    new Subquery.Alias( "alias1", "experimentalFactors", "alias2" ),
+                                    new Subquery.Alias( "alias2", "factorValues", "alias3" ),
+                                    new Subquery.Alias( "alias3", "characteristics", "fvc" ) );
+                    Assertions.assertThat( s.getFilter() )
+                            .hasFieldOrPropertyWithValue( "objectAlias", "fvc" )
+                            .hasFieldOrPropertyWithValue( "propertyName", "valueUri" )
+                            .hasFieldOrPropertyWithValue( "operator", Filter.Operator.in )
+                            .hasFieldOrPropertyWithValue( "requiredValue", Collections.singletonList( "http://example.com" ) );
+                } );
+        // assertEquals( "and (ee.id in (select e.id from ubic.gemma.model.expression.experiment.ExpressionExperiment e join e.allCharacteristics ac where ac.valueUri in (:ac_valueUri1)))",
+        //         FilterQueryUtils.formRestrictionClause( Filters.by( f ) ) );
+    }
+
     private ExpressionExperiment reload( ExpressionExperiment e ) {
         sessionFactory.getCurrentSession().flush();
         sessionFactory.getCurrentSession().evict( e );