Merge pull request #133 from SpineEventEngine/protobuf-columns

The `(column)` option

Author: dmitrykuzmin

.idea/.name

@@ -21,6 +21,7 @@
 package io.spine.server.storage.datastore;
 
 import com.google.cloud.datastore.Datastore;
+import com.google.cloud.datastore.Value;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Iterables;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
@@ -31,7 +32,7 @@
 import io.spine.server.aggregate.AggregateStorage;
 import io.spine.server.delivery.InboxStorage;
 import io.spine.server.entity.Entity;
-import io.spine.server.entity.storage.ColumnTypeRegistry;
+import io.spine.server.entity.storage.ColumnMapping;
 import io.spine.server.projection.Projection;
 import io.spine.server.projection.ProjectionStorage;
 import io.spine.server.storage.RecordStorage;
@@ -42,8 +43,6 @@
 import io.spine.server.storage.datastore.tenant.NamespaceSupplier;
 import io.spine.server.storage.datastore.tenant.NsConverterFactory;
 import io.spine.server.storage.datastore.tenant.PrefixedNsConverterFactory;
-import io.spine.server.storage.datastore.type.DatastoreColumnType;
-import io.spine.server.storage.datastore.type.DatastoreTypeRegistryFactory;
 import io.spine.server.tenant.TenantIndex;
 
 import java.util.Map;
