runtime-join: Cleanup and improved testing

speedment · Feb 20, 2018 · cd9bfe3 · cd9bfe3
1 parent 2839dd3
commit cd9bfe3
Show file tree

Hide file tree

Showing 13 changed files with 845 additions and 569 deletions.
diff --git a/...-join/src/main/java/com/speedment/runtime/join/internal/component/join/BaseAfterJoin.java b/...-join/src/main/java/com/speedment/runtime/join/internal/component/join/BaseAfterJoin.java
@@ -7,7 +7,7 @@
 
 import com.speedment.runtime.field.predicate.Inclusion;
 import com.speedment.runtime.field.trait.HasComparableOperators;
-import com.speedment.runtime.join.stage.OperatorType;
+import com.speedment.runtime.join.stage.JoinPredicateType;
 import com.speedment.runtime.join.trait.HasOnPredicates;
 import static java.util.Objects.requireNonNull;
 import java.util.function.BiFunction;
@@ -34,32 +34,32 @@ class BaseAfterJoin<T, R> implements HasOnPredicates<R> {
 
     @Override
     public R equal(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.EQUAL, joinedField);
+        return operation(JoinPredicateType.EQUAL, joinedField);
     }
 
     @Override
     public R notEqual(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.NOT_EQUAL, joinedField);
+        return operation(JoinPredicateType.NOT_EQUAL, joinedField);
     }
 
     @Override
     public R lessThan(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.LESS_THAN, joinedField);
+        return operation(JoinPredicateType.LESS_THAN, joinedField);
     }
 
     @Override
     public R lessOrEqual(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.LESS_OR_EQUAL, joinedField);
+        return operation(JoinPredicateType.LESS_OR_EQUAL, joinedField);
     }
 
     @Override
     public R greaterThan(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.GREATER_THAN, joinedField);
+        return operation(JoinPredicateType.GREATER_THAN, joinedField);
     }
 
     @Override
     public R greaterOrEqual(HasComparableOperators<?, ?> joinedField) {
-        return operation(OperatorType.GREATER_OR_EQUAL, joinedField);
+        return operation(JoinPredicateType.GREATER_OR_EQUAL, joinedField);
     }
 
     @Override
