io.evitadb.api.requestResponse.schema.builder.ReferenceSchemaBuilder Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of evita_api Show documentation
Show all versions of evita_api Show documentation
Module contains external API of the evitaDB.
The newest version!
/*
*
* _ _ ____ ____
* _____ _(_) |_ __ _| _ \| __ )
* / _ \ \ / / | __/ _` | | | | _ \
* | __/\ V /| | || (_| | |_| | |_) |
* \___| \_/ |_|\__\__,_|____/|____/
*
* Copyright (c) 2023-2024
*
* Licensed under the Business Source License, Version 1.1 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://github.com/FgForrest/evitaDB/blob/master/LICENSE
*
* 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 io.evitadb.api.requestResponse.schema.builder;
import io.evitadb.api.exception.AttributeAlreadyPresentInEntitySchemaException;
import io.evitadb.api.exception.InvalidSchemaMutationException;
import io.evitadb.api.exception.SortableAttributeCompoundSchemaException;
import io.evitadb.api.requestResponse.schema.AttributeSchemaContract;
import io.evitadb.api.requestResponse.schema.AttributeSchemaEditor;
import io.evitadb.api.requestResponse.schema.Cardinality;
import io.evitadb.api.requestResponse.schema.CatalogSchemaContract;
import io.evitadb.api.requestResponse.schema.EntitySchemaContract;
import io.evitadb.api.requestResponse.schema.ReferenceSchemaContract;
import io.evitadb.api.requestResponse.schema.ReferenceSchemaEditor;
import io.evitadb.api.requestResponse.schema.SortableAttributeCompoundSchemaContract;
import io.evitadb.api.requestResponse.schema.SortableAttributeCompoundSchemaContract.AttributeElement;
import io.evitadb.api.requestResponse.schema.dto.ReferenceSchema;
import io.evitadb.api.requestResponse.schema.mutation.LocalEntitySchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.ReferenceSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.ReferenceSchemaMutator;
import io.evitadb.api.requestResponse.schema.mutation.attribute.RemoveAttributeSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.*;
import io.evitadb.api.requestResponse.schema.mutation.sortableAttributeCompound.RemoveSortableAttributeCompoundSchemaMutation;
import io.evitadb.exception.GenericEvitaInternalError;
import io.evitadb.utils.Assert;
import lombok.experimental.Delegate;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.Serial;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import static io.evitadb.utils.Assert.isTrue;
import static java.util.Optional.ofNullable;
/**
* Internal {@link ReferenceSchema} builder used solely from within {@link InternalEntitySchemaBuilder}.
*
* @author Jan Novotný ([email protected]), FG Forrest a.s. (c) 2021
*/
public final class ReferenceSchemaBuilder
implements ReferenceSchemaEditor.ReferenceSchemaBuilder, InternalSchemaBuilderHelper {
@Serial private static final long serialVersionUID = -6435272035844056999L;
private final CatalogSchemaContract catalogSchema;
private final EntitySchemaContract entitySchema;
private final ReferenceSchemaContract baseSchema;
private final LinkedList mutations = new LinkedList<>();
private MutationImpact updatedSchemaDirty = MutationImpact.NO_IMPACT;
private int lastMutationReflectedInSchema = 0;
private ReferenceSchemaContract updatedSchema;
ReferenceSchemaBuilder(
@Nonnull CatalogSchemaContract catalogSchema,
@Nonnull EntitySchemaContract entitySchema,
@Nullable ReferenceSchemaContract existingSchema,
@Nonnull String name,
@Nonnull String entityType,
boolean referencedEntityTypeManaged,
@Nonnull Cardinality cardinality,
@Nonnull List mutations,
boolean createNew
) {
this.catalogSchema = catalogSchema;
this.entitySchema = entitySchema;
this.baseSchema = existingSchema == null ?
ReferenceSchema._internalBuild(
name, entityType, referencedEntityTypeManaged, cardinality, null, false, false, false
) :
existingSchema;
if (createNew) {
this.mutations.add(
new CreateReferenceSchemaMutation(
baseSchema.getName(),
baseSchema.getDescription(),
baseSchema.getDeprecationNotice(),
cardinality,
entityType,
referencedEntityTypeManaged,
baseSchema.getReferencedGroupType(),
baseSchema.isReferencedGroupTypeManaged(),
baseSchema.isIndexed(),
baseSchema.isFaceted()
)
);
} else {
if (referencedEntityTypeManaged != existingSchema.isReferencedEntityTypeManaged() || !entityType.equals(existingSchema.getReferencedEntityType())) {
this.mutations.add(
new ModifyReferenceSchemaRelatedEntityMutation(
baseSchema.getName(),
entityType,
referencedEntityTypeManaged
)
);
}
if (cardinality != existingSchema.getCardinality()) {
this.mutations.add(
new ModifyReferenceSchemaCardinalityMutation(
baseSchema.getName(),
cardinality
)
);
}
}
mutations.stream()
.filter(
it -> it instanceof ReferenceSchemaMutation referenceSchemaMutation &&
(name.equals(referenceSchemaMutation.getName()) &&
!(referenceSchemaMutation instanceof CreateReferenceSchemaMutation)) &&
!(referenceSchemaMutation instanceof RemoveReferenceSchemaMutation)
)
.forEach(this.mutations::add);
}
@Override
@Nonnull
public ReferenceSchemaBuilder withDescription(@Nullable String description) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDescriptionMutation(getName(), description)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder deprecated(@Nonnull String deprecationNotice) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDeprecationNoticeMutation(getName(), deprecationNotice)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder notDeprecatedAnymore() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDeprecationNoticeMutation(getName(), null)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withGroupType(@Nonnull String groupType) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), groupType, false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withGroupTypeRelatedToEntity(@Nonnull String groupType) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), groupType, true)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withoutGroupType() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), null, false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder indexed() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), true)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder nonIndexed() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder faceted() {
if (toInstanceInternal().isIndexed()) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaFacetedMutation(getName(), true)
)
);
} else {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), true),
new SetReferenceSchemaFacetedMutation(getName(), true)
)
);
}
return this;
}
@Override
public ReferenceSchemaBuilder nonFaceted() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaFacetedMutation(getName(), false)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder withAttribute(@Nonnull String attributeName, @Nonnull Class ofType) {
return withAttribute(attributeName, ofType, null);
}
@Nonnull
@Override
public ReferenceSchemaBuilder withAttribute(
@Nonnull String attributeName,
@Nonnull Class ofType,
@Nullable Consumer whichIs
) {
final Optional existingAttribute = getAttribute(attributeName);
final AttributeSchemaBuilder attributeSchemaBuilder =
existingAttribute
.map(it -> {
Assert.isTrue(
ofType.equals(it.getType()),
() -> new InvalidSchemaMutationException(
"Attribute " + attributeName + " has already assigned type " + it.getType() +
", cannot change this type to: " + ofType + "!"
)
);
return new AttributeSchemaBuilder(entitySchema, it);
})
.orElseGet(() -> new AttributeSchemaBuilder(entitySchema, attributeName, ofType));
ofNullable(whichIs).ifPresent(it -> it.accept(attributeSchemaBuilder));
final AttributeSchemaContract attributeSchema = attributeSchemaBuilder.toInstance();
checkSortableTraits(attributeName, attributeSchema);
// check the names in all naming conventions are unique in the catalog schema
checkNamesAreUniqueInAllNamingConventions(
this.getAttributes().values(),
this.getSortableAttributeCompounds().values(),
attributeSchema
);
if (existingAttribute.map(it -> !it.equals(attributeSchema)).orElse(true)) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
attributeSchemaBuilder
.toReferenceMutation(getName())
.stream()
.map(it -> (LocalEntitySchemaMutation) it)
.toArray(LocalEntitySchemaMutation[]::new)
)
);
}
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder withoutAttribute(@Nonnull String attributeName) {
checkSortableAttributeCompoundsWithoutAttribute(
attributeName, this.getSortableAttributeCompounds().values()
);
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceAttributeSchemaMutation(
this.getName(),
new RemoveAttributeSchemaMutation(attributeName)
)
)
);
return this;
}
@Nonnull
@Override
public ReferenceSchemaBuilder withSortableAttributeCompound(
@Nonnull String name,
@Nonnull AttributeElement... attributeElements
) {
return withSortableAttributeCompound(
name, attributeElements, null
);
}
@Override
public ReferenceSchemaBuilder withSortableAttributeCompound(
@Nonnull String name,
@Nonnull AttributeElement[] attributeElements,
@Nullable Consumer whichIs
) {
final Optional existingCompound = getSortableAttributeCompound(name);
final SortableAttributeCompoundSchemaBuilder builder = new SortableAttributeCompoundSchemaBuilder(
catalogSchema,
entitySchema,
this,
this.baseSchema.getSortableAttributeCompound(name).orElse(null),
name,
Arrays.asList(attributeElements),
Collections.emptyList(),
true
);
final SortableAttributeCompoundSchemaBuilder schemaBuilder =
existingCompound
.map(it -> {
Assert.isTrue(
it.getAttributeElements().equals(Arrays.asList(attributeElements)),
() -> new AttributeAlreadyPresentInEntitySchemaException(
it, builder.toInstance(), null, name
)
);
return builder;
})
.orElse(builder);
ofNullable(whichIs).ifPresent(it -> it.accept(schemaBuilder));
final SortableAttributeCompoundSchemaContract compoundSchema = schemaBuilder.toInstance();
isTrue(
compoundSchema.getAttributeElements().size() > 1,
() -> new SortableAttributeCompoundSchemaException(
"Sortable attribute compound requires more than one attribute element!",
compoundSchema
)
);
isTrue(
compoundSchema.getAttributeElements().size() ==
compoundSchema.getAttributeElements()
.stream()
.map(AttributeElement::attributeName)
.distinct()
.count(),
() -> new SortableAttributeCompoundSchemaException(
"Attribute names of elements in sortable attribute compound must be unique!",
compoundSchema
)
);
checkSortableTraits(name, compoundSchema, this.getAttributes());
// check the names in all naming conventions are unique in the catalog schema
checkNamesAreUniqueInAllNamingConventions(
this.getAttributes().values(),
this.getSortableAttributeCompounds().values(),
compoundSchema
);
if (existingCompound.map(it -> !it.equals(compoundSchema)).orElse(true)) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
schemaBuilder
.toReferenceMutation(getName())
.stream()
.map(it -> (LocalEntitySchemaMutation) it)
.toArray(LocalEntitySchemaMutation[]::new)
)
);
}
return this;
}
@Nonnull
@Override
public ReferenceSchemaBuilder withoutSortableAttributeCompound(@Nonnull String name) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSortableAttributeCompoundSchemaMutation(
this.getName(),
new RemoveSortableAttributeCompoundSchemaMutation(name)
)
)
);
return this;
}
/**
* Builds new instance of immutable {@link ReferenceSchemaContract} filled with updated configuration and validates
* consistency of the result.
*/
@Nonnull
public ReferenceSchemaBuilderResult toResult() {
final Collection mutations = toMutation();
// and now rebuild the schema from scratch including consistency checks
ReferenceSchemaContract currentSchema = this.baseSchema;
for (LocalEntitySchemaMutation mutation : mutations) {
currentSchema = ((ReferenceSchemaMutation) mutation).mutate(this.entitySchema, currentSchema);
}
return new ReferenceSchemaBuilderResult(currentSchema, mutations);
}
@Override
@Nonnull
public Collection toMutation() {
// apply necessary mutation sort
sortMutations();
// and return mutations
return this.mutations;
}
/**
* Builds new instance of immutable {@link ReferenceSchemaContract} filled with updated configuration.
*/
@Delegate(types = ReferenceSchemaContract.class)
private ReferenceSchemaContract toInstanceInternal() {
if (this.updatedSchema == null || this.updatedSchemaDirty != MutationImpact.NO_IMPACT) {
// if the dirty flat is set to modified previous we need to start from the base schema again
// and reapply all mutations
if (this.updatedSchemaDirty == MutationImpact.MODIFIED_PREVIOUS) {
this.lastMutationReflectedInSchema = 0;
}
// if the last mutation reflected in the schema is zero we need to start from the base schema
// else we can continue modification last known updated schema by adding additional mutations
ReferenceSchemaContract currentSchema = this.lastMutationReflectedInSchema == 0 ?
this.baseSchema : this.updatedSchema;
if (this.lastMutationReflectedInSchema < this.mutations.size()) {
// apply the mutations not reflected in the schema
for (int i = lastMutationReflectedInSchema; i < this.mutations.size(); i++) {
final LocalEntitySchemaMutation mutation = this.mutations.get(i);
currentSchema = ((ReferenceSchemaMutation) mutation).mutate(entitySchema, currentSchema, ReferenceSchemaMutator.ConsistencyChecks.SKIP);
if (currentSchema == null) {
throw new GenericEvitaInternalError("Reference unexpectedly removed from inside!");
}
}
}
this.updatedSchema = currentSchema;
this.updatedSchemaDirty = MutationImpact.NO_IMPACT;
this.lastMutationReflectedInSchema = this.mutations.size();
}
return this.updatedSchema;
}
/**
* Sorts mutations, so that attribute mutations always come last.
*/
private void sortMutations() {
// sort the mutations first, we need to apply reference schema properties such as faceted / indexed first
final Iterator it = this.mutations.iterator();
final List movedMutations = new LinkedList<>();
while (it.hasNext()) {
final LocalEntitySchemaMutation mutation = it.next();
if (mutation instanceof ModifyReferenceAttributeSchemaMutation) {
it.remove();
movedMutations.add(mutation);
}
}
this.mutations.addAll(movedMutations);
}
/**
* The {@code ReferenceSchemaBuilderResult} class represents the result of building a reference schema.
* It contains the built reference schema and a collection of mutations applied to the schema.
*/
public record ReferenceSchemaBuilderResult(
@Nonnull ReferenceSchemaContract schema,
@Nonnull Collection mutations
) {
}
}