@@ -86,12 +85,12 @@ public class DatastoreStorageFactory implements StorageFactory {
      */
     private final Map<Class<? extends Storage>, DatastoreWrapper> sysWrappers = newConcurrentMap();
 
-    private final ColumnTypeRegistry<? extends DatastoreColumnType<?, ?>> typeRegistry;
+    private final ColumnMapping<Value<?>> columnMapping;
 
     private final NsConverterFactory converterFactory;
 
     protected DatastoreStorageFactory(Builder builder) {
-        this.typeRegistry = builder.typeRegistry;
+        this.columnMapping = builder.columnMapping;
         this.datastore = builder.datastore;
         this.converterFactory = builder.converterFactory;
     }
@@ -156,8 +155,8 @@ public InboxStorage createInboxStorage(boolean multitenant) {
         return new DsInboxStorage(wrapper, multitenant);
     }
 
-    public ColumnTypeRegistry getTypeRegistry() {
-        return typeRegistry;
+    public ColumnMapping<Value<?>> columnMapping() {
+        return columnMapping;
     }
 
     /**
@@ -168,7 +167,7 @@ S configure(B builder, Class<? extends Entity<I, ?>> cls, ContextSpec context) {
         builder.setModelClass(asEntityClass(cls))
                .setDatastore(wrapperFor(context))
                .setMultitenant(context.isMultitenant())
-               .setColumnTypeRegistry(typeRegistry);
+               .setColumnMapping(columnMapping);
         S storage = builder.build();
         return storage;
     }
@@ -268,7 +267,7 @@ public static Builder newBuilder() {
     public static class Builder {
 
         private Datastore datastore;
-        private ColumnTypeRegistry<? extends DatastoreColumnType<?, ?>> typeRegistry;
+        private ColumnMapping<Value<?>> columnMapping;
         private NamespaceConverter namespaceConverter;
         private NsConverterFactory converterFactory;
 
@@ -296,19 +295,17 @@ public Datastore getDatastore() {
         }
 
         /**
-         * Sets a {@link ColumnTypeRegistry} for handling the Entity Columns.
+         * Sets the {@link ColumnMapping} to use.
          *
-         * <p>Default value is {@link DatastoreTypeRegistryFactory#defaultInstance()}.
+         * <p>Default value is {@link DsColumnMapping}.
          *
-         * @param typeRegistry
-         *         the type registry containing all the required
-         *         {@linkplain io.spine.server.entity.storage.ColumnType column types}
-         *         to handle the existing Entity Columns
+         * @param columnMapping
+         *         the storage rules for entity columns
          * @return self for method chaining
          */
         public Builder
-        setTypeRegistry(ColumnTypeRegistry<? extends DatastoreColumnType<?, ?>> typeRegistry) {
-            this.typeRegistry = checkNotNull(typeRegistry);
+        setColumnMapping(ColumnMapping<Value<?>> columnMapping) {
+            this.columnMapping = checkNotNull(columnMapping);
             return this;
         }
 
@@ -337,8 +334,8 @@ public Builder setNamespaceConverter(NamespaceConverter converter) {
          */
         public DatastoreStorageFactory build() {
             checkNotNull(datastore);
-            if (typeRegistry == null) {
-                typeRegistry = DatastoreTypeRegistryFactory.defaultInstance();
+            if (columnMapping == null) {
+                columnMapping = new DsColumnMapping();
             }
             if (namespaceConverter == null) {
                 converterFactory = NsConverterFactory.defaults();

config

@@ -116,7 +116,7 @@ protected DsAggregateStorage(Class<? extends Aggregate<I, ?, ?>> cls,
         @SuppressWarnings("unchecked") // The ID class is ensured by the parameter type.
                 Class<I> idClass = (Class<I>) modelClass.idClass();
         this.idClass = idClass;
-        this.stateTypeName = modelClass.stateType()
+        this.stateTypeName = modelClass.stateTypeUrl()
                                        .toTypeName();
     }
 

datastore/src/main/java/io/spine/server/storage/datastore/DatastoreStorageFactory.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2019, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.server.storage.datastore;
+
+import com.google.cloud.datastore.Blob;
+import com.google.cloud.datastore.BlobValue;
+import com.google.cloud.datastore.BooleanValue;
+import com.google.cloud.datastore.DoubleValue;
+import com.google.cloud.datastore.LongValue;
+import com.google.cloud.datastore.NullValue;
+import com.google.cloud.datastore.StringValue;
+import com.google.cloud.datastore.TimestampValue;
+import com.google.cloud.datastore.Value;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Message;
+import com.google.protobuf.Timestamp;
+import io.spine.core.Version;
+import io.spine.server.entity.storage.AbstractColumnMapping;
+import io.spine.server.entity.storage.ColumnTypeMapping;
+import io.spine.string.Stringifiers;
+
+import static com.google.cloud.Timestamp.ofTimeSecondsAndNanos;
+
+/**
+ * The default Datastore column mapping.
+ *
+ * <p>All column values are stored as Datastore {@link Value}-s.
+ *
+ * <p>Users of the storage can extend this class to specify their own column mapping for the
+ * selected types.
+ */
+public class DsColumnMapping extends AbstractColumnMapping<Value<?>> {
+
+    @Override
+    protected void
+    setupCustomMapping(
+            ImmutableMap.Builder<Class<?>, ColumnTypeMapping<?, ? extends Value<?>>> builder) {
+        builder.put(Timestamp.class, ofTimestamp());
+        builder.put(Version.class, ofVersion());
+    }
+
+    @Override
+    protected ColumnTypeMapping<String, StringValue> ofString() {
+        return StringValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<Integer, LongValue> ofInteger() {
+        return LongValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<Long, LongValue> ofLong() {
+        return LongValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<Float, DoubleValue> ofFloat() {
+        return DoubleValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<Double, DoubleValue> ofDouble() {
+        return DoubleValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<Boolean, BooleanValue> ofBoolean() {
+        return BooleanValue::of;
+    }
+
+    @Override
+    protected ColumnTypeMapping<ByteString, BlobValue> ofByteString() {
+        return bytes -> {
+            Blob blob = Blob.copyFrom(bytes.asReadOnlyByteBuffer());
+            return BlobValue.of(blob);
+        };
+    }
+
+    @Override
+    protected ColumnTypeMapping<Enum<?>, LongValue> ofEnum() {
+        return anEnum -> LongValue.of(anEnum.ordinal());
+    }
+
+    @Override
+    protected ColumnTypeMapping<Message, StringValue> ofMessage() {
+        return msg -> {
+            String str = Stringifiers.toString(msg);
+            return StringValue.of(str);
+        };
+    }
+
+    @Override
+    public ColumnTypeMapping<?, ? extends Value<?>> ofNull() {
+        return o -> NullValue.of();
+    }
+
+    @SuppressWarnings("ProtoTimestampGetSecondsGetNano") // This behavior is intended.
+    private static ColumnTypeMapping<Timestamp, TimestampValue> ofTimestamp() {
+        return timestamp -> TimestampValue.of(
+                ofTimeSecondsAndNanos(timestamp.getSeconds(), timestamp.getNanos())
+        );
+    }
+
+    private static ColumnTypeMapping<Version, LongValue> ofVersion() {
+        return version -> LongValue.of(version.getNumber());
+    }
+}

datastore/src/main/java/io/spine/server/storage/datastore/DsAggregateStorage.java

@@ -34,7 +34,7 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.spine.client.OrderBy.Direction.ASCENDING;
 import static io.spine.util.Exceptions.newIllegalStateException;
-import static io.spine.validate.Validate.checkNotDefault;
+import static io.spine.util.Preconditions2.checkNotDefaultArg;
 import static java.util.Arrays.stream;
 
 /**
@@ -76,7 +76,7 @@ public int compare(Entity a, Entity b) {
      */
     static Comparator<Entity> implementing(OrderBy orderBy) {
         checkNotNull(orderBy);
-        checkNotDefault(orderBy);
+        checkNotDefaultArg(orderBy);
         Comparator<Entity> comparator = new DsEntityComparator(orderBy.getColumn());
         return orderBy.getDirection() == ASCENDING ? comparator : comparator.reversed();
     }

datastore/src/main/java/io/spine/server/storage/datastore/DsColumnMapping.java

@@ -26,8 +26,8 @@
 import com.google.common.base.Objects;
 import com.google.common.collect.ImmutableMultimap;
 import io.spine.client.Filter;
+import io.spine.server.entity.storage.Column;
 import io.spine.server.entity.storage.CompositeQueryParameter;
-import io.spine.server.entity.storage.EntityColumn;
 
 import javax.annotation.Nullable;
 import java.util.ArrayDeque;
@@ -69,7 +69,7 @@ final class DsFilters {
     private static final Predicate<CompositeQueryParameter> isConjunctive =
             input -> {
                 checkNotNull(input);
-                return input.getOperator() == ALL;
+                return input.operator() == ALL;
             };
 
     /**
@@ -285,9 +285,9 @@ private static FilterNode buildConjunctionTree(
      * Converts the given parameter to a {@code Collection} of {@link FilterNode}s.
      */
     private static Collection<FilterNode> toFilters(CompositeQueryParameter param) {
-        ImmutableMultimap<EntityColumn, Filter> srcFilters = param.getFilters();
+        ImmutableMultimap<Column, Filter> srcFilters = param.filters();
         Set<FilterNode> filters = new HashSet<>(srcFilters.size());
-        for (Map.Entry<EntityColumn, Filter> entry : srcFilters.entries()) {
+        for (Map.Entry<Column, Filter> entry : srcFilters.entries()) {
             filters.add(new FilterNode(entry.getKey(), entry.getValue()));
         }
         return filters;
@@ -363,12 +363,12 @@ public void walk(Collection<FilterNode> conjunctionGroup) {
      */
     private static class FilterNode {
 
-        private final EntityColumn column;
+        private final Column column;
         private final Filter columnFilter;
 
         private final Collection<FilterNode> subtrees;
 
-        private FilterNode(@Nullable EntityColumn column, @Nullable Filter filter) {
+        private FilterNode(@Nullable Column column, @Nullable Filter filter) {
             this.column = column;
             this.columnFilter = filter;
             this.subtrees = newLinkedList();
@@ -378,19 +378,20 @@ private FilterNode() {
             this(null, null);
         }
 
-        private EntityColumn getColumn() {
+        private Column column() {
             return column;
         }
 
-        private Filter getFilter() {
+        private Filter filter() {
             return columnFilter;
         }
 
         @SuppressWarnings({"EnumSwitchStatementWhichMissesCases", "MethodOnlyUsedFromInnerClass"})
             // Only non-faulty values are used.
         private StructuredQuery.Filter toFilter(FilterAdapter adapter) {
             Value<?> value = adapter.toValue(column, columnFilter);
-            String columnName = column.name();
+            String columnName = column.name()
+                                      .value();
             switch (columnFilter.getOperator()) {
                 case EQUAL:
                     return eq(columnName, value);
@@ -468,13 +469,13 @@ public boolean equals(Object o) {
                 return false;
             }
             FilterNode that = (FilterNode) o;
-            return Objects.equal(getColumn(), that.getColumn()) &&
-                    Objects.equal(getFilter(), that.getFilter());
+            return Objects.equal(column(), that.column()) &&
+                    Objects.equal(filter(), that.filter());
         }
 
         @Override
         public int hashCode() {
-            return Objects.hashCode(getColumn(), getFilter());
+            return Objects.hashCode(column(), filter());
         }
 
         private static Function<FilterNode, StructuredQuery.Filter>

datastore/src/main/java/io/spine/server/storage/datastore/DsEntityComparator.java

@@ -39,9 +39,9 @@
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.collect.Lists.newArrayList;
+import static io.spine.protobuf.Messages.isDefault;
 import static io.spine.server.storage.datastore.DsEntityComparator.implementing;
 import static io.spine.server.storage.datastore.FieldMaskApplier.recordMasker;
-import static io.spine.validate.Validate.isDefault;
 import static java.util.Collections.singleton;
 import static java.util.stream.Collectors.toList;
 

datastore/src/main/java/io/spine/server/storage/datastore/DsFilters.java

@@ -33,7 +33,7 @@
 import java.util.Iterator;
 import java.util.Optional;
 
-import static io.spine.validate.Validate.isDefault;
+import static io.spine.protobuf.Messages.isDefault;
 
 /**
  * Datastore implementation of the {@link ProjectionStorage}.
@@ -51,7 +51,7 @@ protected DsProjectionStorage(Class<? extends Projection<I, ?, ?>> projectionCla
                                   DsRecordStorage<I> recordStorage,
                                   DsPropertyStorage propertyStorage,
                                   boolean multitenant) {
-        super(multitenant);
+        super(projectionClass, multitenant);
         this.recordStorage = recordStorage;
         this.propertyStorage = propertyStorage;
         this.lastTimestampId =