From 695258c1a90a6ad30f5f323fc1a715ef431a0294 Mon Sep 17 00:00:00 2001
From: Effi Ban <effi.ban@skai.io>
Date: Mon, 5 Feb 2024 12:32:33 +0200
Subject: [PATCH] DRAFT - Support comparable entity fields and DSL

---
 .../kenshoo/pl/entity/AbstractEntityType.java |  92 +++++++----
 .../com/kenshoo/pl/entity/EntityField.java    |  19 +++
 .../kenshoo/pl/entity/MutableEntityField.java |   8 +
 .../entity/internal/AbstractEntityField.java  | 148 ++++++++++++++++++
 .../pl/entity/internal/EntityFieldImpl.java   |  73 ++++-----
 .../internal/PrototypedEntityFieldImpl.java   |  61 +++++++-
 .../SecondaryTableRelationExtractor.java      |   8 +-
 .../internal/VirtualEntityFieldImpl.java      |  45 +++++-
 .../com/kenshoo/pl/entity/TestEntity.java     |  10 ++
 .../kenshoo/pl/entity/TestEntityTable.java    |   3 +
 10 files changed, 388 insertions(+), 79 deletions(-)
 create mode 100644 main/src/main/java/com/kenshoo/pl/entity/MutableEntityField.java
 create mode 100644 main/src/main/java/com/kenshoo/pl/entity/internal/AbstractEntityField.java

diff --git a/main/src/main/java/com/kenshoo/pl/entity/AbstractEntityType.java b/main/src/main/java/com/kenshoo/pl/entity/AbstractEntityType.java
index da02f0bc..1747e7e0 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/AbstractEntityType.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/AbstractEntityType.java
@@ -38,55 +38,87 @@ protected AbstractEntityType(String name) {
         this.name = name;
     }
 
