diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml index fdc04f739..1033df33e 100644 --- a/.github/workflows/maven.yml +++ b/.github/workflows/maven.yml @@ -20,12 +20,10 @@ jobs: fail-fast: false matrix: docker-img: - - docker.io/arangodb/arangodb:3.8.8 - - docker.io/arangodb/arangodb:3.9.5 - - docker.io/arangodb/arangodb:3.10.1 - - docker.io/arangodb/enterprise:3.8.8 - - docker.io/arangodb/enterprise:3.9.5 - - docker.io/arangodb/enterprise:3.10.1 + - docker.io/arangodb/arangodb:3.9.10 + - docker.io/arangodb/arangodb:3.10.5 + - docker.io/arangodb/enterprise:3.9.10 + - docker.io/arangodb/enterprise:3.10.5 topology: - single - cluster @@ -37,12 +35,12 @@ jobs: user-language: - en include: - - docker-img: docker.io/arangodb/arangodb:3.10.1 + - docker-img: docker.io/arangodb/arangodb:3.10.5 topology: single db-ext-names: true java-version: 11 user-language: tr - - docker-img: docker.io/arangodb/enterprise:3.10.1 + - docker-img: docker.io/arangodb/enterprise:3.10.5 topology: cluster db-ext-names: true java-version: 17 @@ -92,7 +90,7 @@ jobs: fail-fast: false matrix: docker-img: - - docker.io/arangodb/enterprise:3.10.1 + - docker.io/arangodb/enterprise:3.10.5 topology: - single - cluster @@ -139,7 +137,7 @@ jobs: fail-fast: false matrix: docker-img: - - docker.io/arangodb/enterprise:3.10.1 + - docker.io/arangodb/enterprise:3.10.5 topology: - cluster db-ext-names: diff --git a/.github/workflows/native.yml b/.github/workflows/native.yml index e6e0fb324..129f028bb 100644 --- a/.github/workflows/native.yml +++ b/.github/workflows/native.yml @@ -14,7 +14,7 @@ jobs: fail-fast: false matrix: docker-img: - - docker.io/arangodb/enterprise:3.10.1 + - docker.io/arangodb/enterprise:3.10.5 topology: - cluster db-ext-names: diff --git a/src/main/java/com/arangodb/entity/InvertedIndexEntity.java b/src/main/java/com/arangodb/entity/InvertedIndexEntity.java index c1b24dcc5..a0ef88451 100644 --- a/src/main/java/com/arangodb/entity/InvertedIndexEntity.java +++ b/src/main/java/com/arangodb/entity/InvertedIndexEntity.java @@ -57,6 +57,8 @@ public class InvertedIndexEntity implements Entity { private Long writebufferIdle; private Long writebufferActive; private Long writebufferSizeMax; + private Boolean cache; + private Boolean primaryKeyCache; public String getId() { return id; @@ -149,4 +151,12 @@ public Long getWritebufferActive() { public Long getWritebufferSizeMax() { return writebufferSizeMax; } + + public Boolean getCache() { + return cache; + } + + public Boolean getPrimaryKeyCache() { + return primaryKeyCache; + } } diff --git a/src/main/java/com/arangodb/entity/InvertedIndexField.java b/src/main/java/com/arangodb/entity/InvertedIndexField.java index 9677e016d..255062ea8 100644 --- a/src/main/java/com/arangodb/entity/InvertedIndexField.java +++ b/src/main/java/com/arangodb/entity/InvertedIndexField.java @@ -15,6 +15,7 @@ public class InvertedIndexField implements Entity { private Boolean includeAllFields; private Boolean searchField; private Boolean trackListPositions; + private Boolean cache; private final Set features = new HashSet<>(); private Collection nested; @@ -103,6 +104,23 @@ public InvertedIndexField trackListPositions(Boolean trackListPositions) { return this; } + public Boolean getCache() { + return cache; + } + + /** + * @param cache Enable this option to always cache the field normalization values in memory for this specific field. + * This can improve the performance of scoring and ranking queries. Otherwise, these values are + * memory-mapped and it is up to the operating system to load them from disk into memory and to evict + * them from memory. (Enterprise Edition only) + * @return this + * @since ArangoDB 3.10.2 + */ + public InvertedIndexField cache(Boolean cache) { + this.cache = cache; + return this; + } + public Set getFeatures() { return features; } @@ -139,11 +157,11 @@ public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; InvertedIndexField that = (InvertedIndexField) o; - return Objects.equals(name, that.name) && Objects.equals(analyzer, that.analyzer) && Objects.equals(includeAllFields, that.includeAllFields) && Objects.equals(searchField, that.searchField) && Objects.equals(trackListPositions, that.trackListPositions) && Objects.equals(features, that.features) && Objects.equals(nested, that.nested); + return Objects.equals(name, that.name) && Objects.equals(analyzer, that.analyzer) && Objects.equals(includeAllFields, that.includeAllFields) && Objects.equals(searchField, that.searchField) && Objects.equals(trackListPositions, that.trackListPositions) && Objects.equals(cache, that.cache) && Objects.equals(features, that.features) && Objects.equals(nested, that.nested); } @Override public int hashCode() { - return Objects.hash(name, analyzer, includeAllFields, searchField, trackListPositions, features, nested); + return Objects.hash(name, analyzer, includeAllFields, searchField, trackListPositions, cache, features, nested); } } diff --git a/src/main/java/com/arangodb/entity/InvertedIndexPrimarySort.java b/src/main/java/com/arangodb/entity/InvertedIndexPrimarySort.java index 1aaa2b169..076c84cb5 100644 --- a/src/main/java/com/arangodb/entity/InvertedIndexPrimarySort.java +++ b/src/main/java/com/arangodb/entity/InvertedIndexPrimarySort.java @@ -15,6 +15,7 @@ public class InvertedIndexPrimarySort implements Entity { private final List fields = new ArrayList<>(); private ArangoSearchCompression compression; + private Boolean cache; public List getFields() { return fields; @@ -42,17 +43,34 @@ public InvertedIndexPrimarySort compression(ArangoSearchCompression compression) return this; } + public Boolean getCache() { + return cache; + } + + /** + * @param cache If you enable this option, then the primary sort columns are always cached in memory. This can + * improve the performance of queries that utilize the primary sort order. Otherwise, these values are + * memory-mapped and it is up to the operating system to load them from disk into memory and to evict + * them from memory (Enterprise Edition only). + * @return this + * @since ArangoDB 3.10.2 + */ + public InvertedIndexPrimarySort cache(Boolean cache) { + this.cache = cache; + return this; + } + @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; InvertedIndexPrimarySort that = (InvertedIndexPrimarySort) o; - return Objects.equals(fields, that.fields) && compression == that.compression; + return Objects.equals(fields, that.fields) && compression == that.compression && Objects.equals(cache, that.cache); } @Override public int hashCode() { - return Objects.hash(fields, compression); + return Objects.hash(fields, compression, cache); } public static class Field { diff --git a/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchProperties.java b/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchProperties.java index 7353cba66..8bf5d0172 100644 --- a/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchProperties.java +++ b/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchProperties.java @@ -20,6 +20,8 @@ package com.arangodb.entity.arangosearch; +import com.arangodb.model.arangosearch.ArangoSearchCreateOptions; + import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -40,6 +42,8 @@ public class ArangoSearchProperties { private final Collection links; private ArangoSearchCompression primarySortCompression; private final Collection storedValues; + private Boolean primarySortCache; + private Boolean primaryKeyCache; public ArangoSearchProperties() { super(); @@ -123,4 +127,35 @@ public void addStoredValues(final StoredValue... storedValues) { this.storedValues.addAll(Arrays.asList(storedValues)); } + public Boolean getPrimarySortCache() { + return primarySortCache; + } + + + /** + * @param primarySortCache If you enable this option, then the primary sort columns are always cached in memory. + * This can improve the performance of queries that utilize the primary sort order. + * Otherwise, these values are memory-mapped and it is up to the operating system to load + * them from disk into memory and to evict them from memory. + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public void setPrimarySortCache(final Boolean primarySortCache) { + this.primarySortCache = primarySortCache; + } + + public Boolean getPrimaryKeyCache() { + return primaryKeyCache; + } + + /** + * @param primaryKeyCache If you enable this option, then the primary key columns are always cached in memory. This + * can improve the performance of queries that return many documents. Otherwise, these values + * are memory-mapped and it is up to the operating system to load them from disk into memory + * and to evict them from memory. + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public void setPrimaryKeyCache(final Boolean primaryKeyCache) { + this.primaryKeyCache = primaryKeyCache; + } + } diff --git a/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchPropertiesEntity.java b/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchPropertiesEntity.java index 55c6d9afe..f6cda4c85 100644 --- a/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchPropertiesEntity.java +++ b/src/main/java/com/arangodb/entity/arangosearch/ArangoSearchPropertiesEntity.java @@ -116,4 +116,23 @@ public Collection getStoredValues() { return properties.getStoredValues(); } + /** + * @return If you enable this option, then the primary sort columns are always cached in memory. This can improve + * the performance of queries that utilize the primary sort order. Otherwise, these values are memory-mapped and it + * is up to the operating system to load them from disk into memory and to evict them from memory. + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public Boolean getPrimarySortCache() { + return properties.getPrimarySortCache(); + } + + /** + * @return If you enable this option, then the primary key columns are always cached in memory. This can improve the + * performance of queries that return many documents. Otherwise, these values are memory-mapped and it is up to the + * operating system to load them from disk into memory and to evict them from memory. + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public Boolean getPrimaryKeyCache() { + return properties.getPrimaryKeyCache(); + } } diff --git a/src/main/java/com/arangodb/entity/arangosearch/FieldLink.java b/src/main/java/com/arangodb/entity/arangosearch/FieldLink.java index 9da26f02f..4d2e5d110 100644 --- a/src/main/java/com/arangodb/entity/arangosearch/FieldLink.java +++ b/src/main/java/com/arangodb/entity/arangosearch/FieldLink.java @@ -14,6 +14,7 @@ public class FieldLink { private final Collection fields; private final Collection nested; private Boolean inBackground; + private Boolean cache; private FieldLink(final String name) { super(); @@ -102,6 +103,19 @@ public FieldLink inBackground(final Boolean inBackground) { return this; } + /** + * @param cache If you enable this option, then field normalization values are always cached in memory. This can + * improve the performance of scoring and ranking queries. Otherwise, these values are memory-mapped + * and it is up to the operating system to load them from disk into memory and to evict them from + * memory. + * @return link + * @since ArangoDB 3.9.5, Enterprise Edition only + */ + public FieldLink cache(final Boolean cache) { + this.cache = cache; + return this; + } + public String getName() { return name; } @@ -133,4 +147,8 @@ public Collection getNested() { public Boolean getInBackground() { return inBackground; } + + public Boolean getCache() { + return cache; + } } \ No newline at end of file diff --git a/src/main/java/com/arangodb/internal/velocypack/VPackDeserializers.java b/src/main/java/com/arangodb/internal/velocypack/VPackDeserializers.java index 39e1e08c1..50c7c07c3 100644 --- a/src/main/java/com/arangodb/internal/velocypack/VPackDeserializers.java +++ b/src/main/java/com/arangodb/internal/velocypack/VPackDeserializers.java @@ -189,6 +189,16 @@ public class VPackDeserializers { context.deserialize(consolidationPolicy, ConsolidationPolicy.class)); } + final VPackSlice primarySortCache = vpack.get("primarySortCache"); + if (primarySortCache.isBoolean()) { + properties.setPrimarySortCache(primarySortCache.getAsBoolean()); + } + + final VPackSlice primaryKeyCache = vpack.get("primaryKeyCache"); + if (primaryKeyCache.isBoolean()) { + properties.setPrimaryKeyCache(primaryKeyCache.getAsBoolean()); + } + final VPackSlice links = vpack.get("links"); if (links.isObject()) { final Iterator> collectionIterator = links.objectIterator(); @@ -303,6 +313,10 @@ protected static FieldLink deserializeField(final Entry fiel link.nested(deserializeField(fieldsIterator.next())); } } + final VPackSlice cache = value.get("cache"); + if (cache.isBoolean()) { + link.cache(cache.getAsBoolean()); + } return link; } diff --git a/src/main/java/com/arangodb/internal/velocypack/VPackSerializers.java b/src/main/java/com/arangodb/internal/velocypack/VPackSerializers.java index c9ce989d4..ec55012d9 100644 --- a/src/main/java/com/arangodb/internal/velocypack/VPackSerializers.java +++ b/src/main/java/com/arangodb/internal/velocypack/VPackSerializers.java @@ -163,6 +163,16 @@ public class VPackSerializers { } context.serialize(builder, "consolidationPolicy", value.getConsolidationPolicy()); + final Boolean primarySortCache = value.getPrimarySortCache(); + if (primarySortCache != null) { + builder.add("primarySortCache", primarySortCache); + } + + final Boolean primaryKeyCache = value.getPrimaryKeyCache(); + if (primaryKeyCache != null) { + builder.add("primaryKeyCache", primaryKeyCache); + } + final Collection links = value.getLinks(); if (!links.isEmpty()) { builder.add("links", ValueType.OBJECT); @@ -314,6 +324,10 @@ private static void serializeFields(final VPackBuilder builder, final Collection if (inBackground != null) { builder.add("inBackground", inBackground); } + Boolean cache = fieldLink.getCache(); + if (cache != null) { + builder.add("cache", cache); + } serializeFieldLinks(builder, fieldLink.getFields()); serializeNested(builder, fieldLink.getNested()); builder.close(); diff --git a/src/main/java/com/arangodb/model/InvertedIndexOptions.java b/src/main/java/com/arangodb/model/InvertedIndexOptions.java index 89e24b244..d444d227c 100644 --- a/src/main/java/com/arangodb/model/InvertedIndexOptions.java +++ b/src/main/java/com/arangodb/model/InvertedIndexOptions.java @@ -51,6 +51,8 @@ public class InvertedIndexOptions extends IndexOptions { private Long writebufferIdle; private Long writebufferActive; private Long writebufferSizeMax; + private Boolean cache; + private Boolean primaryKeyCache; public InvertedIndexOptions() { super(); @@ -347,16 +349,52 @@ public InvertedIndexOptions writebufferSizeMax(Long writebufferSizeMax) { return this; } + public Boolean getCache() { + return cache; + } + + /** + * @param cache Enable this option to always cache the field normalization values in memory for all fields by + * default. This can improve the performance of scoring and ranking queries. Otherwise, these values + * are memory-mapped and it is up to the operating system to load them from disk into memory and to + * evict them from memory. + *

+ * Default: `false`. (Enterprise Edition only) + * @return this + * @since ArangoDB 3.10.2 + */ + public InvertedIndexOptions cache(Boolean cache) { + this.cache = cache; + return this; + } + + public Boolean getPrimaryKeyCache() { + return primaryKeyCache; + } + + /** + * @param primaryKeyCache If you enable this option, then the primary key columns are always cached in memory. This + * can improve the performance of queries that return many documents. Otherwise, these values + * are memory-mapped and it is up to the operating system to load them from disk into memory + * and to evict them from memory (Enterprise Edition only). (default: false) + * @return this + * @since ArangoDB 3.10.2 + */ + public InvertedIndexOptions primaryKeyCache(Boolean primaryKeyCache) { + this.primaryKeyCache = primaryKeyCache; + return this; + } + @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; InvertedIndexOptions that = (InvertedIndexOptions) o; - return type == that.type && Objects.equals(parallelism, that.parallelism) && Objects.equals(primarySort, that.primarySort) && Objects.equals(storedValues, that.storedValues) && Objects.equals(analyzer, that.analyzer) && Objects.equals(features, that.features) && Objects.equals(includeAllFields, that.includeAllFields) && Objects.equals(trackListPositions, that.trackListPositions) && Objects.equals(searchField, that.searchField) && Objects.equals(fields, that.fields) && Objects.equals(consolidationIntervalMsec, that.consolidationIntervalMsec) && Objects.equals(commitIntervalMsec, that.commitIntervalMsec) && Objects.equals(cleanupIntervalStep, that.cleanupIntervalStep) && Objects.equals(consolidationPolicy, that.consolidationPolicy) && Objects.equals(writebufferIdle, that.writebufferIdle) && Objects.equals(writebufferActive, that.writebufferActive) && Objects.equals(writebufferSizeMax, that.writebufferSizeMax); + return type == that.type && Objects.equals(parallelism, that.parallelism) && Objects.equals(primarySort, that.primarySort) && Objects.equals(storedValues, that.storedValues) && Objects.equals(analyzer, that.analyzer) && Objects.equals(features, that.features) && Objects.equals(includeAllFields, that.includeAllFields) && Objects.equals(trackListPositions, that.trackListPositions) && Objects.equals(searchField, that.searchField) && Objects.equals(fields, that.fields) && Objects.equals(consolidationIntervalMsec, that.consolidationIntervalMsec) && Objects.equals(commitIntervalMsec, that.commitIntervalMsec) && Objects.equals(cleanupIntervalStep, that.cleanupIntervalStep) && Objects.equals(consolidationPolicy, that.consolidationPolicy) && Objects.equals(writebufferIdle, that.writebufferIdle) && Objects.equals(writebufferActive, that.writebufferActive) && Objects.equals(writebufferSizeMax, that.writebufferSizeMax) && Objects.equals(cache, that.cache) && Objects.equals(primaryKeyCache, that.primaryKeyCache); } @Override public int hashCode() { - return Objects.hash(type, parallelism, primarySort, storedValues, analyzer, features, includeAllFields, trackListPositions, searchField, fields, consolidationIntervalMsec, commitIntervalMsec, cleanupIntervalStep, consolidationPolicy, writebufferIdle, writebufferActive, writebufferSizeMax); + return Objects.hash(type, parallelism, primarySort, storedValues, analyzer, features, includeAllFields, trackListPositions, searchField, fields, consolidationIntervalMsec, commitIntervalMsec, cleanupIntervalStep, consolidationPolicy, writebufferIdle, writebufferActive, writebufferSizeMax, cache, primaryKeyCache); } } diff --git a/src/main/java/com/arangodb/model/arangosearch/ArangoSearchCreateOptions.java b/src/main/java/com/arangodb/model/arangosearch/ArangoSearchCreateOptions.java index 2fcfe376b..7f2b7b3c3 100644 --- a/src/main/java/com/arangodb/model/arangosearch/ArangoSearchCreateOptions.java +++ b/src/main/java/com/arangodb/model/arangosearch/ArangoSearchCreateOptions.java @@ -134,4 +134,31 @@ public ArangoSearchCreateOptions storedValues(final StoredValue... storedValues) return this; } + + /** + * @param primarySortCache If you enable this option, then the primary sort columns are always cached in memory. + * This can improve the performance of queries that utilize the primary sort order. + * Otherwise, these values are memory-mapped and it is up to the operating system to load + * them from disk into memory and to evict them from memory. + * @return options + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public ArangoSearchCreateOptions primarySortCache(final Boolean primarySortCache) { + properties.setPrimarySortCache(primarySortCache); + return this; + } + + /** + * @param primaryKeyCache If you enable this option, then the primary key columns are always cached in memory. This + * can improve the performance of queries that return many documents. Otherwise, these values + * are memory-mapped and it is up to the operating system to load them from disk into memory + * and to evict them from memory. + * @return options + * @since ArangoDB 3.9.6, Enterprise Edition only + */ + public ArangoSearchCreateOptions primaryKeyCache(final Boolean primaryKeyCache) { + properties.setPrimaryKeyCache(primaryKeyCache); + return this; + } + } diff --git a/src/test/java/com/arangodb/ArangoSearchTest.java b/src/test/java/com/arangodb/ArangoSearchTest.java index 559d5bd7b..52bb94005 100644 --- a/src/test/java/com/arangodb/ArangoSearchTest.java +++ b/src/test/java/com/arangodb/ArangoSearchTest.java @@ -908,7 +908,9 @@ void enhancedTextAnalyzerTyped(ArangoDatabase db) { void arangoSearchOptions(ArangoDatabase db) { assumeTrue(isAtLeastVersion(3, 4)); String viewName = "view-" + rnd(); - FieldLink field = FieldLink.on("f1").inBackground(true); + FieldLink field = FieldLink.on("f1") + .inBackground(true) + .cache(false); if (isEnterprise()) { field.nested(FieldLink.on("f2")); } @@ -923,7 +925,10 @@ void arangoSearchOptions(ArangoDatabase db) { if (isEnterprise()) { link.nested(FieldLink.on("f3")); } - ArangoSearchCreateOptions options = new ArangoSearchCreateOptions().link(link); + ArangoSearchCreateOptions options = new ArangoSearchCreateOptions() + .link(link) + .primarySortCache(true) + .primaryKeyCache(true); StoredValue storedValue = new StoredValue(Arrays.asList("a", "b"), ArangoSearchCompression.none, true); options.storedValues(storedValue); @@ -944,8 +949,12 @@ void arangoSearchOptions(ArangoDatabase db) { assertThat(createdLink.getStoreValues()).isEqualTo(StoreValuesType.ID); assertThat(createdLink.getTrackListPositions()).isFalse(); - if (isEnterprise() && isAtLeastVersion(3, 9, 5) && isLessThanVersion(3, 10)) { + FieldLink fieldLink = createdLink.getFields().iterator().next(); + if (isEnterprise()) { assertThat(createdLink.getCache()).isTrue(); + assertThat(fieldLink.getCache()).isFalse(); + assertThat(properties.getPrimaryKeyCache()).isTrue(); + assertThat(properties.getPrimarySortCache()).isTrue(); assertThat(properties.getStoredValues()) .isNotEmpty() .allSatisfy(it -> assertThat(it.getCache()).isTrue()); @@ -957,7 +966,6 @@ void arangoSearchOptions(ArangoDatabase db) { assertThat(nested.getName()).isEqualTo("f3"); } - FieldLink fieldLink = createdLink.getFields().iterator().next(); assertThat(fieldLink.getName()).isEqualTo("f1"); if (isEnterprise() && isAtLeastVersion(3, 10)) { assertThat(fieldLink.getNested()).isNotEmpty(); diff --git a/src/test/java/com/arangodb/InvertedIndexTest.java b/src/test/java/com/arangodb/InvertedIndexTest.java index e96bc70ef..30fb3cbed 100644 --- a/src/test/java/com/arangodb/InvertedIndexTest.java +++ b/src/test/java/com/arangodb/InvertedIndexTest.java @@ -47,12 +47,15 @@ private void createAnalyzer(String analyzerName, ArangoDatabase db) { } private InvertedIndexOptions createOptions(String analyzerName) { + Boolean cache = isEnterprise() ? true : null; + Boolean fieldCache = cache != null ? false : null; InvertedIndexField field = new InvertedIndexField() .name("foo") .analyzer(AnalyzerType.identity.toString()) .includeAllFields(true) .searchField(false) .trackListPositions(false) + .cache(fieldCache) .features( AnalyzerFeature.position, AnalyzerFeature.frequency, @@ -87,8 +90,9 @@ private InvertedIndexOptions createOptions(String analyzerName) { new InvertedIndexPrimarySort.Field("f2", InvertedIndexPrimarySort.Field.Direction.desc) ) .compression(ArangoSearchCompression.lz4) + .cache(cache) ) - .storedValues(new StoredValue(Arrays.asList("f3", "f4"), ArangoSearchCompression.none)) + .storedValues(new StoredValue(Arrays.asList("f3", "f4"), ArangoSearchCompression.none, cache)) .analyzer(analyzerName) .features(AnalyzerFeature.position, AnalyzerFeature.frequency) .includeAllFields(false) @@ -107,7 +111,9 @@ private InvertedIndexOptions createOptions(String analyzerName) { ) .writebufferIdle(44L) .writebufferActive(55L) - .writebufferSizeMax(66L); + .writebufferSizeMax(66L) + .cache(cache) + .primaryKeyCache(cache); } private void assertCorrectIndexEntity(InvertedIndexEntity indexResult, InvertedIndexOptions options) { @@ -136,6 +142,8 @@ private void assertCorrectIndexEntity(InvertedIndexEntity indexResult, InvertedI assertThat(indexResult.getWritebufferIdle()).isEqualTo(options.getWritebufferIdle()); assertThat(indexResult.getWritebufferActive()).isEqualTo(options.getWritebufferActive()); assertThat(indexResult.getWritebufferSizeMax()).isEqualTo(options.getWritebufferSizeMax()); + assertThat(indexResult.getCache()).isEqualTo(options.getCache()); + assertThat(indexResult.getPrimaryKeyCache()).isEqualTo(options.getPrimaryKeyCache()); } @ParameterizedTest(name = "{index}")