diff options
Diffstat (limited to 'config-model/src/test/java/com/yahoo/schema/AttributeSettingsTestCase.java')
-rw-r--r-- | config-model/src/test/java/com/yahoo/schema/AttributeSettingsTestCase.java | 344 |
1 files changed, 344 insertions, 0 deletions
diff --git a/config-model/src/test/java/com/yahoo/schema/AttributeSettingsTestCase.java b/config-model/src/test/java/com/yahoo/schema/AttributeSettingsTestCase.java new file mode 100644 index 00000000000..bbe63f95787 --- /dev/null +++ b/config-model/src/test/java/com/yahoo/schema/AttributeSettingsTestCase.java @@ -0,0 +1,344 @@ +// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.schema; + +import com.yahoo.document.StructDataType; +import com.yahoo.schema.derived.AttributeFields; +import com.yahoo.schema.derived.IndexingScript; +import com.yahoo.schema.document.Attribute; +import com.yahoo.schema.document.SDField; +import com.yahoo.schema.parser.ParseException; +import com.yahoo.tensor.TensorType; +import com.yahoo.vespa.config.search.AttributesConfig; +import com.yahoo.vespa.configdefinition.IlscriptsConfig; +import org.junit.Test; + +import java.io.IOException; +import java.util.Optional; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +/** + * Attribute settings + * + * @author bratseth + */ +public class AttributeSettingsTestCase extends AbstractSchemaTestCase { + + @Test + public void testAttributeSettings() throws IOException, ParseException { + Schema schema = ApplicationBuilder.buildFromFile("src/test/examples/attributesettings.sd"); + + SDField f1=(SDField) schema.getDocument().getField("f1"); + assertEquals(1, f1.getAttributes().size()); + Attribute a1 = f1.getAttributes().get(f1.getName()); + assertEquals(Attribute.Type.LONG, a1.getType()); + assertEquals(Attribute.CollectionType.SINGLE, a1.getCollectionType()); + assertTrue(a1.isHuge()); + assertFalse(a1.isFastSearch()); + assertFalse(a1.isFastAccess()); + assertFalse(a1.isRemoveIfZero()); + assertFalse(a1.isCreateIfNonExistent()); + + SDField f2=(SDField) schema.getDocument().getField("f2"); + assertEquals(1, f2.getAttributes().size()); + Attribute a2 = f2.getAttributes().get(f2.getName()); + assertEquals(Attribute.Type.LONG, a2.getType()); + assertEquals(Attribute.CollectionType.SINGLE, a2.getCollectionType()); + assertFalse(a2.isHuge()); + assertTrue(a2.isFastSearch()); + assertFalse(a2.isFastAccess()); + assertFalse(a2.isRemoveIfZero()); + assertFalse(a2.isCreateIfNonExistent()); + assertEquals("f2", f2.getAliasToName().get("f2alias")); + SDField f3=(SDField) schema.getDocument().getField("f3"); + assertEquals(1, f3.getAttributes().size()); + assertEquals("f3", f3.getAliasToName().get("f3alias")); + + Attribute a3 = f3.getAttributes().get(f3.getName()); + assertEquals(Attribute.Type.LONG, a3.getType()); + assertEquals(Attribute.CollectionType.SINGLE, a3.getCollectionType()); + assertFalse(a3.isHuge()); + assertFalse(a3.isFastSearch()); + assertFalse(a3.isFastAccess()); + assertFalse(a3.isRemoveIfZero()); + assertFalse(a3.isCreateIfNonExistent()); + + assertWeightedSet(schema, "f4", true, true); + assertWeightedSet(schema, "f5", true, true); + assertWeightedSet(schema, "f6", true, true); + assertWeightedSet(schema, "f7", true, false); + assertWeightedSet(schema, "f8", true, false); + assertWeightedSet(schema, "f9", false, true); + assertWeightedSet(schema, "f10", false, true); + + assertAttrSettings(schema, "f4", false, false, false); + assertAttrSettings(schema, "f5", true, true, true); + assertAttrSettings(schema, "f6", false, false, false); + assertAttrSettings(schema, "f7", false, false, false); + assertAttrSettings(schema, "f8", false, false, false); + assertAttrSettings(schema, "f9", false, false, false); + assertAttrSettings(schema, "f10", false, false, false); + } + + private void assertWeightedSet(Schema schema, String name, boolean createIfNonExistent, boolean removeIfZero) { + SDField f4 = (SDField) schema.getDocument().getField(name); + assertEquals(1, f4.getAttributes().size()); + Attribute a4 = f4.getAttributes().get(f4.getName()); + assertEquals(Attribute.Type.STRING, a4.getType()); + assertEquals(Attribute.CollectionType.WEIGHTEDSET, a4.getCollectionType()); + assertEquals(a4.isRemoveIfZero(), removeIfZero); + assertEquals(a4.isCreateIfNonExistent(), createIfNonExistent); + } + + private void assertAttrSettings(Schema schema, String name, boolean fastAccess, boolean fastSearch, boolean paged) { + SDField f4 = (SDField) schema.getDocument().getField(name); + assertEquals(1, f4.getAttributes().size()); + Attribute a4 = f4.getAttributes().get(f4.getName()); + assertEquals(Attribute.Type.STRING, a4.getType()); + assertEquals(Attribute.CollectionType.WEIGHTEDSET, a4.getCollectionType()); + assertEquals(a4.isFastSearch(), fastSearch); + assertEquals(a4.isFastAccess(), fastAccess); + assertEquals(a4.isPaged(), paged); + } + + @Test + public void requireThatFastAccessCanBeSet() throws IOException, ParseException { + Schema schema = ApplicationBuilder.buildFromFile("src/test/examples/attributesettings.sd"); + SDField field = (SDField) schema.getDocument().getField("fast_access"); + assertEquals(1, field.getAttributes().size()); + Attribute attr = field.getAttributes().get(field.getName()); + assertTrue(attr.isFastAccess()); + } + + private Schema getSchema(String sd) throws ParseException { + ApplicationBuilder builder = new ApplicationBuilder(); + builder.addSchema(sd); + builder.build(true); + return builder.getSchema(); + } + + private Attribute getAttributeF(String sd) throws ParseException { + Schema schema = getSchema(sd); + SDField field = (SDField) schema.getDocument().getField("f"); + return field.getAttributes().get(field.getName()); + } + + @Test + public void requireThatPagedIsDefaultOff() throws ParseException { + Attribute attr = getAttributeF( + "search test {\n" + + " document test { \n" + + " field f type tensor(x[2]) { \n" + + " indexing: attribute \n" + + " }\n" + + " }\n" + + "}\n"); + assertFalse(attr.isPaged()); + } + @Test + public void requireThatPagedCanBeSet() throws ParseException { + Attribute attr = getAttributeF( + "search test {\n" + + " document test { \n" + + " field f type tensor(x[2]) { \n" + + " indexing: attribute \n" + + " attribute: paged \n" + + " }\n" + + " }\n" + + "}\n"); + assertTrue(attr.isPaged()); + } + + @Test + public void requireThatMutableIsDefaultOff() throws ParseException { + Attribute attr = getAttributeF( + "search test {\n" + + " document test { \n" + + " field f type int { \n" + + " indexing: attribute \n" + + " }\n" + + " }\n" + + "}\n"); + assertFalse(attr.isMutable()); + } + + @Test + public void requireThatMutableCanNotbeSetInDocument() throws ParseException { + try { + getSchema("search test {\n" + + " document test {\n" + + " field f type int {\n" + + " indexing: attribute\n" + + " attribute: mutable\n" + + " }\n" + + " }\n" + + "}\n"); + fail(); + } catch (IllegalArgumentException e) { + assertEquals("Field 'f' in 'test' can not be marked mutable as it is inside the document clause.", e.getMessage()); + } + } + + @Test + public void requireThatMutableExtraFieldCanBeSet() throws ParseException { + Attribute attr = getAttributeF( + "search test {\n" + + " document test { \n" + + " field a type int { \n" + + " indexing: attribute \n" + + " }\n" + + " }\n" + + " field f type long {\n" + + " indexing: 0 | to_long | attribute\n" + + " attribute: mutable\n" + + " }\n" + + "}\n"); + assertTrue(attr.isMutable()); + } + + private Schema getSearchWithMutables() throws ParseException { + return getSchema( + "search test {\n" + + " document test { \n" + + " field a type int { \n" + + " indexing: attribute \n" + + " }\n" + + " }\n" + + " field m type long {\n" + + " indexing: attribute\n" + + " attribute: mutable\n" + + " }\n" + + " field f type long {\n" + + " indexing: 0 | to_long | attribute\n" + + " }\n" + + "}\n"); + } + + @Test + public void requireThatMutableConfigIsProperlyPropagated() throws ParseException { + AttributeFields attributes = new AttributeFields(getSearchWithMutables()); + AttributesConfig.Builder builder = new AttributesConfig.Builder(); + attributes.getConfig(builder, AttributeFields.FieldSet.ALL, 13333, true); + AttributesConfig cfg = builder.build(); + assertEquals("a", cfg.attribute().get(0).name()); + assertFalse(cfg.attribute().get(0).ismutable()); + + assertEquals("f", cfg.attribute().get(1).name()); + assertFalse(cfg.attribute().get(1).ismutable()); + + assertEquals("m", cfg.attribute().get(2).name()); + assertTrue(cfg.attribute().get(2).ismutable()); + } + + @Test + public void requireMaxUnCommittedMemoryIsProperlyPropagated() throws ParseException { + AttributeFields attributes = new AttributeFields(getSearchWithMutables()); + AttributesConfig.Builder builder = new AttributesConfig.Builder(); + attributes.getConfig(builder, AttributeFields.FieldSet.ALL, 13333, true); + AttributesConfig cfg = builder.build(); + assertEquals("a", cfg.attribute().get(0).name()); + assertEquals(13333, cfg.attribute().get(0).maxuncommittedmemory()); + + assertEquals("f", cfg.attribute().get(1).name()); + assertEquals(13333, cfg.attribute().get(1).maxuncommittedmemory()); + + assertEquals("m", cfg.attribute().get(2).name()); + assertEquals(13333, cfg.attribute().get(2).maxuncommittedmemory()); + } + + private void verifyEnableBitVectorDefault(Schema schema, boolean enableBitVectors) { + AttributeFields attributes = new AttributeFields(schema); + AttributesConfig.Builder builder = new AttributesConfig.Builder(); + attributes.getConfig(builder, AttributeFields.FieldSet.ALL, 13333, enableBitVectors); + AttributesConfig cfg = builder.build(); + assertEquals("a", cfg.attribute().get(0).name()); + assertEquals(enableBitVectors, cfg.attribute().get(0).enablebitvectors()); + + assertEquals("b", cfg.attribute().get(1).name()); + assertFalse(cfg.attribute().get(1).enablebitvectors()); + } + + @Test + public void requireEnableBitVectorsIsProperlyPropagated() throws ParseException { + Schema schema = getSchema( + "search test {\n" + + " document test { \n" + + " field a type int { \n" + + " indexing: attribute \n" + + " attribute: fast-search\n" + + " }\n" + + " field b type int { \n" + + " indexing: attribute \n" + + " }\n" + + " }\n" + + "}\n"); + verifyEnableBitVectorDefault(schema, false); + verifyEnableBitVectorDefault(schema, true); + } + + @Test + public void requireThatMutableIsAllowedThroughIndexing() throws ParseException { + IndexingScript script = new IndexingScript(getSearchWithMutables()); + IlscriptsConfig.Builder builder = new IlscriptsConfig.Builder(); + script.getConfig(builder); + IlscriptsConfig cfg = builder.build(); + assertEquals(1, cfg.ilscript().size()); + IlscriptsConfig.Ilscript ils = cfg.ilscript(0); + assertEquals("test", ils.doctype()); + assertEquals(2, ils.docfield().size()); + assertEquals("a", ils.docfield(0)); + assertEquals("m", ils.docfield(1)); + + } + + @Test + public void attribute_convert_to_array_copies_internal_state() { + StructDataType refType = new StructDataType("my_struct"); + Attribute single = new Attribute("foo", Attribute.Type.STRING, Attribute.CollectionType.SINGLE, + Optional.of(TensorType.fromSpec("tensor(x{})")), Optional.of(refType)); + single.setRemoveIfZero(true); + single.setCreateIfNonExistent(true); + single.setPrefetch(Boolean.TRUE); + single.setEnableBitVectors(true); + single.setEnableOnlyBitVector(true); + single.setFastSearch(true); + single.setHuge(true); + single.setPaged(true); + single.setFastAccess(true); + single.setPosition(true); + single.setArity(5); + single.setLowerBound(7); + single.setUpperBound(11); + single.setDensePostingListThreshold(13.3); + single.getSorting().setAscending(); + single.getAliases().add("foo"); + + Attribute array = single.convertToArray(); + assertEquals("foo", array.getName()); + assertEquals(Attribute.Type.STRING, array.getType()); + assertEquals(Attribute.CollectionType.ARRAY, array.getCollectionType()); + assertEquals(Optional.of(TensorType.fromSpec("tensor(x{})")), array.tensorType()); + assertSame(single.referenceDocumentType(), array.referenceDocumentType()); + assertTrue(array.isRemoveIfZero()); + assertTrue(array.isCreateIfNonExistent()); + assertTrue(array.isPrefetch()); + assertTrue(array.isEnabledBitVectors()); + assertTrue(array.isEnabledOnlyBitVector()); + assertTrue(array.isFastSearch()); + assertTrue(array.isHuge()); + assertTrue(array.isPaged()); + assertTrue(array.isFastAccess()); + assertTrue(array.isPosition()); + assertEquals(5, array.arity()); + assertEquals(7, array.lowerBound()); + assertEquals(11, array.upperBound()); + assertEquals(13.3, array.densePostingListThreshold(), 0.00001); + assertSame(single.getSorting(), array.getSorting()); + assertSame(single.getAliases(), array.getAliases()); + } + +} |