Migrate to the new columns API and repair tests

Author: dmitrykuzmin

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

@@ -32,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.ColumnConversionRules;
+import io.spine.server.entity.storage.ColumnStorageRules;
 import io.spine.server.projection.Projection;
 import io.spine.server.projection.ProjectionStorage;
 import io.spine.server.storage.RecordStorage;
@@ -43,7 +43,7 @@
 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.DsColumnConversionRules;
+import io.spine.server.storage.datastore.type.DsStorageRules;
 import io.spine.server.tenant.TenantIndex;
 
 import java.util.Map;
@@ -86,12 +86,12 @@ public class DatastoreStorageFactory implements StorageFactory {
      */
     private final Map<Class<? extends Storage>, DatastoreWrapper> sysWrappers = newConcurrentMap();
 
-    private final ColumnConversionRules<Value<?>> columnConversionRules;
+    private final ColumnStorageRules<Value<?>> columnStorageRules;
 
     private final NsConverterFactory converterFactory;
 
     protected DatastoreStorageFactory(Builder builder) {
-        this.columnConversionRules = builder.columnConversionRules;
+        this.columnStorageRules = builder.columnStorageRules;
         this.datastore = builder.datastore;
         this.converterFactory = builder.converterFactory;
     }
@@ -156,8 +156,8 @@ public InboxStorage createInboxStorage(boolean multitenant) {
         return new DsInboxStorage(wrapper, multitenant);
     }
 
-    public ColumnConversionRules<Value<?>> columnConversionRules() {
-        return columnConversionRules;
+    public ColumnStorageRules<Value<?>> columnStorageRules() {
+        return columnStorageRules;
     }
 
     /**
@@ -168,7 +168,7 @@ S configure(B builder, Class<? extends Entity<I, ?>> cls, ContextSpec context) {
         builder.setModelClass(asEntityClass(cls))
                .setDatastore(wrapperFor(context))
                .setMultitenant(context.isMultitenant())
-               .setColumnConversionRules(columnConversionRules);
+               .setColumnStorageRules(columnStorageRules);
         S storage = builder.build();
         return storage;
     }
@@ -268,7 +268,7 @@ public static Builder newBuilder() {
     public static class Builder {
 
         private Datastore datastore;
-        private ColumnConversionRules<Value<?>> columnConversionRules;
+        private ColumnStorageRules<Value<?>> columnStorageRules;
         private NamespaceConverter namespaceConverter;
         private NsConverterFactory converterFactory;
 
@@ -296,17 +296,17 @@ public Datastore getDatastore() {
         }
 
         /**
-         * Sets the {@link ColumnConversionRules}.
+         * Sets the {@link ColumnStorageRules}.
          *
-         * <p>Default value is {@link DsColumnConversionRules}.
+         * <p>Default value is {@link DsStorageRules}.
          *
-         * @param columnConversionRules
-         *         the conversion rules for entity columns
+         * @param columnStorageRules
+         *         the storage rules for entity columns
          * @return self for method chaining
          */
         public Builder
-        setColumnConversionRules(ColumnConversionRules<Value<?>> columnConversionRules) {
-            this.columnConversionRules = checkNotNull(columnConversionRules);
+        setColumnStorageRules(ColumnStorageRules<Value<?>> columnStorageRules) {
+            this.columnStorageRules = checkNotNull(columnStorageRules);
             return this;
         }
 
@@ -335,8 +335,8 @@ public Builder setNamespaceConverter(NamespaceConverter converter) {
          */
         public DatastoreStorageFactory build() {
             checkNotNull(datastore);
-            if (columnConversionRules == null) {
-                columnConversionRules = new DsColumnConversionRules();
+            if (columnStorageRules == null) {
+                columnStorageRules = new DsStorageRules();
             }
             if (namespaceConverter == null) {
                 converterFactory = NsConverterFactory.defaults();

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

@@ -31,7 +31,7 @@
 import io.spine.client.OrderBy;
 import io.spine.client.ResponseFormat;
 import io.spine.server.entity.EntityRecord;
-import io.spine.server.entity.storage.ColumnConversionRules;
+import io.spine.server.entity.storage.ColumnStorageRules;
 import io.spine.server.entity.storage.EntityQuery;
 import io.spine.server.entity.storage.EntityRecordWithColumns;
 import io.spine.server.entity.storage.QueryParameters;
@@ -70,7 +70,7 @@ public class DsRecordStorage<I> extends RecordStorage<I> {
     private final DsLookupByIds<I> idLookup;
     private final DsLookupByQueries queryLookup;
 
-    private final ColumnConversionRules<Value<?>> columnConversionRules;
+    private final ColumnStorageRules<Value<?>> columnStorageRules;
     private final FilterAdapter columnFilterAdapter;
 
     /**
@@ -93,8 +93,8 @@ protected DsRecordStorage(
         this.typeUrl = TypeUrl.from(b.getDescriptor());
         this.idClass = checkNotNull(b.getIdClass());
         this.datastore = b.getDatastore();
-        this.columnConversionRules = checkNotNull(b.getColumnConversionRules());
-        this.columnFilterAdapter = FilterAdapter.of(this.columnConversionRules);
+        this.columnStorageRules = checkNotNull(b.getColumnStorageRules());
+        this.columnFilterAdapter = FilterAdapter.of(this.columnStorageRules);
         this.idLookup = new DsLookupByIds<>(this.datastore, this.typeUrl);
         this.queryLookup = new DsLookupByQueries(this.datastore, this.typeUrl,
                                                  this.columnFilterAdapter);
@@ -269,7 +269,7 @@ protected Entity entityRecordToEntity(I id, EntityRecordWithColumns record) {
     private void populateFromStorageFields(BaseEntity.Builder<Key, Entity.Builder> entity,
                                            EntityRecordWithColumns record) {
         record.columnNames().forEach(columnName -> {
-            Value<?> columnValue = record.columnValue(columnName, columnConversionRules);
+            Value<?> columnValue = record.columnValue(columnName, columnStorageRules);
             entity.set(columnName.value(), columnValue);
         });
     }

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

@@ -25,25 +25,25 @@
 import io.spine.client.Filter;
 import io.spine.protobuf.TypeConverter;
 import io.spine.server.entity.storage.Column;
-import io.spine.server.entity.storage.ColumnConversionRules;
-import io.spine.server.entity.storage.ConversionRule;
+import io.spine.server.entity.storage.ColumnStorageRule;
+import io.spine.server.entity.storage.ColumnStorageRules;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
- * A {@link Filter} to {@link Value} adapter based on {@link ColumnConversionRules}.
+ * A {@link Filter} to {@link Value} adapter based on {@link ColumnStorageRules}.
  */
 final class FilterAdapter {
 
-    private final ColumnConversionRules<Value<?>> conversionRules;
+    private final ColumnStorageRules<Value<?>> columnStorageRules;
 
-    static FilterAdapter of(ColumnConversionRules<Value<?>> conversionRules) {
-        return new FilterAdapter(conversionRules);
+    static FilterAdapter of(ColumnStorageRules<Value<?>> columnStorageRules) {
+        return new FilterAdapter(columnStorageRules);
     }
 
-    private FilterAdapter(ColumnConversionRules<Value<?>> conversionRules) {
-        this.conversionRules = conversionRules;
+    private FilterAdapter(ColumnStorageRules<Value<?>> columnStorageRules) {
+        this.columnStorageRules = columnStorageRules;
     }
 
     /**
@@ -64,11 +64,11 @@ Value<?> toValue(Column column, Filter columnFilter) {
         Class<?> columnClass = column.type();
         Object filterValueUnpacked = TypeConverter.toObject(filterValue, columnClass);
 
-        ConversionRule<?, ? extends Value<?>> strategy =
-                conversionRules.of(filterValueUnpacked.getClass());
-        checkArgument(strategy != null, "Column of unknown type: %s.", column);
+        ColumnStorageRule<?, ? extends Value<?>> storageRule =
+                columnStorageRules.of(filterValueUnpacked.getClass());
+        checkArgument(storageRule != null, "Column of unknown type: %s.", column);
 
-        Value<?> result = strategy.applyTo(filterValueUnpacked);
+        Value<?> result = storageRule.applyTo(filterValueUnpacked);
         return result;
     }
 }

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

@@ -25,7 +25,7 @@
 import com.google.protobuf.Descriptors.Descriptor;
 import io.spine.server.entity.Entity;
 import io.spine.server.entity.model.EntityClass;
-import io.spine.server.entity.storage.ColumnConversionRules;
+import io.spine.server.entity.storage.ColumnStorageRules;
 import io.spine.server.storage.RecordStorage;
 import io.spine.type.TypeUrl;
 
@@ -47,7 +47,7 @@ abstract class RecordStorageBuilder<I,
     private Descriptor descriptor;
     private DatastoreWrapper datastore;
     private boolean multitenant;
-    private ColumnConversionRules<Value<?>> columnConversionRules;
+    private ColumnStorageRules<Value<?>> columnStorageRules;
     private Class<I> idClass;
     private EntityClass<?> entityClass;
 
@@ -132,12 +132,12 @@ public B setMultitenant(boolean multitenant) {
     }
 
     /**
-     * Assigns the column conversion rules of
+     * Assigns the column storage rules of
      * the {@linkplain io.spine.server.entity.storage.Column entity columns}.
      */
     @CanIgnoreReturnValue
-    public B setColumnConversionRules(ColumnConversionRules<Value<?>> columnConversionRules) {
-        this.columnConversionRules = checkNotNull(columnConversionRules);
+    public B setColumnStorageRules(ColumnStorageRules<Value<?>> columnStorageRules) {
+        this.columnStorageRules = checkNotNull(columnStorageRules);
         return self();
     }
 
@@ -164,10 +164,10 @@ public boolean isMultitenant() {
     }
 
     /**
-     * Obtains the column conversion rules of the storage.
+     * Obtains the column storage rules of the storage.
      */
-    public ColumnConversionRules<Value<?>> getColumnConversionRules() {
-        return columnConversionRules;
+    public ColumnStorageRules<Value<?>> getColumnStorageRules() {
+        return columnStorageRules;
     }
 
     /**
@@ -187,7 +187,7 @@ public EntityClass<?> getEntityClass() {
     final void checkRequiredFields() {
         checkNotNull(descriptor, "State descriptor is not set.");
         checkNotNull(datastore, "Datastore is not set.");
-        checkNotNull(columnConversionRules, "Column conversion rules are not set.");
+        checkNotNull(columnStorageRules, "Column storage rules are not set.");
     }
 
     abstract B self();

…astore/type/DsColumnConversionRules.java …orage/datastore/type/DsStorageRules.javadatastore/src/main/java/io/spine/server/storage/datastore/type/DsColumnConversionRules.java renamed to datastore/src/main/java/io/spine/server/storage/datastore/type/DsStorageRules.java datastore/src/main/java/io/spine/server/storage/datastore/type/DsColumnConversionRules.java renamed to datastore/src/main/java/io/spine/server/storage/datastore/type/DsStorageRules.java

@@ -34,88 +34,89 @@
 import com.google.protobuf.Message;
 import com.google.protobuf.Timestamp;
 import io.spine.core.Version;
-import io.spine.server.entity.storage.AbstractColumnConversionRules;
-import io.spine.server.entity.storage.ConversionRule;
+import io.spine.server.entity.storage.AbstractStorageRules;
+import io.spine.server.entity.storage.ColumnStorageRule;
 import io.spine.string.Stringifiers;
 
 import static com.google.cloud.Timestamp.ofTimeSecondsAndNanos;
 
 /**
  * Non-{@code final}, implement to ..., maybe {@link io.spine.annotation.SPI}.
  */
-public class DsColumnConversionRules extends AbstractColumnConversionRules<Value<?>> {
+public class DsStorageRules extends AbstractStorageRules<Value<?>> {
 
     @Override
     protected void
     setupCustomRules(
-            ImmutableMap.Builder<Class<?>, ConversionRule<?, ? extends Value<?>>> builder) {
+            ImmutableMap.Builder<Class<?>, ColumnStorageRule<?, ? extends Value<?>>> builder) {
         builder.put(Timestamp.class, ofTimestamp());
         builder.put(Version.class, ofVersion());
     }
 
     @Override
-    protected ConversionRule<String, StringValue> ofString() {
+    protected ColumnStorageRule<String, StringValue> ofString() {
         return StringValue::of;
     }
 
     @Override
-    protected ConversionRule<Integer, LongValue> ofInteger() {
+    protected ColumnStorageRule<Integer, LongValue> ofInteger() {
         return LongValue::of;
     }
 
     @Override
-    protected ConversionRule<Long, LongValue> ofLong() {
+    protected ColumnStorageRule<Long, LongValue> ofLong() {
         return LongValue::of;
     }
 
     @Override
-    protected ConversionRule<Float, DoubleValue> ofFloat() {
+    protected ColumnStorageRule<Float, DoubleValue> ofFloat() {
         return DoubleValue::of;
     }
 
     @Override
-    protected ConversionRule<Double, DoubleValue> ofDouble() {
+    protected ColumnStorageRule<Double, DoubleValue> ofDouble() {
         return DoubleValue::of;
     }
 
     @Override
-    protected ConversionRule<Boolean, BooleanValue> ofBoolean() {
+    protected ColumnStorageRule<Boolean, BooleanValue> ofBoolean() {
         return BooleanValue::of;
     }
 
     @Override
-    protected ConversionRule<ByteString, BlobValue> ofByteString() {
+    protected ColumnStorageRule<ByteString, BlobValue> ofByteString() {
         return bytes -> {
             Blob blob = Blob.copyFrom(bytes.asReadOnlyByteBuffer());
             return BlobValue.of(blob);
         };
     }
 
     @Override
-    protected ConversionRule<Enum<?>, LongValue> ofEnum() {
+    protected ColumnStorageRule<Enum<?>, LongValue> ofEnum() {
         return anEnum -> LongValue.of(anEnum.ordinal());
     }
 
     @Override
-    protected ConversionRule<Message, StringValue> ofMessage() {
+    protected ColumnStorageRule<Message, StringValue> ofMessage() {
         return msg -> {
             String str = Stringifiers.toString(msg);
             return StringValue.of(str);
         };
     }
 
     @Override
-    public ConversionRule<?, ? extends Value<?>> ofNull() {
+    public ColumnStorageRule<?, ? extends Value<?>> ofNull() {
         return o -> NullValue.of();
     }
 
-    private static ConversionRule<Timestamp, TimestampValue> ofTimestamp() {
+    @SuppressWarnings("ProtoTimestampGetSecondsGetNano") // This behavior is intended.
+    private static ColumnStorageRule<Timestamp, TimestampValue> ofTimestamp() {
         return timestamp -> TimestampValue.of(
                 ofTimeSecondsAndNanos(timestamp.getSeconds(), timestamp.getNanos())
         );
     }
 
-    private static ConversionRule<Version, LongValue> ofVersion() {
+    private static ColumnStorageRule<Version, LongValue> ofVersion() {
         return version -> LongValue.of(version.getNumber());
     }
 }