-    protected <T> EntityField<E, T> field(TableField<Record, T> tableField) {
+    protected <T> MutableEntityField<E, T> field(final TableField<Record, T> tableField) {
         return field(tableField, IdentityValueConverter.getInstance(tableField.getType()));
     }
 
-    protected <T, DBT> EntityField<E, T> field(TableField<Record, DBT> tableField, ValueConverter<T, DBT> valueConverter) {
+    protected <T, DBT> MutableEntityField<E, T> field(final TableField<Record, DBT> tableField, final ValueConverter<T, DBT> valueConverter) {
         return field(tableField, valueConverter, Objects::equals);
     }
 
-    protected <T, DBT> EntityField<E, T> field(TableField<Record, DBT> tableField, ValueConverter<T, DBT> valueConverter, ValueConverter<T, String> stringValueConverter) {
+    protected <T, DBT> MutableEntityField<E, T> field(final TableField<Record, DBT> tableField,
+                                                      final ValueConverter<T, DBT> valueConverter,
+                                                      final ValueConverter<T, String> stringValueConverter) {
         return field(tableField, valueConverter, stringValueConverter, Objects::equals);
     }
 
-    protected <T> EntityField<E, T> field(TableField<Record, T> tableField, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        return field(tableField, IdentityValueConverter.getInstance(tableField.getType()), createStringValueConverter(tableField.getType()), valueEqualityFunction);
+    protected <T> MutableEntityField<E, T> field(final TableField<Record, T> tableField,
+                                                 final EntityValueEqualityFunction<T> valueEqualityFunction) {
+        return field(tableField,
+                IdentityValueConverter.getInstance(tableField.getType()),
+                createStringValueConverter(tableField.getType()),
+                valueEqualityFunction);
     }
 
-    protected <T, DBT> EntityField<E, T> field(TableField<Record, DBT> tableField, ValueConverter<T, DBT> valueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
+    protected <T, DBT> MutableEntityField<E, T> field(final TableField<Record, DBT> tableField,
+                                                      final ValueConverter<T, DBT> valueConverter,
+                                                      final EntityValueEqualityFunction<T> valueEqualityFunction) {
         return field(tableField, valueConverter, createStringValueConverter(valueConverter.getValueClass()), valueEqualityFunction);
     }
 
-    protected <T, DBT> EntityField<E, T> field(TableField<Record, DBT> tableField, ValueConverter<T, DBT> valueConverter,
-                                               ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        return addField(new EntityFieldImpl<>(this, new SimpleEntityFieldDbAdapter<>(tableField, valueConverter), stringValueConverter, valueEqualityFunction));
-    }
-
-    protected <T> EntityField<E, T> field(EntityFieldDbAdapter<T> dbAdapter, ValueConverter<T, String> stringValueConverter) {
-        return addField(new EntityFieldImpl<>(this, dbAdapter, stringValueConverter, Objects::equals));
-    }
-
-    protected <T, T1> EntityField<E, T> virtualField(EntityField<E, T1> field1, Function<T1, T> translator,
-                                                     ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
+    protected <T, DBT> MutableEntityField<E, T> field(final TableField<Record, DBT> tableField,
+                                                      final ValueConverter<T, DBT> valueConverter,
+                                                      final ValueConverter<T, String> stringValueConverter,
+                                                      final EntityValueEqualityFunction<T> valueEqualityFunction) {
+        return addField(
+                EntityFieldImpl.<E, T>builder(this)
+                        .withDbAdapter(new SimpleEntityFieldDbAdapter<>(tableField, valueConverter))
+                        .withStringValueConverter(stringValueConverter)
+                        .withValueEqualityFunction(valueEqualityFunction)
+                        .build()
+        );
+    }
+
+    protected <T> MutableEntityField<E, T> field(EntityFieldDbAdapter<T> dbAdapter, ValueConverter<T, String> stringValueConverter) {
+        return addField(
+                EntityFieldImpl.<E, T>builder(this)
+                        .withDbAdapter(dbAdapter)
+                        .withStringValueConverter(stringValueConverter)
+                        .withValueEqualityFunction(Objects::equals)
+                        .build()
+        );
+    }
+
+    protected <T, T1> MutableEntityField<E, T> virtualField(final EntityField<E, T1> field1,
+                                                            final Function<T1, T> translator,
+                                                            final ValueConverter<T, String> stringValueConverter,
+                                                            final EntityValueEqualityFunction<T> valueEqualityFunction) {
         return virtualField(new VirtualEntityFieldDbAdapter<>(field1.getDbAdapter(), translator), stringValueConverter, valueEqualityFunction);
     }
 
-    protected <T> EntityField<E, T> virtualField(DataTable table,
-                                                 ValueConverter<T, String> stringValueConverter,
-                                                 EntityValueEqualityFunction<T> valueEqualityFunction) {
+    protected <T> MutableEntityField<E, T> virtualField(final DataTable table,
+                                                        final ValueConverter<T, String> stringValueConverter,
+                                                        final EntityValueEqualityFunction<T> valueEqualityFunction) {
         return virtualField(new EmptyVirtualEntityFieldDbAdapter<>(table), stringValueConverter, valueEqualityFunction);
     }
 
-    protected <T, T1, T2> EntityField<E, T> virtualField(EntityField<E, T1> field1, EntityField<E, T2> field2, BiFunction<T1, T2, T> combiner,
-                                                         ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
+    protected <T, T1, T2> MutableEntityField<E, T> virtualField(final EntityField<E, T1> field1,
+                                                                final EntityField<E, T2> field2,
+                                                                final BiFunction<T1, T2, T> combiner,
+                                                                final ValueConverter<T, String> stringValueConverter,
+                                                                final EntityValueEqualityFunction<T> valueEqualityFunction) {
         return virtualField(new VirtualEntityFieldDbAdapter2<>(field1.getDbAdapter(), field2.getDbAdapter(), combiner), stringValueConverter, valueEqualityFunction);
     }
 
-    private <T> EntityField<E, T> virtualField(EntityFieldDbAdapter<T> entityFieldDbAdapter,
-                                               ValueConverter<T, String> stringValueConverter,
-                                               EntityValueEqualityFunction<T> valueEqualityFunction) {
-        return addField(new VirtualEntityFieldImpl<>(this, entityFieldDbAdapter, stringValueConverter, valueEqualityFunction));
+    private <T> MutableEntityField<E, T> virtualField(final EntityFieldDbAdapter<T> entityFieldDbAdapter,
+                                                      final ValueConverter<T, String> stringValueConverter,
+                                                      final EntityValueEqualityFunction<T> valueEqualityFunction) {
+        return addField(
+                VirtualEntityFieldImpl.<E, T>builder(this)
+                        .withDbAdapter(entityFieldDbAdapter)
+                        .withStringValueConverter(stringValueConverter)
+                        .withValueEqualityFunction(valueEqualityFunction)
+                        .build());
     }
 
     private static <T> ValueConverter<T, String> createStringValueConverter(Class<T> valueClass) {
@@ -113,8 +145,12 @@ protected <T, DBT> PrototypedEntityField<E, T> prototypedField(EntityFieldProtot
     }
 
     protected <T, DBT> PrototypedEntityField<E, T> prototypedField(EntityFieldPrototype<T> entityFieldPrototype, TableField<Record, DBT> tableField, ValueConverter<T, DBT> valueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        PrototypedEntityFieldImpl<E, T> field = new PrototypedEntityFieldImpl<>(this, entityFieldPrototype, new SimpleEntityFieldDbAdapter<>(tableField, valueConverter),
-                createStringValueConverter(valueConverter.getValueClass()), valueEqualityFunction);
+        final var field = PrototypedEntityFieldImpl.<E, T>builder(this)
+                .withDbAdapter(new SimpleEntityFieldDbAdapter<>(tableField, valueConverter))
+                .withStringValueConverter(createStringValueConverter(valueConverter.getValueClass()))
+                .withValueEqualityFunction(valueEqualityFunction)
+                .withEntityFieldPrototype(entityFieldPrototype)
+                .build();
         prototypedFields.add(field);
         return addField(field);
     }
diff --git a/main/src/main/java/com/kenshoo/pl/entity/EntityField.java b/main/src/main/java/com/kenshoo/pl/entity/EntityField.java
index 78d62956..720a0887 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/EntityField.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/EntityField.java
@@ -6,6 +6,7 @@
 
 import java.util.Arrays;
 import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 public interface EntityField<E extends EntityType<E>, T> {
@@ -16,6 +17,8 @@ public interface EntityField<E extends EntityType<E>, T> {
 
     boolean valuesEqual(T v1, T v2);
 
+    int compareValues(T v1, T v2);
+
     default Class<T> getValueClass() {
         return getStringValueConverter().getValueClass();
     }
@@ -78,4 +81,20 @@ default PLCondition isNotNull() {
         final TableField<Record, Object> tableField = (TableField<Record, Object>)getDbAdapter().getFirstTableField();
         return new PLCondition(tableField.isNotNull(), entity -> entity.safeGet(this).isNotNull(), this);
     }
+
+    default PLCondition greaterThan(T value) {
+        if (isVirtual()) {
+            throw new UnsupportedOperationException("The greaterThan operation is unsupported for virtual fields");
+        }
+
+        final Object tableValue = getDbAdapter().getFirstDbValue(value);
+        @SuppressWarnings("unchecked") final var tableField = (TableField<Record, Object>) getDbAdapter().getFirstTableField();
+        return new PLCondition(tableField.greaterThan(tableValue), entityFieldGreaterThan(value), this);
+    }
+
+    private Predicate<Entity> entityFieldGreaterThan(T value) {
+        return entity -> entity.safeGet(this)
+                .filter(entityValue -> compareValues(entityValue, value) > 0)
+                .isPresent();
+    }
 }
diff --git a/main/src/main/java/com/kenshoo/pl/entity/MutableEntityField.java b/main/src/main/java/com/kenshoo/pl/entity/MutableEntityField.java
new file mode 100644
index 00000000..cefbb4dd
--- /dev/null
+++ b/main/src/main/java/com/kenshoo/pl/entity/MutableEntityField.java
@@ -0,0 +1,8 @@
+package com.kenshoo.pl.entity;
+
+import java.util.Comparator;
+
+public interface MutableEntityField<E extends EntityType<E>, T> extends EntityField<E, T> {
+
+    EntityField<E, T> comparedBy(final Comparator<T> valueComparator);
+}
diff --git a/main/src/main/java/com/kenshoo/pl/entity/internal/AbstractEntityField.java b/main/src/main/java/com/kenshoo/pl/entity/internal/AbstractEntityField.java
new file mode 100644
index 00000000..a2a7cd10
--- /dev/null
+++ b/main/src/main/java/com/kenshoo/pl/entity/internal/AbstractEntityField.java
@@ -0,0 +1,148 @@
+package com.kenshoo.pl.entity.internal;
+
+import com.kenshoo.pl.entity.*;
+import com.kenshoo.pl.entity.equalityfunctions.EntityValueEqualityFunction;
+
+import java.util.Comparator;
+import java.util.Optional;
+
+import static java.util.Objects.requireNonNull;
+
+abstract class AbstractEntityField<
+        E extends EntityType<E>,
+        T,
+        F extends EntityField<E, T>,
+        B extends AbstractEntityField.Builder<E, T, F, B>> implements MutableEntityField<E, T> {
+
+    protected final EntityType<E> entityType;
+
+    protected final EntityFieldDbAdapter<T> dbAdapter;
+
+    protected final EntityValueEqualityFunction<T> valueEqualityFunction;
+
+    protected final Comparator<T> valueComparator;
+
+    protected final ValueConverter<T, String> stringValueConverter;
+
+    protected AbstractEntityField(final EntityType<E> entityType,
+                                  final EntityFieldDbAdapter<T> dbAdapter,
+                                  final ValueConverter<T, String> stringValueConverter,
+                                  final EntityValueEqualityFunction<T> valueEqualityFunction,
+                                  final Comparator<T> valueComparator) {
+        this.entityType = entityType;
+        this.dbAdapter = dbAdapter;
+        this.stringValueConverter = stringValueConverter;
+        this.valueEqualityFunction = valueEqualityFunction;
+        this.valueComparator = valueComparator;
+    }
+
+    @Override
+    public EntityFieldDbAdapter<T> getDbAdapter() {
+        return dbAdapter;
+    }
+
+    @Override
+    public ValueConverter<T, String> getStringValueConverter() {
+        return stringValueConverter;
+    }
+
+    @Override
+    public boolean valuesEqual(T v1, T v2) {
+        return valueEqualityFunction.apply(v1, v2);
+    }
+
+    @Override
+    public int compareValues(final T v1, final T v2) {
+        return comparatorOf(v1).compare(v1, v2);
+    }
+
+    @Override
+    public EntityType<E> getEntityType() {
+        return entityType;
+    }
+
+    protected B toBuilder() {
+        return newBuilder(entityType)
+                .withDbAdapter(dbAdapter)
+                .withValueEqualityFunction(valueEqualityFunction)
+                .withValueComparator(valueComparator)
+                .withStringValueConverter(stringValueConverter);
+    }
+
+    protected abstract B newBuilder(final EntityType<E> entityType);
+
+    @Override
+    public EntityField<E, T> comparedBy(final Comparator<T> valueComparator) {
+        requireNonNull(valueComparator);
+        return toBuilder()
+                .withValueComparator(valueComparator)
+                .withValueEqualityFunction(equalityFunctionOf(valueComparator))
+                .build();
+    }
+
+    @Override
+    public String toString() {
+        return entityType.toFieldName(this);
+    }
+
+    private Comparator<T> comparatorOf(T value) {
+        return Optional.ofNullable(valueComparator)
+                .orElseGet(() -> {
+                    if (value instanceof Comparable<?>) {
+                        //noinspection unchecked
+                        return (Comparator<T>) Comparator.naturalOrder();
+                    }
+                    throw new UnsupportedOperationException(String.format("The field [%s] is not comparable for the value [%s]", this, value));
+                });
+    }
+
+
+    private EntityValueEqualityFunction<T> equalityFunctionOf(final Comparator<T> valueComparator) {
+        return (v1, v2) -> valueComparator.compare(v1, v2) == 0;
+    }
+
+    protected abstract static class Builder<
+            E extends EntityType<E>,
+            T,
+            F extends EntityField<E, T>,
+            B extends Builder<E, T, F, B>> {
+
+        protected final EntityType<E> entityType;
+
+        protected EntityFieldDbAdapter<T> dbAdapter;
+
+        protected EntityValueEqualityFunction<T> valueEqualityFunction;
+
+        protected Comparator<T> valueComparator;
+
+        protected ValueConverter<T, String> stringValueConverter;
+
+        protected Builder(final EntityType<E> entityType) {
+            this.entityType = entityType;
+        }
+
+        public B withDbAdapter(final EntityFieldDbAdapter<T> dbAdapter) {
+            this.dbAdapter = dbAdapter;
+            return self();
+        }
+
+        public B withValueEqualityFunction(final EntityValueEqualityFunction<T> valueEqualityFunction) {
+            this.valueEqualityFunction = valueEqualityFunction;
+            return self();
+        }
+
+        public B withValueComparator(final Comparator<T> valueComparator) {
+            this.valueComparator = valueComparator;
+            return self();
+        }
+
+        public B withStringValueConverter(final ValueConverter<T, String> stringValueConverter) {
+            this.stringValueConverter = stringValueConverter;
+            return self();
+        }
+
+        protected abstract B self();
+
+        public abstract F build();
+    }
+}
diff --git a/main/src/main/java/com/kenshoo/pl/entity/internal/EntityFieldImpl.java b/main/src/main/java/com/kenshoo/pl/entity/internal/EntityFieldImpl.java
index e9af9ce5..4f0cce2d 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/internal/EntityFieldImpl.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/internal/EntityFieldImpl.java
@@ -1,61 +1,48 @@
 package com.kenshoo.pl.entity.internal;
 
-import com.kenshoo.pl.entity.EntityField;
-import com.kenshoo.pl.entity.EntityFieldDbAdapter;
-import com.kenshoo.pl.entity.EntityType;
-import com.kenshoo.pl.entity.ValueConverter;
+import com.kenshoo.pl.entity.*;
 import com.kenshoo.pl.entity.equalityfunctions.EntityValueEqualityFunction;
 
-public class EntityFieldImpl<E extends EntityType<E>, T> implements EntityField<E, T> {
+import java.util.Comparator;
 
-    private final EntityType<E> entityType;
+public class EntityFieldImpl<E extends EntityType<E>, T>
+        extends AbstractEntityField<E, T, EntityFieldImpl<E, T>, EntityFieldImpl.Builder<E, T>> {
 
-    private final EntityFieldDbAdapter<T> dbAdapter;
-
-    private final EntityValueEqualityFunction<T> valueEqualityFunction;
-
-    private final ValueConverter<T, String> stringValueConverter;
-
-    public EntityFieldImpl(EntityType<E> entityType, EntityFieldDbAdapter<T> dbAdapter, ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        this.entityType = entityType;
-        this.dbAdapter = dbAdapter;
-        this.stringValueConverter = stringValueConverter;
-        this.valueEqualityFunction = valueEqualityFunction;
+    protected EntityFieldImpl(final EntityType<E> entityType,
+                              final EntityFieldDbAdapter<T> dbAdapter,
+                              final ValueConverter<T, String> stringValueConverter,
+                              final EntityValueEqualityFunction<T> valueEqualityFunction,
+                              final Comparator<T> valueComparator) {
+        super(entityType, dbAdapter, stringValueConverter, valueEqualityFunction, valueComparator);
     }
 
     @Override
-    public EntityFieldDbAdapter<T> getDbAdapter() {
-        return dbAdapter;
+    protected Builder<E, T> newBuilder(final EntityType<E> entityType) {
+        return new Builder<>(entityType);
     }
 
-    @Override
-    public ValueConverter<T, String> getStringValueConverter() {
-        return stringValueConverter;
-    }
-
-    @Override
-    public boolean valuesEqual(T v1, T v2) {
-        return valueEqualityFunction.apply(v1, v2);
+    public static <E extends EntityType<E>, T> Builder<E, T> builder(final EntityType<E> entityType) {
+        return new Builder<>(entityType);
     }
 
-    @Override
-    public EntityType<E> getEntityType() {
-        return entityType;
-    }
+    public static class Builder<E extends EntityType<E>, T>
+            extends AbstractEntityField.Builder<E, T, EntityFieldImpl<E, T>, Builder<E, T>> {
 
-    @Override
-    public String toString() {
-        return entityType.toFieldName(this);
-    }
+        public Builder(final EntityType<E> entityType) {
+            super(entityType);
+        }
 
-    @Override
-    @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
-    public boolean equals(Object o) {
-        return (this == o);
-    }
+        protected Builder<E, T> self() {
+            return this;
+        }
 
-    @Override
-    public int hashCode() {
-        return System.identityHashCode(this);
+        public EntityFieldImpl<E, T> build() {
+            return new EntityFieldImpl<>(
+                    entityType,
+                    dbAdapter,
+                    stringValueConverter,
+                    valueEqualityFunction,
+                    valueComparator);
+        }
     }
 }
diff --git a/main/src/main/java/com/kenshoo/pl/entity/internal/PrototypedEntityFieldImpl.java b/main/src/main/java/com/kenshoo/pl/entity/internal/PrototypedEntityFieldImpl.java
index 42c78ffd..7da4d933 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/internal/PrototypedEntityFieldImpl.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/internal/PrototypedEntityFieldImpl.java
@@ -7,13 +7,21 @@
 import com.kenshoo.pl.entity.ValueConverter;
 import com.kenshoo.pl.entity.equalityfunctions.EntityValueEqualityFunction;
 
-public class PrototypedEntityFieldImpl<E extends EntityType<E>, T> extends EntityFieldImpl<E, T> implements PrototypedEntityField<E, T> {
+import java.util.Comparator;
+
+public class PrototypedEntityFieldImpl<E extends EntityType<E>, T>
+        extends AbstractEntityField<E, T, PrototypedEntityFieldImpl<E, T>, PrototypedEntityFieldImpl.Builder<E, T>>
+        implements PrototypedEntityField<E, T> {
 
     private final EntityFieldPrototype<T> entityFieldPrototype;
 
-    public PrototypedEntityFieldImpl(EntityType<E> entityType, EntityFieldPrototype<T> entityFieldPrototype, EntityFieldDbAdapter<T> dbAdapter,
-                                     ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        super(entityType, dbAdapter, stringValueConverter, valueEqualityFunction);
+    private PrototypedEntityFieldImpl(final EntityType<E> entityType,
+                                      final EntityFieldPrototype<T> entityFieldPrototype,
+                                      final EntityFieldDbAdapter<T> dbAdapter,
+                                      final ValueConverter<T, String> stringValueConverter,
+                                      final EntityValueEqualityFunction<T> valueEqualityFunction,
+                                      final Comparator<T> valueComparator) {
+        super(entityType, dbAdapter, stringValueConverter, valueEqualityFunction, valueComparator);
         this.entityFieldPrototype = entityFieldPrototype;
     }
 
@@ -21,4 +29,49 @@ public PrototypedEntityFieldImpl(EntityType<E> entityType, EntityFieldPrototype<
     public EntityFieldPrototype<T> getEntityFieldPrototype() {
         return entityFieldPrototype;
     }
+
+    @Override
+    protected Builder<E, T> toBuilder() {
+        return super.toBuilder()
+                .withEntityFieldPrototype(entityFieldPrototype);
+    }
+
+    @Override
+    protected Builder<E, T> newBuilder(final EntityType<E> entityType) {
+        return new PrototypedEntityFieldImpl.Builder<>(entityType);
+    }
+
+    public static <E extends EntityType<E>, T> Builder<E, T> builder(final EntityType<E> entityType) {
+        return new Builder<>(entityType);
+    }
+
+    public static class Builder<E extends EntityType<E>, T>
+            extends AbstractEntityField.Builder<E, T, PrototypedEntityFieldImpl<E, T>, PrototypedEntityFieldImpl.Builder<E, T>> {
+
+        private EntityFieldPrototype<T> entityFieldPrototype;
+
+        public Builder(final EntityType<E> entityType) {
+            super(entityType);
+        }
+
+        protected PrototypedEntityFieldImpl.Builder<E, T> self() {
+            return this;
+        }
+
+        public Builder<E, T> withEntityFieldPrototype(final EntityFieldPrototype<T> entityFieldPrototype) {
+            this.entityFieldPrototype = entityFieldPrototype;
+            return this;
+        }
+
+        public PrototypedEntityFieldImpl<E, T> build() {
+            return new PrototypedEntityFieldImpl<>(
+                    entityType,
+                    entityFieldPrototype,
+                    dbAdapter,
+                    stringValueConverter,
+                    valueEqualityFunction,
+                    valueComparator
+            );
+        }
+    }
 }
diff --git a/main/src/main/java/com/kenshoo/pl/entity/internal/SecondaryTableRelationExtractor.java b/main/src/main/java/com/kenshoo/pl/entity/internal/SecondaryTableRelationExtractor.java
index d94c08f9..8c433c56 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/internal/SecondaryTableRelationExtractor.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/internal/SecondaryTableRelationExtractor.java
@@ -2,7 +2,9 @@
 
 import com.kenshoo.jooq.DataTable;
 import com.kenshoo.pl.entity.EntityField;
+import com.kenshoo.pl.entity.EntityFieldDbAdapter;
 import com.kenshoo.pl.entity.EntityType;
+import com.kenshoo.pl.entity.ValueConverter;
 import com.kenshoo.pl.entity.converters.IdentityValueConverter;
 import org.jooq.Record;
 import org.jooq.TableField;
@@ -54,7 +56,11 @@ class SecondaryTableRelationExtractor {
     private static <T, E extends EntityType<E>> EntityField<E, ?> createTemporaryEntityField(E entityType, TableField<Record, T> secondaryField, TableField<?, ?> primaryTableField) {
         var primaryField = entityType.findField(primaryTableField).get();
         var converter = IdentityValueConverter.getInstance(secondaryField.getType());
-        return new EntityFieldImpl(entityType, new SimpleEntityFieldDbAdapter<>(secondaryField, converter), primaryField.getStringValueConverter(), Objects::equals);
+        return EntityFieldImpl.builder(entityType)
+                .withDbAdapter((EntityFieldDbAdapter<Object>) new SimpleEntityFieldDbAdapter<>(secondaryField, converter))
+                .withStringValueConverter((ValueConverter<Object, String>) primaryField.getStringValueConverter())
+                .withValueEqualityFunction(Objects::equals)
+                .build();
     }
 
     static <E extends EntityType<E>> Stream<? extends EntityField<E, ?>> relationUsingTableFieldsOfPrimary(DataTable secondaryTable, E entityType) {
diff --git a/main/src/main/java/com/kenshoo/pl/entity/internal/VirtualEntityFieldImpl.java b/main/src/main/java/com/kenshoo/pl/entity/internal/VirtualEntityFieldImpl.java
index 9f8f009b..d794f525 100644
--- a/main/src/main/java/com/kenshoo/pl/entity/internal/VirtualEntityFieldImpl.java
+++ b/main/src/main/java/com/kenshoo/pl/entity/internal/VirtualEntityFieldImpl.java
@@ -5,13 +5,52 @@
 import com.kenshoo.pl.entity.ValueConverter;
 import com.kenshoo.pl.entity.equalityfunctions.EntityValueEqualityFunction;
 
-public class VirtualEntityFieldImpl<E extends EntityType<E>, T> extends EntityFieldImpl<E, T> {
-    public VirtualEntityFieldImpl(EntityType<E> entityType, EntityFieldDbAdapter<T> dbAdapter, ValueConverter<T, String> stringValueConverter, EntityValueEqualityFunction<T> valueEqualityFunction) {
-        super(entityType, dbAdapter, stringValueConverter, valueEqualityFunction);
+import java.util.Comparator;
+
+public class VirtualEntityFieldImpl<E extends EntityType<E>, T> extends
+        AbstractEntityField<E, T, VirtualEntityFieldImpl<E, T>, VirtualEntityFieldImpl.Builder<E, T>> {
+
+    private VirtualEntityFieldImpl(final EntityType<E> entityType,
+                                   final EntityFieldDbAdapter<T> dbAdapter,
+                                   final ValueConverter<T, String> stringValueConverter,
+                                   final EntityValueEqualityFunction<T> valueEqualityFunction,
+                                   final Comparator<T> valueComparator) {
+        super(entityType, dbAdapter, stringValueConverter, valueEqualityFunction, valueComparator);
     }
 
+
     @Override
     public boolean isVirtual() {
         return true;
     }
+
+    @Override
+    protected Builder<E, T> newBuilder(final EntityType<E> entityType) {
+        return new Builder<>(entityType);
+    }
+
+    public static <E extends EntityType<E>, T> Builder<E, T> builder(final EntityType<E> entityType) {
+        return new Builder<>(entityType);
+    }
+
+    public static class Builder<E extends EntityType<E>, T>
+            extends AbstractEntityField.Builder<E, T, VirtualEntityFieldImpl<E, T>, Builder<E, T>> {
+
+        public Builder(final EntityType<E> entityType) {
+            super(entityType);
+        }
+
+        protected Builder<E, T> self() {
+            return this;
+        }
+
+        public VirtualEntityFieldImpl<E, T> build() {
+            return new VirtualEntityFieldImpl<>(
+                    entityType,
+                    dbAdapter,
+                    stringValueConverter,
+                    valueEqualityFunction,
+                    valueComparator);
+        }
+    }
 }
diff --git a/main/src/test/java/com/kenshoo/pl/entity/TestEntity.java b/main/src/test/java/com/kenshoo/pl/entity/TestEntity.java
index 5c695695..8c2e615e 100644
--- a/main/src/test/java/com/kenshoo/pl/entity/TestEntity.java
+++ b/main/src/test/java/com/kenshoo/pl/entity/TestEntity.java
@@ -3,6 +3,13 @@
 import com.kenshoo.jooq.DataTable;
 import com.kenshoo.pl.entity.annotation.Id;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Comparator;
+
+import static java.math.RoundingMode.DOWN;
+import static java.util.Comparator.comparing;
+
 public class TestEntity extends AbstractEntityType<TestEntity> {
 
     public static final TestEntity INSTANCE = new TestEntity();
@@ -14,6 +21,9 @@ public class TestEntity extends AbstractEntityType<TestEntity> {
     public static final PrototypedEntityField<TestEntity, Integer> FIELD_3 = INSTANCE.prototypedField(TestDataFieldPrototype.FIELD_3, TestEntityTable.TABLE.field_3);
     public static final EntityField<TestEntity, String> SECONDARY_FIELD_1 = INSTANCE.field(SecondaryTable.TABLE.secondary_field_1);
 
+    public static final EntityField<TestEntity, BigDecimal> CUSTOM_COMPARABLE_FIELD =
+            INSTANCE.field(TestEntityTable.TABLE.field_4).comparedBy(comparing(n -> n.setScale(2, DOWN)));
+
     private TestEntity() {
         super("test");
     }
diff --git a/main/src/test/java/com/kenshoo/pl/entity/TestEntityTable.java b/main/src/test/java/com/kenshoo/pl/entity/TestEntityTable.java
index ec51d8e8..0db3e83b 100644
--- a/main/src/test/java/com/kenshoo/pl/entity/TestEntityTable.java
+++ b/main/src/test/java/com/kenshoo/pl/entity/TestEntityTable.java
@@ -5,6 +5,8 @@
 import org.jooq.TableField;
 import org.jooq.impl.SQLDataType;
 
+import java.math.BigDecimal;
+
 /**
  * Created by dimag on 13/01/2016.
  */
@@ -20,6 +22,7 @@ private TestEntityTable() {
     public final TableField<Record, String> field_1 = createField("field_1", SQLDataType.VARCHAR.length(10));
     public final TableField<Record, String> field_2 = createField("field_2", SQLDataType.VARCHAR.length(10));
     public final TableField<Record, Integer> field_3 = createField("field_3", SQLDataType.INTEGER);
+    public final TableField<Record, BigDecimal> field_4 = createField("field_4", SQLDataType.NUMERIC);
 
     @Override
     public TestEntityTable as(String alias) {