@@ -69,7 +69,7 @@ public <ENTITY> R between(HasComparableOperators<ENTITY, ?> joinedFieldFrom, Has
 
     @Override
     public <ENTITY> R between(HasComparableOperators<ENTITY, ?> joinedFieldFrom, HasComparableOperators<ENTITY, ?> joinedFieldTo, Inclusion inclusion) {
-        return operation(OperatorType.BETWEEN, joinedFieldFrom, joinedFieldTo, inclusion);
+        return operation(JoinPredicateType.BETWEEN, joinedFieldFrom, joinedFieldTo, inclusion);
     }
 
     @Override
@@ -79,22 +79,22 @@ public <ENTITY> R notBetween(HasComparableOperators<ENTITY, ?> joinedFieldFrom,
 
     @Override
     public <ENTITY> R notBetween(HasComparableOperators<ENTITY, ?> joinedFieldFrom, HasComparableOperators<ENTITY, ?> joinedFieldTo, Inclusion inclusion) {
-        return operation(OperatorType.NOT_BETWEEN, joinedFieldFrom, joinedFieldTo, inclusion);
+        return operation(JoinPredicateType.NOT_BETWEEN, joinedFieldFrom, joinedFieldTo, inclusion);
     }
 
-    private R operation(OperatorType operatorType, HasComparableOperators<?, ?> joinedField) {
+    private R operation(JoinPredicateType operatorType, HasComparableOperators<?, ?> joinedField) {
-        stageBean.setOperatorType(operatorType);
+        stageBean.setJoinPredicateType(operatorType);
         stageBean.setForeignFirstField(joinedField);
         return constructor.apply(currentBuilderStage, stageBean);
     }
 
     private <ENTITY> R operation(
-        final OperatorType operatorType,
+        final JoinPredicateType operatorType,
         final HasComparableOperators<ENTITY, ?> joinedFieldFrom,
         final HasComparableOperators<ENTITY, ?> joinedFieldTo,
         final Inclusion inclusion
     ) {
-        stageBean.setOperatorType(operatorType);
+        stageBean.setJoinPredicateType(operatorType);
         stageBean.setForeignFirstField(joinedFieldFrom);
         stageBean.setForeignSecondField(joinedFieldTo);
         stageBean.setForeignInclusion(inclusion);

diff --git a/...time-join/src/main/java/com/speedment/runtime/join/internal/component/join/StageBean.java b/...time-join/src/main/java/com/speedment/runtime/join/internal/component/join/StageBean.java
@@ -1,6 +1,6 @@
 package com.speedment.runtime.join.internal.component.join;
 
-import com.speedment.runtime.join.stage.OperatorType;
+import com.speedment.runtime.join.stage.JoinPredicateType;
 import com.speedment.runtime.join.stage.JoinType;
 import com.speedment.runtime.config.identifier.TableIdentifier;
 import com.speedment.runtime.field.predicate.Inclusion;
@@ -23,10 +23,10 @@ public final class StageBean<T> {
     private final TableIdentifier<T> identifier;
     private final List<Predicate<? super T>> predicates;
     private JoinType joinType;
-    private HasComparableOperators<? extends T, ?> field;
+    private HasComparableOperators<T, ?> field;
-    private OperatorType operatorType;
+    private JoinPredicateType joinPredicateType;
-    private HasComparableOperators<?, ?> firstForeignField;
+    private HasComparableOperators<?, ?> foreignFirstField;
-    private HasComparableOperators<?, ?> secondForeignField;
+    private HasComparableOperators<?, ?> foreignSecondField;
     private Inclusion foreignInclusion;
 
     public StageBean(TableIdentifier<T> identifier) {
@@ -60,32 +60,32 @@ public void setJoinType(JoinType joinType) {
         return field;
     }
 
-    public void setField(HasComparableOperators<? extends T, ?> field) {
+    public void setField(HasComparableOperators<T, ?> field) {
         this.field = requireNonNull(field);
     }
 
-    public OperatorType getOperatorType() {
+    public JoinPredicateType getJoinPredicateType() {
-        return operatorType;
+        return joinPredicateType;
     }
 
-    public void setOperatorType(OperatorType operatorType) {
+    public void setJoinPredicateType(JoinPredicateType joinPredicateType) {
-        this.operatorType = requireNonNull(operatorType);
+        this.joinPredicateType = requireNonNull(joinPredicateType);
     }
 
     public HasComparableOperators<?, ?> getForeignFirstField() {
-        return firstForeignField;
+        return foreignFirstField;
     }
 
-    public void setForeignFirstField(HasComparableOperators<?, ?> firstTableField) {
+    public void setForeignFirstField(HasComparableOperators<?, ?> foreignFirstField) {
-        this.firstForeignField = requireNonNull(firstTableField);
+        this.foreignFirstField = requireNonNull(foreignFirstField);
     }
 
     public HasComparableOperators<?, ?> getForeignSecondField() {
-        return secondForeignField;
+        return foreignSecondField;
     }
 
-    public void setForeignSecondField(HasComparableOperators<?, ?> secondTableField) {
+    public void setForeignSecondField(HasComparableOperators<?, ?> foreignSecondField) {
-        this.secondForeignField = requireNonNull(secondTableField);
+        this.foreignSecondField = requireNonNull(foreignSecondField);
     }
 
     public TableIdentifier<T> getIdentifier() {
@@ -115,9 +115,9 @@ public Stage<T> asStage() {
             predicates,
             joinType,
             field,
-            operatorType,
+            joinPredicateType,
-            firstForeignField,
+            foreignFirstField,
-            secondForeignField,
+            foreignSecondField,
             foreignInclusion
         );
     }

diff --git a/...eam/DebugJoinStreamSupplierComponent.java → ...xhaustiveJoinStreamSupplierComponent.java b/...eam/DebugJoinStreamSupplierComponent.java → ...xhaustiveJoinStreamSupplierComponent.java
@@ -10,18 +10,18 @@
 import com.speedment.runtime.join.Join;
 import com.speedment.runtime.join.JoinStreamSupplierComponent;
 import com.speedment.runtime.join.internal.component.stream.exhaustive.ExhaustiveHasCreateJoin2;
-import static java.util.Objects.requireNonNull;
-import java.util.function.BiFunction;
-import java.util.stream.Stream;
 import com.speedment.runtime.join.stage.Stage;
 import com.speedment.runtime.join.trait.HasCreateJoin2;
 import java.util.List;
+import static java.util.Objects.requireNonNull;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
 
 /**
  *
  * @author Per Minborg
  */
-public class DebugJoinStreamSupplierComponent implements JoinStreamSupplierComponent {
+public class ExhaustiveJoinStreamSupplierComponent implements JoinStreamSupplierComponent {
 
     private HasCreateJoin2 join2Creator;
 
@@ -32,57 +32,57 @@ void init(StreamSupplierComponent streamSupplier) {
 
     @Override
     public <T1, T2, T> Join<T> createJoin(
-        final List<Stage<?>> p,
+        final List<Stage<?>> stages,
         final BiFunction<T1, T2, T> constructor,
         final TableIdentifier<T1> t1,
         final TableIdentifier<T2> t2
     ) {
-        return join2Creator.createJoin(p, constructor, t1, t2);
+        return join2Creator.createJoin(stages, constructor, t1, t2);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public <T1, T2, T3, T> Join<T> createJoin(
-        final List<Stage<?>> p,
+        final List<Stage<?>> stages,
         final TriFunction<T1, T2, T3, T> constructor,
         final TableIdentifier<T1> t1,
         final TableIdentifier<T2> t2,
         final TableIdentifier<T3> t3
     ) {
-        return (Join<T>) emptyJoin(p, constructor, t1, t2, t3);
+        return (Join<T>) emptyJoin(stages, constructor, t1, t2, t3);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public <T1, T2, T3, T4, T> Join<T> createJoin(
-        final List<Stage<?>> p,
+        final List<Stage<?>> stages,
         final QuadFunction<T1, T2, T3, T4, T> constructor,
         final TableIdentifier<T1> t1,
         final TableIdentifier<T2> t2,
         final TableIdentifier<T3> t3,
         final TableIdentifier<T4> t4
     ) {
-        return (Join<T>) emptyJoin(p, constructor, t1, t2, t3, t4);
+        return (Join<T>) emptyJoin(stages, constructor, t1, t2, t3, t4);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public <T1, T2, T3, T4, T5, T> Join<T> createJoin(
-        final List<Stage<?>> p,
+        final List<Stage<?>> stages,
         final Function5<T1, T2, T3, T4, T5, T> constructor,
         final TableIdentifier<T1> t1,
         final TableIdentifier<T2> t2,
         final TableIdentifier<T3> t3,
         final TableIdentifier<T4> t4,
         final TableIdentifier<T5> t5
     ) {
-        return (Join<T>) emptyJoin(p, constructor, t1, t2, t3, t4, t5);
+        return (Join<T>) emptyJoin(stages, constructor, t1, t2, t3, t4, t5);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public <T1, T2, T3, T4, T5, T6, T> Join<T> createJoin(
-        final List<Stage<?>> p,
+        final List<Stage<?>> stages,
         final Function6<T1, T2, T3, T4, T5, T6, T> constructor,
         final TableIdentifier<T1> t1,
         final TableIdentifier<T2> t2,
@@ -91,7 +91,7 @@ public <T1, T2, T3, T4, T5, T6, T> Join<T> createJoin(
         final TableIdentifier<T5> t5,
         final TableIdentifier<T6> t6
     ) {
-        return (Join<T>) emptyJoin(p, constructor, t1, t2, t3, t4, t5, t6);
+        return (Join<T>) emptyJoin(stages, constructor, t1, t2, t3, t4, t5, t6);
     }
 
     private Join<?> emptyJoin(List<Stage<?>> p, Object unusedConstructor, TableIdentifier<?>... unusedIdentifiers) {
@@ -109,27 +109,6 @@ private void printPipeline(List<Stage<?>> p) {
             .forEachOrdered(System.out::println);
     }
 
-    private class ExhaustiveJoin2<T1, T2, T> implements Join<T> {
-
-        final List<Stage<?>> p;
-        final BiFunction<T1, T2, T> constructor;
-        final TableIdentifier<T1> t1;
-        final TableIdentifier<T2> t2;
-
-        ExhaustiveJoin2(List<Stage<?>> p, BiFunction<T1, T2, T> constructor, TableIdentifier<T1> t1, TableIdentifier<T2> t2) {
-            this.p = requireNonNull(p);
-            this.constructor = requireNonNull(constructor);
-            this.t1 = requireNonNull(t1);
-            this.t2 = requireNonNull(t2);
-        }
-
-        @Override
-        public Stream<T> stream() {
-            return Stream.empty();
-        }
-
-    }
-
     private class EmptyJoin<T> implements Join<T> {
 
         @Override
@@ -138,5 +117,4 @@ public Stream<T> stream() {
         }
 
     }
-
 }