DonalEvans commented on a change in pull request #7010: URL: https://github.com/apache/geode/pull/7010#discussion_r736712020
########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); Review comment: This constant doesn't seem necessary. What is its purpose? ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); + + private static final AtomicReference<LocatorLauncher> LOCATOR = Review comment: This can be removed and the `startLocator()` method changed to: ``` LocatorLauncher locatorLauncher = new LocatorLauncher.Builder() .setMemberName(name) .setPort(locatorPort) .setWorkingDirectory(workingDirectory.getAbsolutePath()) .set(JMX_MANAGER, "true") .set(JMX_MANAGER_PORT, String.valueOf(jmxPort)) .set(JMX_MANAGER_START, "true") .build(); locatorLauncher.start(); await().untilAsserted(() -> { InternalLocator locator = (InternalLocator) locatorLauncher.getLocator(); assertThat(locator.isSharedConfigurationRunning()) .as("Locator shared configuration is running on locator" + getVMId()) .isTrue(); }); ``` ########## File path: geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactRangeIndex.java ########## @@ -481,8 +482,13 @@ private void lockedQueryPrivate(Object key, int operator, Collection results, int limit = -1; Boolean applyLimit = (Boolean) context.cacheGet(CompiledValue.CAN_APPLY_LIMIT_AT_INDEX); + String indexThresholdSize = + System.getProperty(GeodeGlossary.GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE"); if (applyLimit != null && applyLimit) { limit = (Integer) context.cacheGet(CompiledValue.RESULT_LIMIT); + if (indexThresholdSize != null && limit < Integer.parseInt(indexThresholdSize)) { + limit = Integer.parseInt(indexThresholdSize); Review comment: The `lockedQuery()` method in this class also applies a limit. For consistent behaviour, should this change also be applied there? Similarly, other index classes (`HashIndex`, `QueryUtils`, `PrimaryKeyIndex` and `RangeIndex`) use the `CAN_APPLY_LIMIT_AT_INDEX` constant to determine if a limit should be applied, then use the value in `RESULT_LIMIT` to set the limit. This change should be applied in all of those places too, to ensure consistent behaviour. ########## File path: geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactRangeIndex.java ########## @@ -481,8 +482,13 @@ private void lockedQueryPrivate(Object key, int operator, Collection results, int limit = -1; Boolean applyLimit = (Boolean) context.cacheGet(CompiledValue.CAN_APPLY_LIMIT_AT_INDEX); + String indexThresholdSize = + System.getProperty(GeodeGlossary.GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE"); Review comment: Since this value shouldn't be changed at runtime, would it be better to set it when the index is constructed rather than fetching it every time the index is queried? It could also use `Integer.getInteger()` with a default value of 100 (the current default) to avoid having to call `parseInt()` for every query execution. Also, it seems that with this change, there are now three classes, `CompactRangeIndex`, `AbstractGroupOrRangeJunction`, and `CompiledValue` using this system property. It might make sense to have it defined as a constant in only one place, with a default, and then referenced from there if it needs to be used. ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); + + private static final AtomicReference<LocatorLauncher> LOCATOR = + new AtomicReference<>(DUMMY_LOCATOR); + + private static final ServerLauncher DUMMY_SERVER = mock(ServerLauncher.class); + + private static final AtomicReference<ServerLauncher> SERVER = + new AtomicReference<>(DUMMY_SERVER); + + private VM locator, server; + + private String regionName; + + @Before + public void setUp() throws Exception { + locator = getVM(0); + server = getVM(1); + + locatorName = "locator"; + serverName = "server"; + regionName = "exampleRegion"; + + locatorDir = temporaryFolder.newFolder(locatorName); + serverDir = temporaryFolder.newFolder(serverName); + + int[] port = getRandomAvailableTCPPorts(3); + locatorPort = port[0]; + locatorJmxPort = port[1]; + serverPort = port[2]; + + locators = "localhost[" + locatorPort + "]"; + + locator.invoke(() -> startLocator(locatorName, locatorDir, locatorPort, locatorJmxPort)); + + gfsh.connectAndVerify(locatorJmxPort, GfshCommandRule.PortType.jmxManager); + + server.invoke(() -> startServer(serverName, serverDir, serverPort, locators)); + } + + @Test + public void testQueryWithWildcardAndIndexOnAttributeFromHashMap() { + gfsh.executeAndAssertThat("create region --name=" + regionName + " --type=PARTITION") + .statusIsSuccess(); + + server.invoke(() -> { + QueryService cacheQS = GemFireCacheImpl.getInstance().getQueryService(); Review comment: `GemFireCacheImpl.getInstance()` is deprecated and should not be used. Instead, you can do: ``` Cache cache = SERVER.get().getCache(); QueryService cacheQS = cache.getQueryService(); ``` The `cache` variable can then also be used on line 131 rather than using another call to `GemFireCacheImpl.getInstance()`. ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); + + private static final AtomicReference<LocatorLauncher> LOCATOR = + new AtomicReference<>(DUMMY_LOCATOR); + + private static final ServerLauncher DUMMY_SERVER = mock(ServerLauncher.class); Review comment: This constant doesn't seem necessary. What is its purpose? ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); + + private static final AtomicReference<LocatorLauncher> LOCATOR = + new AtomicReference<>(DUMMY_LOCATOR); + + private static final ServerLauncher DUMMY_SERVER = mock(ServerLauncher.class); + + private static final AtomicReference<ServerLauncher> SERVER = + new AtomicReference<>(DUMMY_SERVER); + + private VM locator, server; + + private String regionName; + + @Before + public void setUp() throws Exception { + locator = getVM(0); + server = getVM(1); + + locatorName = "locator"; + serverName = "server"; + regionName = "exampleRegion"; + + locatorDir = temporaryFolder.newFolder(locatorName); + serverDir = temporaryFolder.newFolder(serverName); + + int[] port = getRandomAvailableTCPPorts(3); + locatorPort = port[0]; + locatorJmxPort = port[1]; + serverPort = port[2]; + + locators = "localhost[" + locatorPort + "]"; + + locator.invoke(() -> startLocator(locatorName, locatorDir, locatorPort, locatorJmxPort)); + + gfsh.connectAndVerify(locatorJmxPort, GfshCommandRule.PortType.jmxManager); + + server.invoke(() -> startServer(serverName, serverDir, serverPort, locators)); + } + + @Test + public void testQueryWithWildcardAndIndexOnAttributeFromHashMap() { + gfsh.executeAndAssertThat("create region --name=" + regionName + " --type=PARTITION") + .statusIsSuccess(); + + server.invoke(() -> { + QueryService cacheQS = GemFireCacheImpl.getInstance().getQueryService(); + cacheQS.createIndex("IdIndex", "value.positions['SUN']", + SEPARATOR + regionName + ".entrySet"); + Region<Integer, Portfolio> region = + GemFireCacheImpl.getInstance().getRegion(regionName); + FunctionService.onRegion(region).execute(new MyFunction()); + await().untilAsserted(() -> assertThat(region.size()).isEqualTo(10000)); + }); + + String query = "query --query=\"<trace> select e.key, e.value from " + + SEPARATOR + regionName + ".entrySet e where e.value.positions['SUN'] like 'somethin%'\""; + + String cmdResult = String.valueOf(gfsh.executeAndAssertThat(query).getResultModel()); + assertThat(cmdResult).contains("\"Rows\":\"1\""); + assertThat(cmdResult).contains("indexesUsed(1):IdIndex(Results: 10000)"); + } + + private static void startLocator(String name, File workingDirectory, int locatorPort, + int jmxPort) { + LOCATOR.set(new LocatorLauncher.Builder() + .setMemberName(name) + .setPort(locatorPort) + .setWorkingDirectory(workingDirectory.getAbsolutePath()) + .set(JMX_MANAGER, "true") + .set(JMX_MANAGER_PORT, String.valueOf(jmxPort)) + .set(JMX_MANAGER_START, "true") + .build()); + + LOCATOR.get().start(); + + await().untilAsserted(() -> { + InternalLocator locator = (InternalLocator) LOCATOR.get().getLocator(); + assertThat(locator.isSharedConfigurationRunning()) + .as("Locator shared configuration is running on locator" + getVMId()) + .isTrue(); + }); + } + + private static void startServer(String name, File workingDirectory, int serverPort, + String locators) { + System.setProperty(GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE", "10000"); + SERVER.set(new ServerLauncher.Builder() + .setDeletePidFileOnStop(Boolean.TRUE) + .setMemberName(name) + .setServerPort(serverPort) + .setWorkingDirectory(workingDirectory.getAbsolutePath()) + .set(HTTP_SERVICE_PORT, "0") + .set(LOCATORS, locators) + .build()); + + SERVER.get().start(); + } + + public static class MyFunction implements Function, DataSerializable { + @Override + public void execute(FunctionContext context) { + Java6Assertions.assertThat(context).isInstanceOf(RegionFunctionContext.class); + PartitionedRegion region = (PartitionedRegion) ((RegionFunctionContext) context).getDataSet(); Review comment: This can be simplified to: ``` Region<Integer, Portfolio> region = context.getCache().getRegion(regionName); ``` if `regionName` is made a constant. ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; Review comment: These Strings are never modified, so they can be made constants, similarly for `regionName`. ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; + + private String locators; + + private static final LocatorLauncher DUMMY_LOCATOR = mock(LocatorLauncher.class); + + private static final AtomicReference<LocatorLauncher> LOCATOR = + new AtomicReference<>(DUMMY_LOCATOR); + + private static final ServerLauncher DUMMY_SERVER = mock(ServerLauncher.class); + + private static final AtomicReference<ServerLauncher> SERVER = + new AtomicReference<>(DUMMY_SERVER); + + private VM locator, server; + + private String regionName; + + @Before + public void setUp() throws Exception { + locator = getVM(0); + server = getVM(1); + + locatorName = "locator"; + serverName = "server"; + regionName = "exampleRegion"; + + locatorDir = temporaryFolder.newFolder(locatorName); + serverDir = temporaryFolder.newFolder(serverName); + + int[] port = getRandomAvailableTCPPorts(3); + locatorPort = port[0]; + locatorJmxPort = port[1]; + serverPort = port[2]; + + locators = "localhost[" + locatorPort + "]"; + + locator.invoke(() -> startLocator(locatorName, locatorDir, locatorPort, locatorJmxPort)); + + gfsh.connectAndVerify(locatorJmxPort, GfshCommandRule.PortType.jmxManager); + + server.invoke(() -> startServer(serverName, serverDir, serverPort, locators)); + } + + @Test + public void testQueryWithWildcardAndIndexOnAttributeFromHashMap() { + gfsh.executeAndAssertThat("create region --name=" + regionName + " --type=PARTITION") + .statusIsSuccess(); + + server.invoke(() -> { + QueryService cacheQS = GemFireCacheImpl.getInstance().getQueryService(); + cacheQS.createIndex("IdIndex", "value.positions['SUN']", + SEPARATOR + regionName + ".entrySet"); + Region<Integer, Portfolio> region = + GemFireCacheImpl.getInstance().getRegion(regionName); + FunctionService.onRegion(region).execute(new MyFunction()); + await().untilAsserted(() -> assertThat(region.size()).isEqualTo(10000)); + }); + + String query = "query --query=\"<trace> select e.key, e.value from " + + SEPARATOR + regionName + ".entrySet e where e.value.positions['SUN'] like 'somethin%'\""; + + String cmdResult = String.valueOf(gfsh.executeAndAssertThat(query).getResultModel()); + assertThat(cmdResult).contains("\"Rows\":\"1\""); + assertThat(cmdResult).contains("indexesUsed(1):IdIndex(Results: 10000)"); + } + + private static void startLocator(String name, File workingDirectory, int locatorPort, + int jmxPort) { + LOCATOR.set(new LocatorLauncher.Builder() + .setMemberName(name) + .setPort(locatorPort) + .setWorkingDirectory(workingDirectory.getAbsolutePath()) + .set(JMX_MANAGER, "true") + .set(JMX_MANAGER_PORT, String.valueOf(jmxPort)) + .set(JMX_MANAGER_START, "true") + .build()); + + LOCATOR.get().start(); + + await().untilAsserted(() -> { + InternalLocator locator = (InternalLocator) LOCATOR.get().getLocator(); + assertThat(locator.isSharedConfigurationRunning()) + .as("Locator shared configuration is running on locator" + getVMId()) + .isTrue(); + }); + } + + private static void startServer(String name, File workingDirectory, int serverPort, + String locators) { + System.setProperty(GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE", "10000"); + SERVER.set(new ServerLauncher.Builder() + .setDeletePidFileOnStop(Boolean.TRUE) + .setMemberName(name) + .setServerPort(serverPort) + .setWorkingDirectory(workingDirectory.getAbsolutePath()) + .set(HTTP_SERVICE_PORT, "0") + .set(LOCATORS, locators) + .build()); + + SERVER.get().start(); + } + + public static class MyFunction implements Function, DataSerializable { + @Override + public void execute(FunctionContext context) { Review comment: Warnings here can be fixed by using `Function<Void>` and `FunctionContext<Void>`. Alternately, these puts could just be done inline in the test inside the invocation on the server instead of using function execution, since there doesn't seem to be a reason for using it here. ########## File path: geode-cq/src/distributedTest/java/org/apache/geode/cache/query/dunit/QueryWithRangeIndexDUnitTest.java ########## @@ -0,0 +1,204 @@ +/* + * 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.geode.cache.query.dunit; + +import static org.apache.geode.cache.Region.SEPARATOR; +import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT; +import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START; +import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS; +import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts; +import static org.apache.geode.internal.lang.SystemPropertyHelper.GEMFIRE_PREFIX; +import static org.apache.geode.test.awaitility.GeodeAwaitility.await; +import static org.apache.geode.test.dunit.VM.getVM; +import static org.apache.geode.test.dunit.VM.getVMId; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.Serializable; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicReference; + +import org.assertj.core.api.Java6Assertions; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import org.apache.geode.DataSerializable; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.execute.Function; +import org.apache.geode.cache.execute.FunctionContext; +import org.apache.geode.cache.execute.FunctionService; +import org.apache.geode.cache.execute.RegionFunctionContext; +import org.apache.geode.cache.query.QueryService; +import org.apache.geode.cache.query.data.Portfolio; +import org.apache.geode.distributed.LocatorLauncher; +import org.apache.geode.distributed.ServerLauncher; +import org.apache.geode.distributed.internal.InternalLocator; +import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.apache.geode.internal.cache.PartitionedRegion; +import org.apache.geode.test.dunit.VM; +import org.apache.geode.test.dunit.rules.DistributedRule; +import org.apache.geode.test.junit.rules.GfshCommandRule; +import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolder; + +public class QueryWithRangeIndexDUnitTest implements Serializable { + + @Rule + public transient GfshCommandRule gfsh = new GfshCommandRule(); + + @Rule + public DistributedRule distributedRule = new DistributedRule(); + + @Rule + public SerializableTemporaryFolder temporaryFolder = new SerializableTemporaryFolder(); + + private String locatorName, serverName; + + private File locatorDir, serverDir; + + private int locatorPort, locatorJmxPort, serverPort; Review comment: The [style guide used by Geode](https://google.github.io/styleguide/javaguide.html#s4.8.2-variable-declarations) requires that only one variable is defined per line. These should be broken up onto separate lines. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
