diff --git a/docs/schema/index-management/index-performance.md b/docs/schema/index-management/index-performance.md index 81febbf4f3..1f4247fd28 100644 --- a/docs/schema/index-management/index-performance.md +++ b/docs/schema/index-management/index-performance.md @@ -285,13 +285,17 @@ When using `order().by()` it is important to note that: results. All results will be retrieved and then sorted in-memory. For large result sets, this can be very expensive. -- Mixed indexes support ordering natively and efficiently. However, +- Mixed indexes support ordering property keys with **SINGLE** cardinality + natively and efficiently. However, the property key used in the order().by() method must have been previously added to the mixed indexed for native result ordering support. This is important in cases where the the order().by() key is different from the query keys. If the property key is not part of the index, then sorting requires loading all results into memory. +- Only Elasticsearch and Solr mixed index backends support ordering + property keys with **LIST** cardinality natively and efficiently. + ### Label Constraint In many cases it is desirable to only index vertices or edges with a diff --git a/janusgraph-backend-testutils/src/main/java/org/janusgraph/graphdb/JanusGraphIndexTest.java b/janusgraph-backend-testutils/src/main/java/org/janusgraph/graphdb/JanusGraphIndexTest.java index 851350c398..d12821daa3 100644 --- a/janusgraph-backend-testutils/src/main/java/org/janusgraph/graphdb/JanusGraphIndexTest.java +++ b/janusgraph-backend-testutils/src/main/java/org/janusgraph/graphdb/JanusGraphIndexTest.java @@ -154,6 +154,7 @@ import static org.janusgraph.testutil.JanusGraphAssert.assertNoBackendHit; import static org.janusgraph.testutil.JanusGraphAssert.assertNotEmpty; import static org.janusgraph.testutil.JanusGraphAssert.assertTraversal; +import static org.janusgraph.testutil.JanusGraphAssert.assertTraversalAndIndexUsage; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -186,16 +187,18 @@ public abstract class JanusGraphIndexTest extends JanusGraphBaseTest { public final boolean supportsGeoPoint; public final boolean supportsNumeric; public final boolean supportsText; + public final boolean supportsOrderingListProperty; public IndexFeatures indexFeatures; private static final Logger log = LoggerFactory.getLogger(JanusGraphIndexTest.class); - protected JanusGraphIndexTest(boolean supportsGeoPoint, boolean supportsNumeric, boolean supportsText) { + protected JanusGraphIndexTest(boolean supportsGeoPoint, boolean supportsNumeric, boolean supportsText, boolean supportsOrderingListProperty) { this.supportsGeoPoint = supportsGeoPoint; this.supportsNumeric = supportsNumeric; this.supportsText = supportsText; + this.supportsOrderingListProperty = supportsOrderingListProperty; } protected String[] getIndexBackends() { @@ -4754,4 +4757,189 @@ public void testGetIndexInfo() throws DecoderException { assertEquals(1, indexInfo.getCompositeIndexType().getInlineFieldKeys().length); assertEquals("id", indexInfo.getCompositeIndexType().getInlineFieldKeys()[0]); } + + @Test + public void testOrderingListProperty() { + PropertyKey name1 = mgmt.makePropertyKey("name1").dataType(String.class).cardinality(Cardinality.SINGLE) + .make(); + PropertyKey name2 = mgmt.makePropertyKey("name2").dataType(String.class).cardinality(Cardinality.LIST) + .make(); + PropertyKey gender = mgmt.makePropertyKey("gender").dataType(String.class).cardinality(Cardinality.SINGLE).make(); + PropertyKey age1 = mgmt.makePropertyKey("age1").dataType(Double.class).cardinality(Cardinality.SINGLE).make(); + PropertyKey age2 = mgmt.makePropertyKey("age2").dataType(Double.class).cardinality(Cardinality.LIST).make(); + PropertyKey birth1 = mgmt.makePropertyKey("birth1").dataType(Date.class).cardinality(Cardinality.SINGLE).make(); + PropertyKey birth2 = mgmt.makePropertyKey("birth2").dataType(Date.class).cardinality(Cardinality.LIST).make(); + + mgmt.buildIndex("listPropertyOrdering", Vertex.class) + .addKey(name1, Mapping.STRING.asParameter()) + .addKey(name2, Mapping.STRING.asParameter()) + .addKey(gender, Mapping.STRING.asParameter()) + .addKey(age1) + .addKey(age2) + .addKey(birth1) + .addKey(birth2) + .buildMixedIndex(INDEX); + finishSchema(); + + Vertex v1 = tx.addVertex("gender", "male", "name1", "value1", "name2", "value1", "age1", 1, "age2", 1, "birth1", "2010-01-01T00:00:00", "birth2", "2010-01-01T00:00:00"); + Vertex v2 = tx.addVertex("gender", "female", "name1", "value2", "name2", "value2", "age1", 2, "age2", 2, "birth1", "2011-01-01T00:00:00", "birth2", "2011-01-01T00:00:00"); + Vertex v3 = tx.addVertex("gender", "male", "name1", "value3", "name2", "value3", "name2", "value8", "age1", 3, "age2", 3, "birth1", "2012-01-01T00:00:00", "birth2", "2012-01-01T00:00:00"); + Vertex v4 = tx.addVertex("gender", "female", "name1", "value4", "name2", "value4", "name2", "value7", "age1", 4, "age2", 4, "birth1", "2013-01-01T00:00:00", "birth2", "2013-01-01T00:00:00"); + Vertex v5 = tx.addVertex("gender", "male", "name1", "value5", "name2", "value5", "age1", 5, "age2", 5, "birth1", "2014-01-01T00:00:00", "birth2", "2014-01-01T00:00:00"); + Vertex v6 = tx.addVertex("gender", "female", "name1", "value6", "name2", "value6", "age1", 6, "age2", 6, "birth1", "2015-01-01T00:00:00", "birth2", "2015-01-01T00:00:00"); + tx.commit(); + + clopen(option(FORCE_INDEX_USAGE), false); + + final GraphTraversalSource g = tx.traversal(); + org.apache.tinkerpop.gremlin.process.traversal.Order ORDER_DESC = org.apache.tinkerpop.gremlin.process.traversal.Order.desc; + + // ordering without using index on SINGLE cardinality property + Supplier> tFullscanSingle = () -> g.V().order().by("name1"); + assertTraversalAndIndexUsage( + Arrays.asList( + "query=[]", + "_fullscan=true" + ), + tFullscanSingle, v1, v2, v3, v4, v5, v6 + ); + + // ordering without using index on LIST cardinality property with multiple values + // throws IllegalStateException with message "Multiple properties exist for the provided key, use Vertex.properties(name2)" + Exception exception = assertThrows(IllegalStateException.class, () -> { + g.V().order().by("name2").toList(); + }); + assertTrue(exception.getMessage().contains("Multiple properties exist for the provided key, use Vertex.properties(name2)")); + + /////////////////////////////////////////////////// + // ordering SINGLE cardinality properties + // ordering SINGLE cardinality String property + Supplier> tSingleString = () -> g.V().has("name1").order().by("name1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(name1 <> null)", + "_query=[(name1 <> null)][DESC(name1)]:listPropertyOrdering" + ), + tSingleString, v6, v5, v4, v3, v2, v1 + ); + + // ordering SINGLE cardinality Double property + Supplier> tSingleDouble = () -> g.V().has("age1").order().by("age1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(age1 <> null)", + "_query=[(age1 <> null)][DESC(age1)]:listPropertyOrdering" + ), + tSingleDouble, v6, v5, v4, v3, v2, v1 + ); + + // ordering SINGLE cardinality Date property + Supplier> tSingleDate = () -> g.V().has("birth1").order().by("birth1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(birth1 <> null)", + "_query=[(birth1 <> null)][DESC(birth1)]:listPropertyOrdering" + ), + tSingleDate, v6, v5, v4, v3, v2, v1 + ); + + ///////////////////////////////////////////////// + // ordering SINGLE cardinality properties with filtering + // ordering SINGLE cardinality String property + Supplier> tSingleStringFilter = () -> g.V().has("gender", "female").has("name1").order().by("name1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND name1 <> null)", + "_query=[(gender = female AND name1 <> null)][DESC(name1)]:listPropertyOrdering" + ), + tSingleStringFilter, v6, v4, v2 + ); + + // ordering SINGLE cardinality Double property + Supplier> tSingleDoubleFilter = () -> g.V().has("gender", "female").has("age1").order().by("age1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND age1 <> null)", + "_query=[(gender = female AND age1 <> null)][DESC(age1)]:listPropertyOrdering" + ), + tSingleDoubleFilter, v6, v4, v2 + ); + + // ordering SINGLE cardinality Date property + Supplier> tSingleDateFilter = () -> g.V().has("gender", "female").has("birth1").order().by("birth1", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND birth1 <> null)", + "_query=[(gender = female AND birth1 <> null)][DESC(birth1)]:listPropertyOrdering" + ), + tSingleDateFilter, v6, v4, v2 + ); + + // certain mixed index backend specific part since Lucene does not support ordering for list properties + if (supportsOrderingListProperty) { + /////////////////////////////////////////////////// + // ordering LIST cardinality properties + // ordering LIST cardinality String property + Supplier> tListString = () -> g.V().has("name2").order().by("name2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(name2 <> null)", + "_query=[(name2 <> null)][DESC(name2)]:listPropertyOrdering" + ), + tListString, v3, v4, v6, v5, v2, v1 + ); + + // ordering LIST cardinality Double property + Supplier> tListDouble = () -> g.V().has("age2").order().by("age2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(age2 <> null)", + "_query=[(age2 <> null)][DESC(age2)]:listPropertyOrdering" + ), + tListDouble, v6, v5, v4, v3, v2, v1 + ); + + // ordering LIST cardinality Date property + Supplier> tListDate = () -> g.V().has("birth2").order().by("birth2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(birth2 <> null)", + "_query=[(birth2 <> null)][DESC(birth2)]:listPropertyOrdering" + ), + tListDate, v6, v5, v4, v3, v2, v1 + ); + + ///////////////////////////////////////////////// + // ordering LIST cardinality properties with filtering + // ordering LIST cardinality String property + Supplier> tListStringFilter = () -> g.V().has("gender", "female").has("name2").order().by("name2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND name2 <> null)", + "_query=[(gender = female AND name2 <> null)][DESC(name2)]:listPropertyOrdering" + ), + tListStringFilter, v4, v6, v2 + ); + + // ordering LIST cardinality Double property + Supplier> tListDoubleFilter = () -> g.V().has("gender", "female").has("age2").order().by("age2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND age2 <> null)", + "_query=[(gender = female AND age2 <> null)][DESC(age2)]:listPropertyOrdering" + ), + tListDoubleFilter, v6, v4, v2 + ); + + // ordering LIST cardinality Date property + Supplier> tListDateFilter = () -> g.V().has("gender", "female").has("birth2").order().by("birth2", ORDER_DESC); + assertTraversalAndIndexUsage( + Arrays.asList( + "_condition=(gender = female AND birth2 <> null)", + "_query=[(gender = female AND birth2 <> null)][DESC(birth2)]:listPropertyOrdering" + ), + tListDateFilter, v6, v4, v2 + ); + } + } } diff --git a/janusgraph-backend-testutils/src/main/java/org/janusgraph/testutil/JanusGraphAssert.java b/janusgraph-backend-testutils/src/main/java/org/janusgraph/testutil/JanusGraphAssert.java index 241e237475..c8c782b13e 100644 --- a/janusgraph-backend-testutils/src/main/java/org/janusgraph/testutil/JanusGraphAssert.java +++ b/janusgraph-backend-testutils/src/main/java/org/janusgraph/testutil/JanusGraphAssert.java @@ -37,6 +37,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.function.Supplier; import java.util.stream.IntStream; import java.util.stream.Stream; @@ -79,6 +80,30 @@ public static void assertNotEmpty(Object object) { assertFalse(isEmpty(object)); } + public static void assertTraversalAndIndexUsage(List containsText, + Supplier> traversal, + E... expectedElements) { + + // assert expected results + assertTraversal(traversal.get(), expectedElements); + + // assert index usage + String profileStr = traversal.get().profile().toList().toString(); + + // let's drop the postfix coming from dynamic field definition so comparison will not fail for Solr + // all dynamic field definitions are in janusgraph-solr/src/test/resources/solr/core-template/schema.xml + // multi-valued date and date postfix + profileStr = profileStr.replace("_dts", "").replace("_dt", ""); + // multi-valued string and string postfix + profileStr = profileStr.replace("_ss", "").replace("_s", ""); + // multi-valued double and double postfix + profileStr = profileStr.replace("_ds", "").replace("_d", ""); + + for (String text : containsText) { + assertTrue(profileStr.contains(text)); + } + } + public static void assertTraversal(GraphTraversal req, E... expectedElements) { for (final E expectedElement : expectedElements) { assertEquals(expectedElement, req.next()); diff --git a/janusgraph-core/src/main/java/org/janusgraph/diskstorage/indexing/IndexFeatures.java b/janusgraph-core/src/main/java/org/janusgraph/diskstorage/indexing/IndexFeatures.java index 61e86779b2..6651e24613 100644 --- a/janusgraph-core/src/main/java/org/janusgraph/diskstorage/indexing/IndexFeatures.java +++ b/janusgraph-core/src/main/java/org/janusgraph/diskstorage/indexing/IndexFeatures.java @@ -39,12 +39,13 @@ public class IndexFeatures { private final boolean supportsGeoContains; private final boolean supportsGeoExists; private final boolean supportsNotQueryNormalForm; + private final boolean supportsOrderingListProperty; private final Set supportedCardinalities; public IndexFeatures(boolean supportsDocumentTTL, Mapping defaultMap, Set supportedMap, String wildcardField, Set supportedCardinalities, boolean supportsNanoseconds, boolean supportCustomAnalyzer, boolean supportsGeoContains, boolean supportGeoExists, - boolean supportsNotQueryNormalForm) { + boolean supportsNotQueryNormalForm, boolean supportsOrderingListProperty) { Preconditions.checkArgument(defaultMap!=null && defaultMap!=Mapping.DEFAULT); Preconditions.checkArgument(supportedMap!=null && !supportedMap.isEmpty() @@ -59,6 +60,7 @@ public IndexFeatures(boolean supportsDocumentTTL, Mapping defaultMap, Set(supportedMappings)), wildcardField, Collections.unmodifiableSet(new HashSet<>(supportedCardinalities)), supportsNanoseconds, supportsCustomAnalyzer, - supportsGeoContains, supportsGeoExists, supportNotQueryNormalForm); + supportsGeoContains, supportsGeoExists, supportNotQueryNormalForm, supportsOrderingListProperty); } } } diff --git a/janusgraph-core/src/main/java/org/janusgraph/graphdb/database/IndexSerializer.java b/janusgraph-core/src/main/java/org/janusgraph/graphdb/database/IndexSerializer.java index 9d115b212d..6eb3e74ba6 100644 --- a/janusgraph-core/src/main/java/org/janusgraph/graphdb/database/IndexSerializer.java +++ b/janusgraph-core/src/main/java/org/janusgraph/graphdb/database/IndexSerializer.java @@ -181,6 +181,20 @@ public boolean supportsExistsQuery(final MixedIndexType index, final ParameterIn return true; } + public boolean allMixedIndexBackendSupportsOrderingListProperty() { + if (mixedIndexes.isEmpty()) { + return false; + } + for (Map.Entry entry : mixedIndexes.entrySet()) { + // if any of the mixed index backends does not support ordering list property, let's return false + if (!entry.getValue().getFeatures().supportsOrderingListProperty()) { + return false; + } + } + + return true; + } + public IndexFeatures features(final MixedIndexType index) { return getMixedIndex(index).getFeatures(); } diff --git a/janusgraph-core/src/main/java/org/janusgraph/graphdb/query/graph/GraphCentricQueryBuilder.java b/janusgraph-core/src/main/java/org/janusgraph/graphdb/query/graph/GraphCentricQueryBuilder.java index bfc51f394b..f5f4243e5f 100644 --- a/janusgraph-core/src/main/java/org/janusgraph/graphdb/query/graph/GraphCentricQueryBuilder.java +++ b/janusgraph-core/src/main/java/org/janusgraph/graphdb/query/graph/GraphCentricQueryBuilder.java @@ -15,7 +15,7 @@ package org.janusgraph.graphdb.query.graph; import com.google.common.base.Preconditions; -import org.janusgraph.core.Cardinality; +//import org.janusgraph.core.Cardinality; import org.janusgraph.core.JanusGraphEdge; import org.janusgraph.core.JanusGraphElement; import org.janusgraph.core.JanusGraphQuery; @@ -201,8 +201,8 @@ public GraphCentricQueryBuilder orderBy(String keyName, org.apache.tinkerpop.gr Preconditions.checkArgument(key!=null && order!=null,"Need to specify and key and an order"); Preconditions.checkArgument(Comparable.class.isAssignableFrom(key.dataType()), "Can only order on keys with comparable data type. [%s] has datatype [%s]", key.name(), key.dataType()); - Preconditions.checkArgument(key.cardinality()== Cardinality.SINGLE, - "Ordering is undefined on multi-valued key [%s]", key.name()); + //Preconditions.checkArgument(key.cardinality()== Cardinality.SINGLE, + // "Ordering is undefined on multi-valued key [%s]", key.name()); Preconditions.checkArgument(!orders.containsKey(key), "orders [%s] already contains key [%s]", orders, key); orders.add(key, Order.convert(order)); return this; diff --git a/janusgraph-core/src/main/java/org/janusgraph/graphdb/tinkerpop/optimize/step/HasStepFolder.java b/janusgraph-core/src/main/java/org/janusgraph/graphdb/tinkerpop/optimize/step/HasStepFolder.java index bcf6d78444..2761b2ba9b 100644 --- a/janusgraph-core/src/main/java/org/janusgraph/graphdb/tinkerpop/optimize/step/HasStepFolder.java +++ b/janusgraph-core/src/main/java/org/janusgraph/graphdb/tinkerpop/optimize/step/HasStepFolder.java @@ -40,6 +40,7 @@ import org.janusgraph.core.Cardinality; import org.janusgraph.core.JanusGraphTransaction; import org.janusgraph.core.PropertyKey; +import org.janusgraph.graphdb.database.StandardJanusGraph; import org.janusgraph.graphdb.query.JanusGraphPredicateUtils; import org.janusgraph.graphdb.query.QueryUtil; import org.janusgraph.graphdb.tinkerpop.optimize.JanusGraphTraversalUtil; @@ -117,11 +118,18 @@ static boolean validJanusGraphOrder(OrderGlobalStep orderGlobalStep, Traversal r // do not fold comparators that include nested traversals that are not simple ElementValues return false; } + + // check if all mixed index backends of the graph supports ordering for LIST cardinality properties + // if this is the case, validJanusGraphOrder() method can return true not only for SINGLE + // but also for LIST cardinality properties + StandardJanusGraph graph = JanusGraphTraversalUtil.getJanusGraph(rootTraversal.asAdmin()); + boolean allMixedIndexBackendSupportsOrderingListProperty = graph.getIndexSerializer().allMixedIndexBackendSupportsOrderingListProperty(); + final JanusGraphTransaction tx = JanusGraphTraversalUtil.getTx(rootTraversal.asAdmin()); final PropertyKey pKey = tx.getPropertyKey(key); if (pKey == null || !(Comparable.class.isAssignableFrom(pKey.dataType())) - || (isVertexOrder && pKey.cardinality() != Cardinality.SINGLE)) { + || (isVertexOrder && !allMixedIndexBackendSupportsOrderingListProperty && pKey.cardinality() != Cardinality.SINGLE)) { return false; } } diff --git a/janusgraph-es/src/main/java/org/janusgraph/diskstorage/es/compat/AbstractESCompat.java b/janusgraph-es/src/main/java/org/janusgraph/diskstorage/es/compat/AbstractESCompat.java index a7680e5a35..41339ed4b6 100644 --- a/janusgraph-es/src/main/java/org/janusgraph/diskstorage/es/compat/AbstractESCompat.java +++ b/janusgraph-es/src/main/java/org/janusgraph/diskstorage/es/compat/AbstractESCompat.java @@ -57,6 +57,7 @@ static IndexFeatures.Builder coreFeatures() { .supportsCustomAnalyzer() .supportsGeoExists() .supportNotQueryNormalForm() + .supportsOrderingListProperty() ; } diff --git a/janusgraph-es/src/test/java/org/janusgraph/diskstorage/es/ElasticsearchJanusGraphIndexTest.java b/janusgraph-es/src/test/java/org/janusgraph/diskstorage/es/ElasticsearchJanusGraphIndexTest.java index e2877e2a16..c846099f43 100644 --- a/janusgraph-es/src/test/java/org/janusgraph/diskstorage/es/ElasticsearchJanusGraphIndexTest.java +++ b/janusgraph-es/src/test/java/org/janusgraph/diskstorage/es/ElasticsearchJanusGraphIndexTest.java @@ -55,7 +55,7 @@ public abstract class ElasticsearchJanusGraphIndexTest extends JanusGraphIndexTe protected static JanusGraphElasticsearchContainer esr = new JanusGraphElasticsearchContainer(); public ElasticsearchJanusGraphIndexTest() { - super(true, true, true); + super(true, true, true, true); } @Override diff --git a/janusgraph-lucene/src/test/java/org/janusgraph/diskstorage/lucene/BerkeleyLuceneTest.java b/janusgraph-lucene/src/test/java/org/janusgraph/diskstorage/lucene/BerkeleyLuceneTest.java index b697ebb11a..24d1e1e056 100644 --- a/janusgraph-lucene/src/test/java/org/janusgraph/diskstorage/lucene/BerkeleyLuceneTest.java +++ b/janusgraph-lucene/src/test/java/org/janusgraph/diskstorage/lucene/BerkeleyLuceneTest.java @@ -37,7 +37,7 @@ public class BerkeleyLuceneTest extends JanusGraphIndexTest { public BerkeleyLuceneTest() { - super(true, true, true); + super(true, true, true, false); } @Override diff --git a/janusgraph-solr/src/main/java/org/janusgraph/diskstorage/solr/SolrIndex.java b/janusgraph-solr/src/main/java/org/janusgraph/diskstorage/solr/SolrIndex.java index 00c60e2fd6..011318257f 100644 --- a/janusgraph-solr/src/main/java/org/janusgraph/diskstorage/solr/SolrIndex.java +++ b/janusgraph-solr/src/main/java/org/janusgraph/diskstorage/solr/SolrIndex.java @@ -243,6 +243,7 @@ public static Mode parse(String mode) { .supportsCardinality(Cardinality.SET) .supportsCustomAnalyzer() .supportsGeoContains() + .supportsOrderingListProperty() .build(); private static final Map SPATIAL_PREDICATES = spatialPredicates(); diff --git a/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/JanusGraphSolrContainer.java b/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/JanusGraphSolrContainer.java index d16c3e2b3f..6df2baf0f0 100644 --- a/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/JanusGraphSolrContainer.java +++ b/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/JanusGraphSolrContainer.java @@ -30,7 +30,7 @@ public class JanusGraphSolrContainer extends SolrContainer { private static final String DEFAULT_SOLR_VERSION = "8.11.1"; private static final String DEFAULT_SOLR_IMAGE = "solr"; - private static final String COLLECTIONS = "store1 store2 vertex edge namev namee composite psearch esearch vsearch mi mixed index1 index2 index3 ecategory vcategory pcategory theIndex vertices edges booleanIndex dateIndex instantIndex uuidIndex randomMixedIndex collectionIndex nameidx oridx otheridx lengthidx"; + private static final String COLLECTIONS = "store1 store2 vertex edge namev namee composite psearch esearch vsearch mi mixed index1 index2 index3 ecategory vcategory pcategory theIndex vertices edges booleanIndex dateIndex instantIndex uuidIndex randomMixedIndex collectionIndex nameidx oridx otheridx lengthidx listPropertyOrdering"; private static String getVersion() { String property = System.getProperty("solr.docker.version"); diff --git a/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/SolrJanusGraphIndexTest.java b/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/SolrJanusGraphIndexTest.java index 694fbd119b..074ad445d0 100644 --- a/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/SolrJanusGraphIndexTest.java +++ b/janusgraph-solr/src/test/java/org/janusgraph/diskstorage/solr/SolrJanusGraphIndexTest.java @@ -31,7 +31,7 @@ public abstract class SolrJanusGraphIndexTest extends JanusGraphIndexTest { protected static JanusGraphSolrContainer solrContainer = new JanusGraphSolrContainer(); protected SolrJanusGraphIndexTest() { - super(true, true, true); + super(true, true, true, true); } @Override