LENS-777: Fix: Waiting query selector change from intersecting to union
Project: http://git-wip-us.apache.org/repos/asf/lens/repo Commit: http://git-wip-us.apache.org/repos/asf/lens/commit/7ad12ed7 Tree: http://git-wip-us.apache.org/repos/asf/lens/tree/7ad12ed7 Diff: http://git-wip-us.apache.org/repos/asf/lens/diff/7ad12ed7 Branch: refs/heads/current-release-line Commit: 7ad12ed738abbf14d0b5bfe29dd45de209d32167 Parents: 66f164b Author: Akshay Goyal <[email protected]> Authored: Wed Sep 23 17:39:34 2015 +0530 Committer: Rajat Khandelwal <[email protected]> Committed: Wed Sep 23 17:39:34 2015 +0530 ---------------------------------------------------------------------- .../server/query/QueryExecutionServiceImpl.java | 2 +- .../IntersectingWaitingQueriesSelector.java | 107 ----------- .../collect/UnioningWaitingQueriesSelector.java | 93 ++++++++++ .../IntersectingWaitingQueriesSelectorTest.java | 185 ------------------- .../UnioningWaitingQueriesSelectorTest.java | 135 ++++++++++++++ 5 files changed, 229 insertions(+), 293 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lens/blob/7ad12ed7/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java b/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java index 2ba54e0..3bc9a4a 100644 --- a/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java +++ b/lens-server/src/main/java/org/apache/lens/server/query/QueryExecutionServiceImpl.java @@ -1026,7 +1026,7 @@ public class QueryExecutionServiceImpl extends BaseLensService implements QueryE ImmutableSet<WaitingQueriesSelectionPolicy> selectionPolicies = getImplementations( WAITING_QUERIES_SELECTION_POLICY_FACTORIES_KEY, hiveConf); - this.waitingQueriesSelector = new IntersectingWaitingQueriesSelector(selectionPolicies); + this.waitingQueriesSelector = new UnioningWaitingQueriesSelector(selectionPolicies); try { this.userQueryToCubeQueryRewriter = new UserQueryToCubeQueryRewriter(conf); http://git-wip-us.apache.org/repos/asf/lens/blob/7ad12ed7/lens-server/src/main/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelector.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelector.java b/lens-server/src/main/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelector.java deleted file mode 100644 index fee4120..0000000 --- a/lens-server/src/main/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelector.java +++ /dev/null @@ -1,107 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.apache.lens.server.query.collect; - -import java.util.List; -import java.util.Set; - -import org.apache.lens.server.api.query.FinishedLensQuery; -import org.apache.lens.server.api.query.QueryContext; -import org.apache.lens.server.api.query.collect.EstimatedImmutableQueryCollection; -import org.apache.lens.server.api.query.collect.WaitingQueriesSelectionPolicy; - -import com.google.common.annotations.VisibleForTesting; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; -import lombok.NonNull; - -/** - * Selects queries eligible by all {@link WaitingQueriesSelectionPolicy} to move them out of waiting state. - * - */ -public class IntersectingWaitingQueriesSelector implements WaitingQueriesSelector { - - private final ImmutableSet<WaitingQueriesSelectionPolicy> selectionPolicies; - - public IntersectingWaitingQueriesSelector( - @NonNull final ImmutableSet<WaitingQueriesSelectionPolicy> selectionPolicies) { - this.selectionPolicies = selectionPolicies; - } - - /** - * Selects queries eligible by all {@link WaitingQueriesSelectionPolicy} to move them out of waiting state. - * - * @see WaitingQueriesSelector#selectQueries(FinishedLensQuery, EstimatedImmutableQueryCollection) - * - * @param finishedQuery - * @param waitingQueries - * @return - */ - @Override - public Set<QueryContext> selectQueries(final FinishedLensQuery finishedQuery, - final EstimatedImmutableQueryCollection waitingQueries) { - - Set<WaitingQueriesSelectionPolicy> allSelectionPolicies = prepareAllSelectionPolicies(finishedQuery); - - List<Set<QueryContext>> candiateQueriesSets = getAllCandidateQueriesSets(finishedQuery, waitingQueries, - allSelectionPolicies); - - return findCommonQueries(candiateQueriesSets); - } - - @VisibleForTesting - Set<WaitingQueriesSelectionPolicy> prepareAllSelectionPolicies(final FinishedLensQuery finishedQuery) { - - /* Get the selection policies of driver on which this query was run */ - ImmutableSet<WaitingQueriesSelectionPolicy> driverSelectionPolicies = finishedQuery.getDriverSelectionPolicies(); - - return Sets.union(this.selectionPolicies, driverSelectionPolicies); - } - - private List<Set<QueryContext>> getAllCandidateQueriesSets( - final FinishedLensQuery finishedQuery, final EstimatedImmutableQueryCollection waitingQueries, - final Set<WaitingQueriesSelectionPolicy> allSelectionPolicies) { - - List<Set<QueryContext>> candidateQueriesSets = Lists.newLinkedList(); - - for (final WaitingQueriesSelectionPolicy selectionPolicy : allSelectionPolicies) { - - Set<QueryContext> candiateQueries = selectionPolicy.selectQueries(finishedQuery, waitingQueries); - candidateQueriesSets.add(candiateQueries); - } - return candidateQueriesSets; - } - - @VisibleForTesting - Set<QueryContext> findCommonQueries(final List<Set<QueryContext>> candiateQueriesSets) { - - Set<QueryContext> commonQueries = Sets.newLinkedHashSet(); - - if (!candiateQueriesSets.isEmpty()) { - commonQueries = Iterables.get(candiateQueriesSets, 0); - - for (Set<QueryContext> candidateEligibleQueries : candiateQueriesSets) { - commonQueries.retainAll(candidateEligibleQueries); - } - } - return commonQueries; - } -} http://git-wip-us.apache.org/repos/asf/lens/blob/7ad12ed7/lens-server/src/main/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelector.java ---------------------------------------------------------------------- diff --git a/lens-server/src/main/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelector.java b/lens-server/src/main/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelector.java new file mode 100644 index 0000000..8db059e --- /dev/null +++ b/lens-server/src/main/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelector.java @@ -0,0 +1,93 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.lens.server.query.collect; + +import java.util.List; +import java.util.Set; + +import org.apache.lens.server.api.query.FinishedLensQuery; +import org.apache.lens.server.api.query.QueryContext; +import org.apache.lens.server.api.query.collect.EstimatedImmutableQueryCollection; +import org.apache.lens.server.api.query.collect.WaitingQueriesSelectionPolicy; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import lombok.NonNull; + +/** + * Selects queries eligible by all {@link WaitingQueriesSelectionPolicy} to move them out of waiting state. + * + */ +public class UnioningWaitingQueriesSelector implements WaitingQueriesSelector { + + private final ImmutableSet<WaitingQueriesSelectionPolicy> selectionPolicies; + + public UnioningWaitingQueriesSelector( + @NonNull final ImmutableSet<WaitingQueriesSelectionPolicy> selectionPolicies) { + this.selectionPolicies = selectionPolicies; + } + + /** + * Selects queries eligible by all {@link WaitingQueriesSelectionPolicy} to move them out of waiting state. + * + * @see WaitingQueriesSelector#selectQueries(FinishedLensQuery, EstimatedImmutableQueryCollection) + * + * @param finishedQuery + * @param waitingQueries + * @return + */ + @Override + public Set<QueryContext> selectQueries(final FinishedLensQuery finishedQuery, + final EstimatedImmutableQueryCollection waitingQueries) { + + Set<WaitingQueriesSelectionPolicy> allSelectionPolicies = prepareAllSelectionPolicies(finishedQuery); + + List<Set<QueryContext>> candiateQueriesSets = getAllCandidateQueriesSets(finishedQuery, waitingQueries, + allSelectionPolicies); + + return Sets.newHashSet(Iterables.concat(candiateQueriesSets)); + } + + @VisibleForTesting + Set<WaitingQueriesSelectionPolicy> prepareAllSelectionPolicies(final FinishedLensQuery finishedQuery) { + + /* Get the selection policies of driver on which this query was run */ + ImmutableSet<WaitingQueriesSelectionPolicy> driverSelectionPolicies = finishedQuery.getDriverSelectionPolicies(); + + return Sets.union(this.selectionPolicies, driverSelectionPolicies); + } + + private List<Set<QueryContext>> getAllCandidateQueriesSets( + final FinishedLensQuery finishedQuery, final EstimatedImmutableQueryCollection waitingQueries, + final Set<WaitingQueriesSelectionPolicy> allSelectionPolicies) { + + List<Set<QueryContext>> candidateQueriesSets = Lists.newLinkedList(); + + for (final WaitingQueriesSelectionPolicy selectionPolicy : allSelectionPolicies) { + + Set<QueryContext> candiateQueries = selectionPolicy.selectQueries(finishedQuery, waitingQueries); + candidateQueriesSets.add(candiateQueries); + } + return candidateQueriesSets; + } + +} http://git-wip-us.apache.org/repos/asf/lens/blob/7ad12ed7/lens-server/src/test/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelectorTest.java ---------------------------------------------------------------------- diff --git a/lens-server/src/test/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelectorTest.java b/lens-server/src/test/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelectorTest.java deleted file mode 100644 index 62e371d..0000000 --- a/lens-server/src/test/java/org/apache/lens/server/query/collect/IntersectingWaitingQueriesSelectorTest.java +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ - -package org.apache.lens.server.query.collect; - -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; -import java.util.Set; - -import org.apache.lens.server.api.query.FinishedLensQuery; -import org.apache.lens.server.api.query.QueryContext; -import org.apache.lens.server.api.query.collect.EstimatedImmutableQueryCollection; -import org.apache.lens.server.api.query.collect.WaitingQueriesSelectionPolicy; - -import org.testng.annotations.Test; -import org.testng.collections.Sets; - -import com.beust.jcommander.internal.Lists; -import com.google.common.collect.ImmutableSet; - -public class IntersectingWaitingQueriesSelectorTest { - - @Test - public void testFindCommonQueriesWhenInputIsEmptyListOfSets() { - - List<Set<QueryContext>> candidateQueriesSets = Lists.newArrayList(); - Set<QueryContext> expectedEligibleQueries = Sets.newHashSet(); - - testFindCommonQueries(candidateQueriesSets, expectedEligibleQueries); - } - - @Test - public void testFindCommonQueriesWhenNoCommonQueryIsPresent() { - - QueryContext eligibleQuery1 = mock(QueryContext.class); - QueryContext eligibleQuery2 = mock(QueryContext.class); - - Set<QueryContext> eligibleQueriesSetA = Sets.newHashSet(Arrays.asList(eligibleQuery1)); - Set<QueryContext> eligibleQueriesSetB = Sets.newHashSet(Arrays.asList(eligibleQuery2)); - - List<Set<QueryContext>> candidateQueriesSets = Arrays.asList(eligibleQueriesSetA, eligibleQueriesSetB); - Set<QueryContext> expectedEligibleQueries = Sets.newHashSet(); - - testFindCommonQueries(candidateQueriesSets, expectedEligibleQueries); - } - - @Test - public void testFindCommonQueriesWhenACommonQueryIsPresent() { - - QueryContext eligibleQuery1 = mock(QueryContext.class); - QueryContext eligibleQuery2 = mock(QueryContext.class); - QueryContext eligibleQuery3 = mock(QueryContext.class); - - Set<QueryContext> eligibleQueriesSetA = Sets.newHashSet(Arrays.asList(eligibleQuery1, eligibleQuery2)); - Set<QueryContext> eligibleQueriesSetB = Sets.newHashSet(Arrays.asList(eligibleQuery1, eligibleQuery3)); - - List<Set<QueryContext>> candidateQueriesSets = Arrays.asList(eligibleQueriesSetA, eligibleQueriesSetB); - Set<QueryContext> expectedEligibleQueries = Sets.newHashSet(Arrays.asList(eligibleQuery1)); - - testFindCommonQueries(candidateQueriesSets, expectedEligibleQueries); - } - - private void testFindCommonQueries(final List<Set<QueryContext>> queriesSets, - final Set<QueryContext> expectedEligibleQueries) { - - IntersectingWaitingQueriesSelector selector = new IntersectingWaitingQueriesSelector(mock(ImmutableSet.class)); - - Set<QueryContext> actualCommonQueries = selector.findCommonQueries(queriesSets); - assertEquals(actualCommonQueries, expectedEligibleQueries); - } - - @Test - public void testPrepareAllSelectionPolicies() { - - WaitingQueriesSelectionPolicy p1 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy p2 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy dp1 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy dp2 = mock(WaitingQueriesSelectionPolicy.class); - - FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); - when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.of(dp1, dp2)); - - IntersectingWaitingQueriesSelector selector = new IntersectingWaitingQueriesSelector(ImmutableSet.of(p1, p2)); - assertEquals(selector.prepareAllSelectionPolicies(mockFinishedQuery), ImmutableSet.of(p1, p2, dp1, dp2)); - } - - @Test - public void testPrepareAllSelectionPoliciesWithNoDriverSelectionPolicy() { - - WaitingQueriesSelectionPolicy p1 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy p2 = mock(WaitingQueriesSelectionPolicy.class); - - final ImmutableSet<WaitingQueriesSelectionPolicy> emptySet = ImmutableSet.copyOf( - Sets.<WaitingQueriesSelectionPolicy>newHashSet()); - - FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); - when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(emptySet); - - IntersectingWaitingQueriesSelector selector = new IntersectingWaitingQueriesSelector(ImmutableSet.of(p1, p2)); - - assertEquals(selector.prepareAllSelectionPolicies(mockFinishedQuery), ImmutableSet.of(p1, p2)); - } - - @Test - public void testSelectQueriesCommonBetweenAllSelectionPolicies(){ - - QueryContext q1 = mock(QueryContext.class); - QueryContext q2 = mock(QueryContext.class); - QueryContext q3 = mock(QueryContext.class); - - /* eligibleQueriesSet1, eligibleQueriesSet2, eligibleQueriesSet3 have q1 in common */ - Set<QueryContext> eligibleQueriesSet1 = Sets.newHashSet(Arrays.asList(q1, q2)); - Set<QueryContext> eligibleQueriesSet2 = Sets.newHashSet(Arrays.asList(q1, q3)); - Set<QueryContext> eligibleQueriesSet3 = Sets.newHashSet(Arrays.asList(q1, q2)); - - FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); - EstimatedImmutableQueryCollection mockWaitingQueries = mock(EstimatedImmutableQueryCollection.class); - WaitingQueriesSelectionPolicy policy1 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy policy2 = mock(WaitingQueriesSelectionPolicy.class); - WaitingQueriesSelectionPolicy driverSelectionPolicy = mock(WaitingQueriesSelectionPolicy.class); - - when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.of(driverSelectionPolicy)); - - /* selection policy1 will return eligibleQueriesSet1 */ - when(policy1.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet1); - - /* selection policy2 will return eligibleQueriesSet2 */ - when(policy2.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet2); - - /* driver selection policy will return eligibleQueriesSet3 */ - when(driverSelectionPolicy.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet3); - - WaitingQueriesSelector selector = new IntersectingWaitingQueriesSelector(ImmutableSet.of(policy1, policy2)); - - /* selector should return only eligibleQuery1, as this is the only common eligible waiting query returned - * by both selection policies */ - Set<QueryContext> actualEligibleQueries = selector.selectQueries(mockFinishedQuery, mockWaitingQueries); - Set<QueryContext> expectedEligibleQueries = Sets.newHashSet(Arrays.asList(q1)); - - assertEquals(actualEligibleQueries, expectedEligibleQueries); - } - - @Test(expectedExceptions = NullPointerException.class) - public void testSelectorMustNotAcceptNullAsSelectionPolicies() { - new IntersectingWaitingQueriesSelector(null); - } - - @Test - public void testSelectQueriesWithNoSelectionPolicies(){ - - FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); - EstimatedImmutableQueryCollection mockWaitingQueries = mock(EstimatedImmutableQueryCollection.class); - Set<WaitingQueriesSelectionPolicy> emptySetOfPolicies = Sets.newHashSet(); - - when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.copyOf(emptySetOfPolicies)); - - WaitingQueriesSelector selector = new IntersectingWaitingQueriesSelector(ImmutableSet.copyOf(emptySetOfPolicies)); - - /* selector should return an empty set as no selection policy is available */ - Set<QueryContext> actualEligibleQueries = selector.selectQueries(mockFinishedQuery, mockWaitingQueries); - - assertTrue(actualEligibleQueries.isEmpty()); - } -} http://git-wip-us.apache.org/repos/asf/lens/blob/7ad12ed7/lens-server/src/test/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelectorTest.java ---------------------------------------------------------------------- diff --git a/lens-server/src/test/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelectorTest.java b/lens-server/src/test/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelectorTest.java new file mode 100644 index 0000000..98801de --- /dev/null +++ b/lens-server/src/test/java/org/apache/lens/server/query/collect/UnioningWaitingQueriesSelectorTest.java @@ -0,0 +1,135 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.lens.server.query.collect; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertTrue; + +import java.util.Arrays; +import java.util.Set; + +import org.apache.lens.server.api.query.FinishedLensQuery; +import org.apache.lens.server.api.query.QueryContext; +import org.apache.lens.server.api.query.collect.EstimatedImmutableQueryCollection; +import org.apache.lens.server.api.query.collect.WaitingQueriesSelectionPolicy; + +import org.testng.annotations.Test; +import org.testng.collections.Sets; + +import com.google.common.collect.ImmutableSet; + +public class UnioningWaitingQueriesSelectorTest { + + @Test + public void testPrepareAllSelectionPolicies() { + + WaitingQueriesSelectionPolicy p1 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy p2 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy dp1 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy dp2 = mock(WaitingQueriesSelectionPolicy.class); + + FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); + when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.of(dp1, dp2)); + + UnioningWaitingQueriesSelector selector = new UnioningWaitingQueriesSelector(ImmutableSet.of(p1, p2)); + assertEquals(selector.prepareAllSelectionPolicies(mockFinishedQuery), ImmutableSet.of(p1, p2, dp1, dp2)); + } + + @Test + public void testPrepareAllSelectionPoliciesWithNoDriverSelectionPolicy() { + + WaitingQueriesSelectionPolicy p1 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy p2 = mock(WaitingQueriesSelectionPolicy.class); + + final ImmutableSet<WaitingQueriesSelectionPolicy> emptySet = ImmutableSet.copyOf( + Sets.<WaitingQueriesSelectionPolicy>newHashSet()); + + FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); + when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(emptySet); + + UnioningWaitingQueriesSelector selector = new UnioningWaitingQueriesSelector(ImmutableSet.of(p1, p2)); + + assertEquals(selector.prepareAllSelectionPolicies(mockFinishedQuery), ImmutableSet.of(p1, p2)); + } + + @Test + public void testSelectQueriesWithAllSelectionPolicies(){ + + QueryContext q1 = mock(QueryContext.class); + QueryContext q2 = mock(QueryContext.class); + QueryContext q3 = mock(QueryContext.class); + + /* eligibleQueriesSet1, eligibleQueriesSet2, eligibleQueriesSet3 have q1 in common */ + Set<QueryContext> eligibleQueriesSet1 = Sets.newHashSet(Arrays.asList(q1, q2)); + Set<QueryContext> eligibleQueriesSet2 = Sets.newHashSet(Arrays.asList(q1, q3)); + Set<QueryContext> eligibleQueriesSet3 = Sets.newHashSet(Arrays.asList(q1, q2)); + + FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); + EstimatedImmutableQueryCollection mockWaitingQueries = mock(EstimatedImmutableQueryCollection.class); + WaitingQueriesSelectionPolicy policy1 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy policy2 = mock(WaitingQueriesSelectionPolicy.class); + WaitingQueriesSelectionPolicy driverSelectionPolicy = mock(WaitingQueriesSelectionPolicy.class); + + when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.of(driverSelectionPolicy)); + + /* selection policy1 will return eligibleQueriesSet1 */ + when(policy1.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet1); + + /* selection policy2 will return eligibleQueriesSet2 */ + when(policy2.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet2); + + /* driver selection policy will return eligibleQueriesSet3 */ + when(driverSelectionPolicy.selectQueries(mockFinishedQuery, mockWaitingQueries)).thenReturn(eligibleQueriesSet3); + + WaitingQueriesSelector selector = new UnioningWaitingQueriesSelector(ImmutableSet.of(policy1, policy2)); + + /* selector should return only eligibleQuery1, as this is the only common eligible waiting query returned + * by both selection policies */ + Set<QueryContext> actualEligibleQueries = selector.selectQueries(mockFinishedQuery, mockWaitingQueries); + Set<QueryContext> expectedEligibleQueries = Sets.newHashSet(Arrays.asList(q1, q2, q3)); + + assertEquals(actualEligibleQueries, expectedEligibleQueries); + } + + @Test(expectedExceptions = NullPointerException.class) + public void testSelectorMustNotAcceptNullAsSelectionPolicies() { + new UnioningWaitingQueriesSelector(null); + } + + @Test + public void testSelectQueriesWithNoSelectionPolicies(){ + + FinishedLensQuery mockFinishedQuery = mock(FinishedLensQuery.class); + EstimatedImmutableQueryCollection mockWaitingQueries = mock(EstimatedImmutableQueryCollection.class); + Set<WaitingQueriesSelectionPolicy> emptySetOfPolicies = Sets.newHashSet(); + + when(mockFinishedQuery.getDriverSelectionPolicies()).thenReturn(ImmutableSet.copyOf(emptySetOfPolicies)); + + WaitingQueriesSelector selector = new UnioningWaitingQueriesSelector(ImmutableSet.copyOf(emptySetOfPolicies)); + + /* selector should return an empty set as no selection policy is available */ + Set<QueryContext> actualEligibleQueries = selector.selectQueries(mockFinishedQuery, mockWaitingQueries); + + assertTrue(actualEligibleQueries.isEmpty()); + } + +}
