From d509976322e0bdc44bb57ef8ef719150c30522c2 Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Thu, 3 Jun 2021 10:27:00 +0200
Subject: [PATCH 1/6] Remove now unused code

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../core/extendedrequest/TableAndJoins.java   | 35 -------------------
 1 file changed, 35 deletions(-)

diff --git a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
index 7e495ec..77828a9 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
@@ -41,41 +41,6 @@ public JoinDescriptor getJoinDescriptor(String aliasId) {
         return joins.get(aliasId);
     }
 
-    private static void applyJoinToStringBuilder(StringBuilder sb, JoinDescriptor descriptor) {
-        Column lhs = descriptor.getLHSColumn();
-        Column rhs = descriptor.getRHSColumn();
-        Table table = descriptor.getRHSTable();
-        String joinLine = table.toString() + " ON " + lhs.toString() + "=" + rhs.toString();
-        switch (descriptor.getJoinType()) {
-            case JOIN:
-                sb.append(" JOIN ");
-                break;
-            case LEFT_OUTER_JOIN:
-                sb.append(" LEFT JOIN ");
-                break;
-            case RIGHT_OUTER_JOIN:
-                throw new UnsupportedOperationException("Rewrite to use LEFT JOIN instead");
-            default:
-                throw new UnsupportedOperationException("Unsupported join type: " + descriptor.getJoinType());
-        }
-        sb.append(joinLine);
-    }
-
-    protected void generateFromAndJoins(StringBuilder sb, Set<String> selectedJoinAliases) {
-        int selectedJoins = 0;
-        sb.append(" FROM ");
-        sb.append(primaryTable.toString());
-        for (JoinDescriptor joinDescriptor : joins.values()) {
-            if (selectedJoinAliases.contains(joinDescriptor.getJoinAliasId())) {
-                applyJoinToStringBuilder(sb, joinDescriptor);
-                selectedJoins++;
-            }
-        }
-        if (selectedJoinAliases.size() != selectedJoins) {
-            throw new IllegalArgumentException("selectedJoinAliases contained an unknown alias");
-        }
-    }
-
     public boolean hasJoins() {
         return !joins.isEmpty();
     }

From 59b10da7526479292c54f5c7d7add18aca5ca607 Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Thu, 3 Jun 2021 10:22:25 +0200
Subject: [PATCH 2/6] Refactor ExtendedRequest initialization

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../org/dcsa/core/controller/ExtendedBaseController.java  | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/dcsa/core/controller/ExtendedBaseController.java b/src/main/java/org/dcsa/core/controller/ExtendedBaseController.java
index 7969bc3..c646e4b 100644
--- a/src/main/java/org/dcsa/core/controller/ExtendedBaseController.java
+++ b/src/main/java/org/dcsa/core/controller/ExtendedBaseController.java
@@ -24,9 +24,13 @@ public String getType() {
         return getService().getModelClass().getSimpleName();
     }
 
-    @GetMapping()
+    protected ExtendedRequest<T> newExtendedRequest() {
+        return new ExtendedRequest<>(extendedParameters, r2dbcDialect, getService().getModelClass());
+    }
+
+    @GetMapping
     public Flux<T> findAll(ServerHttpResponse response, ServerHttpRequest request) {
-        ExtendedRequest<T> extendedRequest = new ExtendedRequest<>(extendedParameters, r2dbcDialect, getService().getModelClass());
+        ExtendedRequest<T> extendedRequest = newExtendedRequest();
         try {
             extendedRequest.parseParameter(request.getQueryParams());
         } catch (GetException getException) {

From a51c0c60a974887d943c16f91329511a36d7fc96 Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Tue, 1 Jun 2021 12:19:22 +0200
Subject: [PATCH 3/6] Refactor query generation

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../core/extendedrequest/ExtendedRequest.java | 122 +++++++-----------
 .../core/extendedrequest/TableAndJoins.java   |   8 ++
 .../org/dcsa/core/query/DBEntityAnalysis.java |   1 +
 .../core/query/impl/AbstractQueryFactory.java |  66 ++++++++++
 .../query/impl/DefaultDBEntityAnalysis.java   |   2 +
 .../impl/DefaultDBEntityAnalysisBuilder.java  |   1 +
 .../org/dcsa/core/ExtendedRequestTest.java    |   2 +-
 7 files changed, 123 insertions(+), 79 deletions(-)
 create mode 100644 src/main/java/org/dcsa/core/query/impl/AbstractQueryFactory.java

diff --git a/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java b/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
index a4aefc5..ae10320 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
@@ -1,33 +1,27 @@
 package org.dcsa.core.extendedrequest;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import io.r2dbc.spi.Row;
-import io.r2dbc.spi.RowMetadata;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.dcsa.core.exception.GetException;
 import org.dcsa.core.query.DBEntityAnalysis;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
+import org.dcsa.core.query.impl.PreparedQuery;
 import org.springframework.data.r2dbc.dialect.R2dbcDialect;
 import org.springframework.data.relational.core.dialect.RenderContextFactory;
 import org.springframework.data.relational.core.sql.*;
-import org.springframework.data.relational.core.sql.render.RenderContext;
-import org.springframework.data.relational.core.sql.render.SqlRenderer;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.http.server.reactive.ServerHttpResponse;
 import org.springframework.r2dbc.core.DatabaseClient;
 import org.springframework.r2dbc.core.PreparedOperation;
-import org.springframework.r2dbc.core.binding.BindTarget;
-import org.springframework.r2dbc.core.binding.Bindings;
 
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.spec.SecretKeySpec;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 import java.nio.charset.StandardCharsets;
 import java.security.InvalidKeyException;
 import java.security.Key;
@@ -51,7 +45,7 @@
  *  * object.
  */
 @RequiredArgsConstructor
-public class ExtendedRequest<T> {
+public class ExtendedRequest<T> extends AbstractQueryFactory<T> {
 
     public static final String PARAMETER_SPLIT = "&";
     public static final String CURSOR_SPLIT = "=";
@@ -124,6 +118,20 @@ public void parseParameter(Map<String, List<String>> params, boolean fromCursor)
         finishedParsingParameters();
     }
 
+    protected CursorBackedFilterCondition getFilterCondition() {
+        return filterCondition;
+    }
+
+    @Override
+    protected Set<String> getJoinAliasInUse() {
+        return joinAliasInUse;
+    }
+
+    @Override
+    protected SelectBuilder.SelectFromAndJoin applyLimitOffset(SelectBuilder.SelectFromAndJoin t) {
+        return getPagination().applyLimitOffset(t);
+    }
+
     // For sub-classes to hook into this
     protected void finishedParsingParameters() {
         filterCondition = getQueryParameterParser().build();
@@ -214,65 +222,44 @@ private static Map<String, List<String>> convertToQueryStringToHashMap(String so
     }
 
     public DatabaseClient.GenericExecuteSpec getCount(DatabaseClient databaseClient) {
-        return databaseClient.sql(this.getCountQuery());
+        return databaseClient.sql(this.generateCountQuery());
     }
 
     public DatabaseClient.GenericExecuteSpec getFindAll(DatabaseClient databaseClient) {
-        return databaseClient.sql(this.getQuery());
-    }
-
-    public Select getSelectQuery() {
-        List<Expression> expressions = dbEntityAnalysis.getAllSelectableFields().stream().map(queryField -> {
-            markQueryFieldInUse(queryField);
-            return queryField.getSelectColumn();
-        }).collect(Collectors.toList());
-        Sort<T> sort = getSort();
-
-        return generateBaseQuery(Select.builder().select(expressions))
-                .orderBy(sort.getOrderByFields()).build();
+        return databaseClient.sql(this.generateSelectQuery());
     }
 
-    public Select getSelectCountQuery() {
-        return generateBaseQuery(Select.builder().select(
-                Functions.count(Expressions.asterisk()).as("count")
-        )).build();
+    protected SelectBuilder.BuildSelect applyOrder(SelectBuilder.SelectOrdered builder) {
+        return builder.orderBy(getSort().getOrderByFields());
     }
 
+    @Override
     protected SelectBuilder.SelectOrdered generateBaseQuery(SelectBuilder.SelectAndFrom selectBuilder) {
         if (filterCondition == null) {
             finishedParsingParameters();
         }
-        Pagination<T> pagination = getPagination();
-        if (selectDistinct) {
-            selectBuilder = selectBuilder.distinct();
-        }
-        SelectBuilder.SelectWhere selectWhere = applyJoins(pagination.applyLimitOffset(selectBuilder.from(
-                dbEntityAnalysis.getTableAndJoins().getPrimaryTable()
-        )));
-        Condition con = filterCondition.computeCondition(r2dbcDialect);
-        if (TrueCondition.INSTANCE.equals(con)) {
-            return selectWhere;
-        }
-        return selectWhere.where(con);
+        return super.generateBaseQuery(selectBuilder);
     }
 
-    public void setQueryCount(Integer count) {
-        getPagination().setTotal(count);
+    @Override
+    protected Condition generateCondition() {
+        return getFilterCondition().computeCondition(r2dbcDialect);
     }
 
-    protected SelectBuilder.SelectWhere applyJoins(SelectBuilder.SelectFromAndJoin selectBuilder) {
-        if (!joinAliasInUse.isEmpty()) {
-            return dbEntityAnalysis.getTableAndJoins().applyJoins(selectBuilder, joinAliasInUse);
-        }
-        return selectBuilder;
+    public void setQueryCount(Integer count) {
+        getPagination().setTotal(count);
     }
 
-    public PreparedOperation<Select> getCountQuery() {
+    public PreparedOperation<Select> generateCountQuery() {
         if (filterCondition == null) {
             finishedParsingParameters();
         }
+        return super.generateCountQuery();
+    }
+
+    protected PreparedQuery createPreparedOperation(Select select) {
         RenderContextFactory factory = new RenderContextFactory(r2dbcDialect);
-        return PreparedQuery.of(getSelectCountQuery(), factory.createRenderContext(), filterCondition.getBindings());
+        return PreparedQuery.of(select, factory.createRenderContext(), filterCondition.getBindings());
     }
 
     /**
@@ -319,13 +306,20 @@ protected DBEntityAnalysis.DBEntityAnalysisBuilder<T> prepareDBEntityAnalysis()
         return DBEntityAnalysis.builder(this.modelClass).loadFieldsAndJoinsFromModel();
     }
 
-    public PreparedOperation<Select> getQuery() {
+    public PreparedOperation<Select> generateSelectQuery() {
+        List<Expression> expressions = dbEntityAnalysis.getAllSelectableFields().stream().map(queryField -> {
+            markQueryFieldInUse(queryField);
+            return queryField.getSelectColumn();
+        }).collect(Collectors.toList());
+        return this.generateSelectQuery(expressions);
+    }
+
+    protected PreparedOperation<Select> generateSelectQuery(List<Expression> expressions) {
         if (filterCondition == null) {
             finishedParsingParameters();
             assert filterCondition != null;
         }
-        RenderContextFactory factory = new RenderContextFactory(r2dbcDialect);
-        return PreparedQuery.of(getSelectQuery(), factory.createRenderContext(), filterCondition.getBindings());
+        return super.generateSelectQuery(expressions);
     }
 
     public boolean ignoreUnknownProperties() {
@@ -333,15 +327,6 @@ public boolean ignoreUnknownProperties() {
         return jsonIgnoreProperties != null && jsonIgnoreProperties.ignoreUnknown();
     }
 
-    public T getModelClassInstance(Row row, RowMetadata meta) {
-        try {
-            Constructor<T> constructor = modelClass.getDeclaredConstructor();
-            return constructor.newInstance();
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            throw new GetException("Error when creating a new instance of: " + modelClass.getSimpleName());
-        }
-    }
-
     /*
      * DO NOT USE THIS CIPHER FOR ANYTHING IMPORTANT (we are not in asseco-reactive-api-code)
      * -> Reason: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Electronic_codebook_(ECB)
@@ -454,23 +439,4 @@ private String getHeaderPageCursor(Pagination.PageRequest page) {
         return getExtendedParameters().getPaginationCursorName() + CURSOR_SPLIT + Base64.getUrlEncoder().encodeToString(parameters);
     }
 
-    @RequiredArgsConstructor(staticName = "of")
-    private static class PreparedQuery implements PreparedOperation<Select> {
-
-        @Getter
-        private final Select source;
-        private final RenderContext renderContext;
-        private final Bindings bindings;
-
-        @Override
-        public void bindTo(BindTarget target) {
-            bindings.apply(target);
-        }
-
-        @Override
-        public String toQuery() {
-            SqlRenderer sqlRenderer = SqlRenderer.create(this.renderContext);
-            return sqlRenderer.render(source);
-        }
-    }
 }
diff --git a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
index 77828a9..80250bf 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
@@ -7,6 +7,7 @@
 import org.springframework.data.relational.core.sql.SelectBuilder;
 import org.springframework.data.relational.core.sql.Table;
 
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Set;
@@ -45,6 +46,13 @@ public boolean hasJoins() {
         return !joins.isEmpty();
     }
 
+    public Set<String> getAvailableJoinAliases(boolean includePrimary) {
+        if (includePrimary) {
+            return Collections.unmodifiableSet(knownAliases);
+        }
+        return Collections.unmodifiableSet(joins.keySet());
+    }
+
     public SelectBuilder.SelectFromAndJoinCondition applyJoins(SelectBuilder.SelectFromAndJoin selectFromAndJoin, Set<String> selectedJoinAliases) {
         SelectBuilder.SelectJoin current = selectFromAndJoin;
         int selectedJoins = 0;
diff --git a/src/main/java/org/dcsa/core/query/DBEntityAnalysis.java b/src/main/java/org/dcsa/core/query/DBEntityAnalysis.java
index 969cdfe..c254305 100644
--- a/src/main/java/org/dcsa/core/query/DBEntityAnalysis.java
+++ b/src/main/java/org/dcsa/core/query/DBEntityAnalysis.java
@@ -18,6 +18,7 @@ public interface DBEntityAnalysis<T> {
     QueryField getQueryFieldFromSelectName(String selectColumnName) throws IllegalArgumentException;
     List<QueryField> getAllSelectableFields();
     TableAndJoins getTableAndJoins();
+    Class<T> getEntityType();
 
     static <T> DBEntityAnalysisBuilder<T> builder(Class<T> entityType) {
         return new DefaultDBEntityAnalysisBuilder<>(entityType);
diff --git a/src/main/java/org/dcsa/core/query/impl/AbstractQueryFactory.java b/src/main/java/org/dcsa/core/query/impl/AbstractQueryFactory.java
new file mode 100644
index 0000000..2fedc04
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/AbstractQueryFactory.java
@@ -0,0 +1,66 @@
+package org.dcsa.core.query.impl;
+
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.extendedrequest.TableAndJoins;
+import org.dcsa.core.query.DBEntityAnalysis;
+import org.springframework.data.relational.core.sql.*;
+import org.springframework.r2dbc.core.PreparedOperation;
+
+import java.util.List;
+import java.util.Set;
+
+@RequiredArgsConstructor
+public abstract class AbstractQueryFactory<T> {
+
+    public abstract DBEntityAnalysis<T> getDbEntityAnalysis();
+
+    protected abstract Set<String> getJoinAliasInUse();
+
+    protected abstract boolean isSelectDistinct();
+
+    protected abstract SelectBuilder.SelectFromAndJoin applyLimitOffset(SelectBuilder.SelectFromAndJoin t);
+
+    protected SelectBuilder.SelectOrdered generateBaseQuery(SelectBuilder.SelectAndFrom selectBuilder) {
+        DBEntityAnalysis<T> dbEntityAnalysis = getDbEntityAnalysis();
+        TableAndJoins tableAndJoins = dbEntityAnalysis.getTableAndJoins();
+        // Run this before the call to applyJoins(...) as it can affect which joins will be used.
+        Condition con = generateCondition();
+
+        if (isSelectDistinct()) {
+            selectBuilder = selectBuilder.distinct();
+        }
+        SelectBuilder.SelectWhere selectWhere = applyJoins(tableAndJoins, applyLimitOffset(selectBuilder.from(
+                tableAndJoins.getPrimaryTable()
+        )));
+        if (con == null || TrueCondition.INSTANCE.equals(con)) {
+            return selectWhere;
+        }
+        return selectWhere.where(con);
+    }
+
+    protected abstract Condition generateCondition();
+
+    protected abstract SelectBuilder.BuildSelect applyOrder(SelectBuilder.SelectOrdered builder);
+
+    public abstract PreparedOperation<Select> generateSelectQuery();
+
+    protected PreparedOperation<Select> generateSelectQuery(List<Expression> expressions) {
+        return createPreparedOperation(applyOrder(generateBaseQuery(Select.builder().select(expressions))).build());
+    }
+
+    public PreparedOperation<Select> generateCountQuery() {
+        return createPreparedOperation(generateBaseQuery(Select.builder().select(
+                Functions.count(Expressions.asterisk()).as("count")
+        )).build());
+    }
+
+    protected abstract PreparedOperation<Select> createPreparedOperation(Select select);
+
+    private SelectBuilder.SelectWhere applyJoins(TableAndJoins tableAndJoins, SelectBuilder.SelectFromAndJoin selectBuilder) {
+        Set<String> joinAliasInUse = getJoinAliasInUse();
+        if (!joinAliasInUse.isEmpty()) {
+            return tableAndJoins.applyJoins(selectBuilder, joinAliasInUse);
+        }
+        return selectBuilder;
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
index dac3a59..40b6866 100644
--- a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
+++ b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
@@ -13,6 +13,8 @@
 @RequiredArgsConstructor
 public class DefaultDBEntityAnalysis<T> implements DBEntityAnalysis<T> {
 
+    @Getter
+    private final Class<T> entityType;
     private final Map<String, QueryField> jsonName2QueryField;
     private final Map<String, QueryField> selectName2QueryField;
     private final Set<String> declaredButNotSelectable;
diff --git a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
index 135748c..6007561 100644
--- a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
+++ b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
@@ -569,6 +569,7 @@ public DBEntityAnalysis<T> build() {
         this.verifyFieldsAndJoins();
         used = true;
         return new DefaultDBEntityAnalysis<>(
+                entityType,
                 Collections.unmodifiableMap(jsonName2DbField),
                 Collections.unmodifiableMap(selectName2DbField),
                 Collections.unmodifiableSet(declaredButNotSelectable),
diff --git a/src/test/java/org/dcsa/core/ExtendedRequestTest.java b/src/test/java/org/dcsa/core/ExtendedRequestTest.java
index 6365349..b8fb4f6 100644
--- a/src/test/java/org/dcsa/core/ExtendedRequestTest.java
+++ b/src/test/java/org/dcsa/core/ExtendedRequestTest.java
@@ -206,7 +206,7 @@ public void verify(String query, Consumer<ExtendedRequest<T>> requestMutator) {
             if (requestMutator != null) {
                 requestMutator.accept(request);
             }
-            generated = request.getQuery().toQuery();
+            generated = request.generateSelectQuery().toQuery();
             Assertions.assertEquals(prettifyQuery(query), prettifyQuery(generated));
         }
 

From d77e24fe7afc4951076a8c29c18f812f859f203f Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Thu, 3 Jun 2021 13:42:26 +0200
Subject: [PATCH 4/6] Joins: Forgive primary table being present in apply joins

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../java/org/dcsa/core/extendedrequest/TableAndJoins.java | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
index 80250bf..25830a9 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/TableAndJoins.java
@@ -21,10 +21,12 @@ public class TableAndJoins {
     private final Table primaryTable;
     private final Set<String> knownAliases = new HashSet<>();
     private final LinkedHashMap<String, JoinDescriptor> joins = new LinkedHashMap<>();
+    private final String primaryTableAlias;
 
     public TableAndJoins(Table primaryTable) {
         this.primaryTable = primaryTable;
-        knownAliases.add(ReflectUtility.getAliasId(primaryTable));
+        primaryTableAlias = ReflectUtility.getAliasId(primaryTable);
+        knownAliases.add(primaryTableAlias);
     }
 
     public void addJoinDescriptor(JoinDescriptor joinDescriptor) {
@@ -65,6 +67,10 @@ public SelectBuilder.SelectFromAndJoinCondition applyJoins(SelectBuilder.SelectF
                 selectedJoins++;
             }
         }
+        // "Forgive" if the primary table is included as well.
+        if (selectedJoinAliases.contains(primaryTableAlias)) {
+            selectedJoins++;
+        }
         if (selectedJoinAliases.size() != selectedJoins) {
             throw new IllegalArgumentException("selectedJoinAliases contained an unknown alias");
         }

From 96815db3b8f0b1e1ba4cd3e229ab7466c2662ce0 Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Thu, 3 Jun 2021 14:09:35 +0200
Subject: [PATCH 5/6] Alternative method to create custom queries

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../core/extendedrequest/ExtendedRequest.java |   8 --
 .../dcsa/core/query/QueryFactoryBuilder.java  |  23 ++++
 .../core/query/impl/GenericQueryFactory.java  |  68 +++++++++++
 .../dcsa/core/query/impl/PreparedQuery.java   |  30 +++++
 .../query/impl/QueryFactoryBuilderImpl.java   | 108 ++++++++++++++++++
 .../core/repository/ExtendedRepository.java   |   4 +
 .../repository/ExtendedRepositoryImpl.java    |  27 ++++-
 7 files changed, 255 insertions(+), 13 deletions(-)
 create mode 100644 src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/GenericQueryFactory.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/PreparedQuery.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java

diff --git a/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java b/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
index ae10320..000535d 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/ExtendedRequest.java
@@ -221,14 +221,6 @@ private static Map<String, List<String>> convertToQueryStringToHashMap(String so
         return data;
     }
 
-    public DatabaseClient.GenericExecuteSpec getCount(DatabaseClient databaseClient) {
-        return databaseClient.sql(this.generateCountQuery());
-    }
-
-    public DatabaseClient.GenericExecuteSpec getFindAll(DatabaseClient databaseClient) {
-        return databaseClient.sql(this.generateSelectQuery());
-    }
-
     protected SelectBuilder.BuildSelect applyOrder(SelectBuilder.SelectOrdered builder) {
         return builder.orderBy(getSort().getOrderByFields());
     }
diff --git a/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java b/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
new file mode 100644
index 0000000..ee25e0c
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
@@ -0,0 +1,23 @@
+package org.dcsa.core.query;
+
+import org.dcsa.core.extendedrequest.CursorBackedFilterCondition;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
+import org.dcsa.core.query.impl.QueryFactoryBuilderImpl;
+import org.springframework.data.r2dbc.dialect.R2dbcDialect;
+import org.springframework.data.relational.core.sql.SelectBuilder;
+
+import java.util.function.Function;
+
+public interface QueryFactoryBuilder<T> {
+
+    QueryFactoryBuilder<T> distinct();
+    QueryFactoryBuilder<T> limitOffset(Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffsetFunction);
+    QueryFactoryBuilder<T> order(Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> orderFunction);
+    QueryFactoryBuilder<T> r2dbcDialect(R2dbcDialect r2dbcDialect);
+    QueryFactoryBuilder<T> copyBuilder();
+    AbstractQueryFactory<T> build(CursorBackedFilterCondition filterCondition);
+
+    static <T> QueryFactoryBuilder<T> builder(DBEntityAnalysis<T> dbEntityAnalysis) {
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, false, null, null, null);
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/GenericQueryFactory.java b/src/main/java/org/dcsa/core/query/impl/GenericQueryFactory.java
new file mode 100644
index 0000000..f6941b4
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/GenericQueryFactory.java
@@ -0,0 +1,68 @@
+package org.dcsa.core.query.impl;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.query.DBEntityAnalysis;
+import org.springframework.data.relational.core.dialect.RenderContextFactory;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Expression;
+import org.springframework.data.relational.core.sql.Select;
+import org.springframework.data.relational.core.sql.SelectBuilder;
+import org.springframework.r2dbc.core.PreparedOperation;
+import org.springframework.r2dbc.core.binding.Bindings;
+
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+
+@RequiredArgsConstructor(staticName = "of")
+class GenericQueryFactory<T> extends AbstractQueryFactory<T> {
+
+    @Getter
+    private final DBEntityAnalysis<T> dbEntityAnalysis;
+
+    @Getter
+    private final boolean selectDistinct;
+
+    private final Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffsets;
+    private final Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> order;
+    @Getter
+    private final Set<String> joinAliasInUse;
+    private final Condition conditions;
+    private final List<Expression> selectExpressions;
+
+    private final RenderContextFactory renderContextFactory;
+    private final Bindings bindings;
+
+
+    @Override
+    public PreparedOperation<Select> generateSelectQuery() {
+        return generateSelectQuery(selectExpressions);
+    }
+
+    @Override
+    protected PreparedOperation<Select> createPreparedOperation(Select select) {
+        return PreparedQuery.of(select, renderContextFactory.createRenderContext(), bindings);
+    }
+
+    @Override
+    protected Condition generateCondition() {
+        return conditions;
+    }
+
+    @Override
+    protected SelectBuilder.SelectFromAndJoin applyLimitOffset(SelectBuilder.SelectFromAndJoin builder) {
+        if (limitOffsets != null) {
+            return limitOffsets.apply(builder);
+        }
+        return builder;
+    }
+
+    @Override
+    protected SelectBuilder.BuildSelect applyOrder(SelectBuilder.SelectOrdered builder) {
+        if (order != null) {
+            return order.apply(builder);
+        }
+        return builder;
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/PreparedQuery.java b/src/main/java/org/dcsa/core/query/impl/PreparedQuery.java
new file mode 100644
index 0000000..865f042
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/PreparedQuery.java
@@ -0,0 +1,30 @@
+package org.dcsa.core.query.impl;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.relational.core.sql.Select;
+import org.springframework.data.relational.core.sql.render.RenderContext;
+import org.springframework.data.relational.core.sql.render.SqlRenderer;
+import org.springframework.r2dbc.core.PreparedOperation;
+import org.springframework.r2dbc.core.binding.BindTarget;
+import org.springframework.r2dbc.core.binding.Bindings;
+
+@RequiredArgsConstructor(staticName = "of")
+public class PreparedQuery implements PreparedOperation<Select> {
+
+    @Getter
+    private final Select source;
+    private final RenderContext renderContext;
+    private final Bindings bindings;
+
+    @Override
+    public void bindTo(BindTarget target) {
+        bindings.apply(target);
+    }
+
+    @Override
+    public String toQuery() {
+        SqlRenderer sqlRenderer = SqlRenderer.create(this.renderContext);
+        return sqlRenderer.render(source);
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java b/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java
new file mode 100644
index 0000000..db40e22
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java
@@ -0,0 +1,108 @@
+package org.dcsa.core.query.impl;
+
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.extendedrequest.CursorBackedFilterCondition;
+import org.dcsa.core.extendedrequest.JoinDescriptor;
+import org.dcsa.core.extendedrequest.QueryField;
+import org.dcsa.core.extendedrequest.TableAndJoins;
+import org.dcsa.core.query.DBEntityAnalysis;
+import org.dcsa.core.query.QueryFactoryBuilder;
+import org.springframework.data.r2dbc.dialect.R2dbcDialect;
+import org.springframework.data.relational.core.dialect.RenderContextFactory;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Expression;
+import org.springframework.data.relational.core.sql.SelectBuilder;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor(staticName = "of")
+public class QueryFactoryBuilderImpl<T> implements QueryFactoryBuilder<T> {
+
+    private static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+    private final DBEntityAnalysis<T> dbEntityAnalysis;
+    private final boolean selectDistinct;
+
+    private final Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffset;
+    private final Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> order;
+    private final R2dbcDialect r2dbcDialect;
+
+    public QueryFactoryBuilder<T> copyBuilder() {
+        // Immutable, so we can just return this
+        return this;
+    }
+
+    public QueryFactoryBuilder<T> distinct() {
+        if (selectDistinct) {
+            return this;
+        }
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, true, limitOffset, order, r2dbcDialect);
+    }
+
+    public QueryFactoryBuilder<T> limitOffset(Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffsetFunction) {
+        if (limitOffsetFunction == limitOffset) {
+            return this;
+        }
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffsetFunction, order, r2dbcDialect);
+    }
+
+    public QueryFactoryBuilder<T> order(Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> orderFunction) {
+        if (orderFunction == order) {
+            return this;
+        }
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, orderFunction, r2dbcDialect);
+    }
+
+    public QueryFactoryBuilder<T> r2dbcDialect(R2dbcDialect newR2dbcDialect) {
+        if (newR2dbcDialect == this.r2dbcDialect) {
+            return this;
+        }
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, order, newR2dbcDialect);
+    }
+
+    public AbstractQueryFactory<T> build(CursorBackedFilterCondition filterCondition) {
+        if (r2dbcDialect == null) {
+            throw new IllegalStateException("Missing r2dbcDialect parameter");
+        }
+        Condition condition = filterCondition.computeCondition(r2dbcDialect);
+        Set<String> usedAliases = new HashSet<>();
+        TableAndJoins tableAndJoins = dbEntityAnalysis.getTableAndJoins();
+        List<Expression> expressions = dbEntityAnalysis.getAllSelectableFields().stream().map(queryField -> {
+            addAliases(usedAliases, queryField, tableAndJoins);
+            return queryField.getSelectColumn();
+        }).collect(Collectors.toList());
+        for (QueryField queryField : filterCondition.getReferencedQueryFields()) {
+            addAliases(usedAliases, queryField, tableAndJoins);
+        }
+        return GenericQueryFactory.of(
+                dbEntityAnalysis,
+                selectDistinct,
+                limitOffset,
+                order,
+                Set.of(usedAliases.toArray(EMPTY_STRING_ARRAY)),
+                condition,
+                expressions,
+                new RenderContextFactory(r2dbcDialect),
+                filterCondition.getBindings()
+        );
+    }
+
+    private static void addAliases(Set<String> joinAliasInUse, QueryField fieldInUse, TableAndJoins tableAndJoins) {
+        String joinAlias = fieldInUse.getTableJoinAlias();
+        while (joinAlias != null) {
+            JoinDescriptor descriptor = tableAndJoins.getJoinDescriptor(joinAlias);
+            if (descriptor == null) {
+                break;
+            }
+            String alias = descriptor.getJoinAliasId();
+            if (!joinAliasInUse.add(alias)) {
+                break;
+            }
+            joinAlias = descriptor.getDependentAlias();
+        }
+    }
+}
diff --git a/src/main/java/org/dcsa/core/repository/ExtendedRepository.java b/src/main/java/org/dcsa/core/repository/ExtendedRepository.java
index 467f0d7..907d900 100644
--- a/src/main/java/org/dcsa/core/repository/ExtendedRepository.java
+++ b/src/main/java/org/dcsa/core/repository/ExtendedRepository.java
@@ -1,6 +1,7 @@
 package org.dcsa.core.repository;
 
 import org.dcsa.core.extendedrequest.ExtendedRequest;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.data.repository.NoRepositoryBean;
 import reactor.core.publisher.Flux;
@@ -12,4 +13,7 @@ public interface ExtendedRepository<T, I> extends R2dbcRepository<T, I> {
     Flux<T> findAllExtended(final ExtendedRequest<T> extendedRequest);
     /* internal */ I getIdOfEntity(T entity);
 
+    Flux<T> findAllQuery(final AbstractQueryFactory<T> queryFactory);
+    Mono<T> findQuery(final AbstractQueryFactory<T> queryFactory);
+
 }
diff --git a/src/main/java/org/dcsa/core/repository/ExtendedRepositoryImpl.java b/src/main/java/org/dcsa/core/repository/ExtendedRepositoryImpl.java
index 9d3d80d..819c23a 100644
--- a/src/main/java/org/dcsa/core/repository/ExtendedRepositoryImpl.java
+++ b/src/main/java/org/dcsa/core/repository/ExtendedRepositoryImpl.java
@@ -1,11 +1,14 @@
 package org.dcsa.core.repository;
 
 import org.dcsa.core.extendedrequest.ExtendedRequest;
+import org.dcsa.core.query.DBEntityAnalysis;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
 import org.springframework.data.r2dbc.convert.MappingR2dbcConverter;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.r2dbc.repository.support.SimpleR2dbcRepository;
 import org.springframework.data.relational.repository.support.MappingRelationalEntityInformation;
 import org.springframework.r2dbc.core.DatabaseClient;
+import org.springframework.r2dbc.core.RowsFetchSpec;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -28,7 +31,7 @@ public I getIdOfEntity(T entity) {
     }
 
     public Mono<Integer> countAllExtended(final ExtendedRequest<T> extendedRequest) {
-        return extendedRequest.getCount(databaseClient)
+        return databaseClient.sql(extendedRequest.generateCountQuery())
                 .map((row, metadata) -> row.get(0, Integer.class))
                 .first()
                 .defaultIfEmpty(0);
@@ -36,10 +39,24 @@ public Mono<Integer> countAllExtended(final ExtendedRequest<T> extendedRequest)
 
     public Flux<T> findAllExtended(final ExtendedRequest<T> extendedRequest) {
         boolean ignoreUnknownProperties = extendedRequest.ignoreUnknownProperties();
-        return extendedRequest.getFindAll(databaseClient)
+        return executeQuery(extendedRequest, ignoreUnknownProperties).all();
+    }
+
+    public Flux<T> findAllQuery(final AbstractQueryFactory<T> queryFactory) {
+        return executeQuery(queryFactory, false).all();
+    }
+
+    public Mono<T> findQuery(final AbstractQueryFactory<T> queryFactory) {
+        return executeQuery(queryFactory, false).one();
+    }
+
+    private RowsFetchSpec<T> executeQuery(final AbstractQueryFactory<T> queryFactory, boolean ignoreUnknownProperties) {
+        DBEntityAnalysis<T> dbEntityAnalysis = queryFactory.getDbEntityAnalysis();
+
+        return databaseClient.sql(queryFactory.generateSelectQuery())
                 .map((row, metadata) ->
-                        rowMapper.mapRow(row, metadata, extendedRequest.getDbEntityAnalysis(),
-                                extendedRequest.getModelClass(), ignoreUnknownProperties)
-                ).all();
+                        rowMapper.mapRow(row, metadata, dbEntityAnalysis,
+                                dbEntityAnalysis.getEntityType(), ignoreUnknownProperties)
+                );
     }
 }

From 93d601ec5e2c98b252ae5241a2bc50b0bed97b4e Mon Sep 17 00:00:00 2001
From: Niels Thykier <nt@asseco.dk>
Date: Fri, 4 Jun 2021 14:18:04 +0200
Subject: [PATCH 6/6] Create API for more flexible queries

Signed-off-by: Niels Thykier <nt@asseco.dk>
---
 .../dcsa/core/extendedrequest/QueryField.java |  13 +
 .../core/extendedrequest/QueryFields.java     |   5 +
 .../extendedrequest/QueryParameterParser.java | 172 +-----------
 .../dcsa/core/query/QueryFactoryBuilder.java  |  42 ++-
 .../dcsa/core/query/impl/ComparisonType.java  | 108 +++++++
 .../query/impl/DefaultDBEntityAnalysis.java   |   3 +-
 .../impl/DefaultDBEntityAnalysisBuilder.java  |  26 +-
 ...DelegatingCursorBackedFilterCondition.java |  39 +++
 .../query/impl/InlineableFilterCondition.java |  19 ++
 .../query/impl/QueryFactoryBuilderImpl.java   | 264 ++++++++++++++++--
 .../core/query/impl/QueryGeneratorUtils.java  |  51 ++++
 .../core/service/ExtendedBaseService.java     |   4 +
 .../service/impl/ExtendedBaseServiceImpl.java |  10 +
 .../org/dcsa/core/util/ReflectUtility.java    |   5 +-
 .../org/dcsa/core/ExtendedRequestTest.java    |   4 +-
 .../java/org/dcsa/core/QueryFactoryTest.java  | 191 +++++++++++++
 .../core/models/AbstractCustomerBook.java     |  13 +
 .../core/models/combined/CustomerBook.java    |  10 +-
 18 files changed, 766 insertions(+), 213 deletions(-)
 create mode 100644 src/main/java/org/dcsa/core/query/impl/ComparisonType.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/DelegatingCursorBackedFilterCondition.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/InlineableFilterCondition.java
 create mode 100644 src/main/java/org/dcsa/core/query/impl/QueryGeneratorUtils.java
 create mode 100644 src/test/java/org/dcsa/core/QueryFactoryTest.java

diff --git a/src/main/java/org/dcsa/core/extendedrequest/QueryField.java b/src/main/java/org/dcsa/core/extendedrequest/QueryField.java
index 5b5f625..8fc90d3 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/QueryField.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/QueryField.java
@@ -1,6 +1,8 @@
 package org.dcsa.core.extendedrequest;
 
+import org.springframework.data.domain.Sort;
 import org.springframework.data.relational.core.sql.Column;
+import org.springframework.data.relational.core.sql.OrderByField;
 
 import java.lang.reflect.Field;
 
@@ -19,7 +21,18 @@ default boolean isSelectable() {
     default String getDatePattern() {
         return null;
     }
+    default String getFieldPath() {
+        return null;
+    }
     default Field getCombinedModelField() {
         return null;
     }
+
+    default OrderByField asOrderByField(Sort.Direction direction) {
+        Column column = getSelectColumn();
+        if (column == null) {
+            column = getInternalQueryColumn();
+        }
+        return OrderByField.from(column, direction);
+    }
 }
diff --git a/src/main/java/org/dcsa/core/extendedrequest/QueryFields.java b/src/main/java/org/dcsa/core/extendedrequest/QueryFields.java
index 98b2871..baf56b6 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/QueryFields.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/QueryFields.java
@@ -44,6 +44,7 @@ public static QueryField queryFieldFromFieldWithSelectPrefix(Class<?> combinedMo
             selectColumn = internalColumn.as(SqlIdentifier.quoted(namePrefix + selectName));
         }
         return FieldBackedQueryField.of(
+                namePrefix + combinedModelField.getName(),
                 combinedModelField,
                 internalColumn,
                 selectColumn,
@@ -84,6 +85,10 @@ public Column getSelectColumn() {
     @Data(staticConstructor = "of")
     private static class FieldBackedQueryField implements QueryField {
 
+        @NonNull
+        @Getter
+        private final String fieldPath;
+
         @NonNull
         @Getter
         private final Field combinedModelField;
diff --git a/src/main/java/org/dcsa/core/extendedrequest/QueryParameterParser.java b/src/main/java/org/dcsa/core/extendedrequest/QueryParameterParser.java
index f2e6acf..4b98dfb 100644
--- a/src/main/java/org/dcsa/core/extendedrequest/QueryParameterParser.java
+++ b/src/main/java/org/dcsa/core/extendedrequest/QueryParameterParser.java
@@ -1,16 +1,16 @@
 package org.dcsa.core.extendedrequest;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.dcsa.core.exception.GetException;
 import org.dcsa.core.query.DBEntityAnalysis;
+import org.dcsa.core.query.impl.ComparisonType;
+import org.dcsa.core.query.impl.DelegatingCursorBackedFilterCondition;
+import org.dcsa.core.query.impl.InlineableFilterCondition;
 import org.springframework.data.annotation.Transient;
-import org.springframework.data.r2dbc.dialect.PostgresDialect;
 import org.springframework.data.r2dbc.dialect.R2dbcDialect;
 import org.springframework.data.relational.core.sql.*;
 import org.springframework.r2dbc.core.binding.BindMarker;
-import org.springframework.r2dbc.core.binding.Bindings;
 import org.springframework.r2dbc.core.binding.MutableBindings;
 
 import java.lang.reflect.Field;
@@ -21,16 +21,14 @@
 import java.time.format.DateTimeParseException;
 import java.time.temporal.Temporal;
 import java.util.*;
-import java.util.function.BiFunction;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
+
+import static org.dcsa.core.query.impl.QueryGeneratorUtils.andAllFilters;
 
 @RequiredArgsConstructor
 public class QueryParameterParser<T> {
 
-    public static final FilterCondition EMPTY_CONDITION = InlineableFilterCondition.of(TrueCondition.INSTANCE);
-
     protected final ExtendedParameters extendedParameters;
     protected final R2dbcDialect r2dbcDialect;
     protected final DBEntityAnalysis<T> dbAnalysis;
@@ -275,165 +273,5 @@ protected QueryField getQueryFieldFromJSONName(String jsonName) {
         return queryField;
     }
 
-    private static FilterCondition isubstr(Expression lhs, Expression rhsOrig) {
-        Expression rhs = surroundWithWildCards(rhsOrig);
-        return r2dbcDialect -> {
-            if (r2dbcDialect instanceof PostgresDialect) {
-                return Comparison.create(lhs, "ILIKE", rhs);
-            }
-            return Conditions.like(Functions.upper(lhs), Functions.upper(rhs));
-        };
-    }
-
-    private static FilterCondition iequal(Expression lhs, Expression rhs) {
-        return InlineableFilterCondition.of(Conditions.isEqual(Functions.upper(lhs), Functions.upper(rhs)));
-    }
-
-    private static Expression surroundWithWildCards(Expression rhs) {
-        List<Expression> params = new ArrayList<>(3);
-        params.add(SQL.literalOf("%"));
-        params.add(rhs);
-        params.add(SQL.literalOf("%"));
-        return SimpleFunction.create("CONCAT", params);
-    }
 
-    @Getter
-    @RequiredArgsConstructor
-    protected enum ComparisonType {
-        GT(true, Conditions::isGreater),
-        GTE(true, Conditions::isGreaterOrEqualTo),
-        EQ(false, Conditions::isEqual),
-        LTE(true, Conditions::isLessOrEqualTo),
-        LT(true, Conditions::isLess),
-        NEQ(false, Conditions::isNotEqual),
-        SUBSTR(false, Conditions::like),
-        IEQ(false, true, QueryParameterParser::iequal),
-        ISUBSTR(false, true, QueryParameterParser::isubstr),
-        ;
-
-        private final boolean requiredOrdering;
-        private final boolean convertToString;
-        private final BiFunction<Expression, Expression, FilterCondition> singleValueConverter;
-
-        ComparisonType(boolean requiredOrdering, BiFunction<Expression, Expression, Condition> conditionBiFunction) {
-            this(requiredOrdering, false, (lhs, rhs) -> InlineableFilterCondition.of(conditionBiFunction.apply(lhs, rhs)));
-        }
-
-        public Expression defaultFieldConversion(QueryField queryField) {
-            boolean needsCast = convertToString;
-            if (needsCast) {
-                Class<?> valueType = queryField.getType();
-                if (valueType.isEnum() || String.class.equals(valueType)) {
-                    needsCast = false;
-                }
-            }
-            if (needsCast) {
-                Column aliased = queryField.getInternalQueryColumn().as(SqlIdentifier.unquoted("VARCHAR"));
-                return SimpleFunction.create("CAST", Collections.singletonList(aliased));
-            }
-            return queryField.getInternalQueryColumn();
-        }
-
-        public FilterCondition singleNonNullValueCondition(QueryField queryField, Expression expression) {
-            return singleNonNullValueCondition(defaultFieldConversion(queryField), expression);
-        }
-
-        public FilterCondition singleNonNullValueCondition(Expression field, Expression expression) {
-            return singleValueConverter.apply(field, expression);
-        }
-
-        public FilterCondition multiValueCondition(QueryField queryField, List<Expression> expressions) {
-            return multiValueCondition(defaultFieldConversion(queryField), expressions);
-        }
-
-        public FilterCondition multiValueCondition(Expression field, List<Expression> expressions) {
-            if (expressions.isEmpty()) {
-                throw new IllegalArgumentException("Right-hand side expression list must be non-empty");
-            }
-            if (expressions.size() == 1) {
-                return singleNonNullValueCondition(field, expressions.get(0));
-            } else if (this == EQ || this == NEQ) {
-                if (this == EQ) {
-                    return InlineableFilterCondition.of(Conditions.in(field, expressions));
-                }
-                return InlineableFilterCondition.of(Conditions.notIn(field, expressions));
-            } else {
-                return andAllFilters(
-                        expressions.stream().map(e -> singleValueConverter.apply(field, e)).collect(Collectors.toList()),
-                        true
-                );
-            }
-        }
-    }
-
-    private static FilterCondition andAllFilters(List<FilterCondition> filters, boolean nestOnMultiple) {
-        if (filters.isEmpty()) {
-            return EMPTY_CONDITION;
-        }
-        if (filters.size() == 1) {
-            return filters.get(0);
-        }
-        if (filters.stream().allMatch(FilterCondition::isInlineable)) {
-            return InlineableFilterCondition.of(andAll(filters.stream().map(FilterCondition::computeCondition), nestOnMultiple));
-        }
-        return (r2dbcDialect) -> andAll(filters.stream().map(f -> f.computeCondition(r2dbcDialect)), nestOnMultiple);
-    }
-
-    private static Condition andAll(Stream<Condition> conditions, boolean nestOnMultiple) {
-        return andAll(conditions::iterator, nestOnMultiple);
-    }
-
-    private static Condition andAll(Iterable<Condition> conditions, boolean nestOnMultiple) {
-        Iterator<Condition> iter = conditions.iterator();
-        assert iter.hasNext();
-        Condition con = iter.next();
-        if (!iter.hasNext()) {
-            return con;
-        }
-        do {
-            con = con.and(iter.next());
-        } while (iter.hasNext());
-        if (!nestOnMultiple) {
-            return con;
-        }
-        return Conditions.nest(con);
-    }
-
-    @RequiredArgsConstructor(staticName = "of")
-    private static class InlineableFilterCondition implements FilterCondition {
-        private final Condition condition;
-
-        public Condition computeCondition(R2dbcDialect r2dbcDialect) {
-            return condition;
-        }
-
-        public boolean isInlineable() {
-            return true;
-        }
-    }
-
-    @RequiredArgsConstructor(staticName = "of")
-    private static class DelegatingCursorBackedFilterCondition implements CursorBackedFilterCondition {
-
-        private final FilterCondition delegate;
-
-        @Getter
-        private final Map<String, List<String>> cursorParameters;
-
-        @Getter
-        private final Set<QueryField> referencedQueryFields;
-
-        @Getter
-        private final Bindings bindings;
-
-        @Override
-        public Condition computeCondition(R2dbcDialect r2dbcDialect) {
-            return delegate.computeCondition(r2dbcDialect);
-        }
-
-        @Override
-        public boolean isInlineable() {
-            return delegate.isInlineable();
-        }
-    }
 }
diff --git a/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java b/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
index ee25e0c..d85e6f7 100644
--- a/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
+++ b/src/main/java/org/dcsa/core/query/QueryFactoryBuilder.java
@@ -1,11 +1,14 @@
 package org.dcsa.core.query;
 
-import org.dcsa.core.extendedrequest.CursorBackedFilterCondition;
+import org.apache.commons.lang3.concurrent.BackgroundInitializer;
 import org.dcsa.core.query.impl.AbstractQueryFactory;
 import org.dcsa.core.query.impl.QueryFactoryBuilderImpl;
 import org.springframework.data.r2dbc.dialect.R2dbcDialect;
 import org.springframework.data.relational.core.sql.SelectBuilder;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
 public interface QueryFactoryBuilder<T> {
@@ -13,11 +16,42 @@ public interface QueryFactoryBuilder<T> {
     QueryFactoryBuilder<T> distinct();
     QueryFactoryBuilder<T> limitOffset(Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffsetFunction);
     QueryFactoryBuilder<T> order(Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> orderFunction);
+    QueryFactoryBuilder<T> order(BiFunction<SelectBuilder.SelectOrdered, DBEntityAnalysis<T>, SelectBuilder.BuildSelect> orderFunction);
     QueryFactoryBuilder<T> r2dbcDialect(R2dbcDialect r2dbcDialect);
-    QueryFactoryBuilder<T> copyBuilder();
-    AbstractQueryFactory<T> build(CursorBackedFilterCondition filterCondition);
+    FrozenBuilder<QueryFactoryBuilder<T>> freeze();
+
+    ConditionBuilder<T> conditions();
+    AbstractQueryFactory<T> build();
 
     static <T> QueryFactoryBuilder<T> builder(DBEntityAnalysis<T> dbEntityAnalysis) {
-        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, false, null, null, null);
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, false, null, null, null, null);
+    }
+
+    interface ConditionBuilder<T> {
+
+        ComparisonBuilder<T> fieldByJsonName(String jsonName);
+        ComparisonBuilder<T> fieldByJavaField(String javaField);
+        QueryFactoryBuilder<T> withQuery();
+
+        FrozenBuilder<ConditionBuilder<T>> freeze();
+        AbstractQueryFactory<T> build();
+    }
+
+    interface FrozenBuilder<B> {
+        B copyBuilder();
+    }
+
+    interface ComparisonBuilder<T> {
+        ConditionBuilder<T> isNull();
+        ConditionBuilder<T> isNotNull();
+        ConditionBuilder<T> greaterThan(Object value);
+        ConditionBuilder<T> greaterThanOrEqualTo(Object value);
+        ConditionBuilder<T> equalTo(Object value);
+        ConditionBuilder<T> lessThanOrEqualTo(Object value);
+        ConditionBuilder<T> lessThan(Object value);
+        default ConditionBuilder<T> oneOf(Object ... values) {
+            return oneOf(Arrays.asList(values));
+        }
+        ConditionBuilder<T> oneOf(List<Object> values);
     }
 }
diff --git a/src/main/java/org/dcsa/core/query/impl/ComparisonType.java b/src/main/java/org/dcsa/core/query/impl/ComparisonType.java
new file mode 100644
index 0000000..0a29467
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/ComparisonType.java
@@ -0,0 +1,108 @@
+package org.dcsa.core.query.impl;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.extendedrequest.FilterCondition;
+import org.dcsa.core.extendedrequest.QueryField;
+import org.dcsa.core.extendedrequest.QueryParameterParser;
+import org.springframework.data.r2dbc.dialect.PostgresDialect;
+import org.springframework.data.relational.core.sql.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+
+import static org.dcsa.core.query.impl.QueryGeneratorUtils.andAllFilters;
+
+@Getter
+@RequiredArgsConstructor
+public enum ComparisonType {
+    GT(true, Conditions::isGreater),
+    GTE(true, Conditions::isGreaterOrEqualTo),
+    EQ(false, Conditions::isEqual),
+    LTE(true, Conditions::isLessOrEqualTo),
+    LT(true, Conditions::isLess),
+    NEQ(false, Conditions::isNotEqual),
+    SUBSTR(false, Conditions::like),
+    IEQ(false, true, ComparisonType::iequal),
+    ISUBSTR(false, true, ComparisonType::isubstr),
+    ;
+
+    private final boolean requiredOrdering;
+    private final boolean convertToString;
+    private final BiFunction<Expression, Expression, FilterCondition> singleValueConverter;
+
+    ComparisonType(boolean requiredOrdering, BiFunction<Expression, Expression, Condition> conditionBiFunction) {
+        this(requiredOrdering, false, (lhs, rhs) -> InlineableFilterCondition.of(conditionBiFunction.apply(lhs, rhs)));
+    }
+
+    public Expression defaultFieldConversion(QueryField queryField) {
+        boolean needsCast = convertToString;
+        if (needsCast) {
+            Class<?> valueType = queryField.getType();
+            if (valueType.isEnum() || String.class.equals(valueType)) {
+                needsCast = false;
+            }
+        }
+        if (needsCast) {
+            Column aliased = queryField.getInternalQueryColumn().as(SqlIdentifier.unquoted("VARCHAR"));
+            return SimpleFunction.create("CAST", Collections.singletonList(aliased));
+        }
+        return queryField.getInternalQueryColumn();
+    }
+
+    public FilterCondition singleNonNullValueCondition(QueryField queryField, Expression expression) {
+        return singleNonNullValueCondition(defaultFieldConversion(queryField), expression);
+    }
+
+    public FilterCondition singleNonNullValueCondition(Expression field, Expression expression) {
+        return singleValueConverter.apply(field, expression);
+    }
+
+    public FilterCondition multiValueCondition(QueryField queryField, List<Expression> expressions) {
+        return multiValueCondition(defaultFieldConversion(queryField), expressions);
+    }
+
+    public FilterCondition multiValueCondition(Expression field, List<Expression> expressions) {
+        if (expressions.isEmpty()) {
+            throw new IllegalArgumentException("Right-hand side expression list must be non-empty");
+        }
+        if (expressions.size() == 1) {
+            return singleNonNullValueCondition(field, expressions.get(0));
+        } else if (this == EQ || this == NEQ) {
+            if (this == EQ) {
+                return InlineableFilterCondition.of(Conditions.in(field, expressions));
+            }
+            return InlineableFilterCondition.of(Conditions.notIn(field, expressions));
+        } else {
+            return andAllFilters(
+                    expressions.stream().map(e -> singleValueConverter.apply(field, e)).collect(Collectors.toList()),
+                    true
+            );
+        }
+    }
+
+    private static FilterCondition isubstr(Expression lhs, Expression rhsOrig) {
+        Expression rhs = surroundWithWildCards(rhsOrig);
+        return r2dbcDialect -> {
+            if (r2dbcDialect instanceof PostgresDialect) {
+                return Comparison.create(lhs, "ILIKE", rhs);
+            }
+            return Conditions.like(Functions.upper(lhs), Functions.upper(rhs));
+        };
+    }
+
+    private static FilterCondition iequal(Expression lhs, Expression rhs) {
+        return InlineableFilterCondition.of(Conditions.isEqual(Functions.upper(lhs), Functions.upper(rhs)));
+    }
+
+    private static Expression surroundWithWildCards(Expression rhs) {
+        List<Expression> params = new ArrayList<>(3);
+        params.add(SQL.literalOf("%"));
+        params.add(rhs);
+        params.add(SQL.literalOf("%"));
+        return SimpleFunction.create("CONCAT", params);
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
index 40b6866..03c4c6a 100644
--- a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
+++ b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysis.java
@@ -16,6 +16,7 @@ public class DefaultDBEntityAnalysis<T> implements DBEntityAnalysis<T> {
     @Getter
     private final Class<T> entityType;
     private final Map<String, QueryField> jsonName2QueryField;
+    private final Map<String, QueryField> javaFieldName2QueryField;
     private final Map<String, QueryField> selectName2QueryField;
     private final Set<String> declaredButNotSelectable;
     @Getter
@@ -38,7 +39,7 @@ public QueryField getQueryFieldFromJSONName(String jsonName) throws IllegalArgum
 
     @Override
     public QueryField getQueryFieldFromJavaFieldName(String javaFieldName) throws IllegalArgumentException {
-        throw new UnsupportedOperationException("Not implemented yet");
+        return getFieldFromTable(javaFieldName2QueryField, javaFieldName);
     }
 
     public QueryField getQueryFieldFromSelectName(String selectName) throws IllegalArgumentException {
diff --git a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
index 6007561..fdc6e58 100644
--- a/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
+++ b/src/main/java/org/dcsa/core/query/impl/DefaultDBEntityAnalysisBuilder.java
@@ -2,7 +2,10 @@
 
 import lombok.RequiredArgsConstructor;
 import org.dcsa.core.extendedrequest.*;
-import org.dcsa.core.model.*;
+import org.dcsa.core.model.ForeignKey;
+import org.dcsa.core.model.JoinedWithModel;
+import org.dcsa.core.model.PrimaryModel;
+import org.dcsa.core.model.ViaJoinAlias;
 import org.dcsa.core.query.DBEntityAnalysis;
 import org.dcsa.core.util.ReflectUtility;
 import org.springframework.data.annotation.Transient;
@@ -20,6 +23,7 @@ public class DefaultDBEntityAnalysisBuilder<T> implements DBEntityAnalysis.DBEnt
     private final Class<T> entityType;
 
     private final Map<String, QueryField> jsonName2DbField = new HashMap<>();
+    private final Map<String, QueryField> javaFieldName2DbField = new HashMap<>();
     private final Map<String, QueryField> selectName2DbField = new HashMap<>();
     private final List<QueryField> allSelectableFields = new ArrayList<>();
     private final Map<String, QueryField> internalQueryName2DbField = new HashMap<>();
@@ -129,11 +133,11 @@ private void loadForeignKeysFromEntityClass() {
             initJoinAliasTable();
         }
 
-        loadJoinsAndFieldsAndForeignKeysDeep(entityType, model -> model.isAssignableFrom(entityType), "", "", null);
+        loadJoinsAndFieldsAndForeignKeysDeep(entityType, model -> model.isAssignableFrom(entityType), "", "", null, new HashSet<>());
     }
 
     private void loadJoinsAndFieldsAndForeignKeysDeep(Class<?> modelType, Predicate<Class<?>> skipFieldRegistration,
-                                                      String prefix, String joinAlias, Table table) {
+                                                      String prefix, String joinAlias, Table table, Set<String> seenFields) {
         if (joinAlias.equals("")) {
             joinAlias = ReflectUtility.getTableName(modelType);
         }
@@ -146,6 +150,12 @@ private void loadJoinsAndFieldsAndForeignKeysDeep(Class<?> modelType, Predicate<
             if (field.isAnnotationPresent(Transient.class)) {
                 continue;
             }
+            String fieldName = field.getName();
+            // Cope with fields being shadowed in subclasses - we take the "first" (subclass) definition we find.
+            if (seenFields.contains(fieldName)) {
+                continue;
+            }
+            seenFields.add(fieldName);
 
             if (field.isAnnotationPresent(ForeignKey.class)) {
                 ForeignKey foreignKey = field.getAnnotation(ForeignKey.class);
@@ -171,7 +181,7 @@ private void loadJoinsAndFieldsAndForeignKeysDeep(Class<?> modelType, Predicate<
 
                 // load fields recursively with new prefix
                 String newPrefix = prefix + ReflectUtility.transformFromFieldNameToJsonName(intoField) + ".";
-                loadJoinsAndFieldsAndForeignKeysDeep(intoField.getType(), skipFieldRegistration, newPrefix, intoJoinAlias, null);
+                loadJoinsAndFieldsAndForeignKeysDeep(intoField.getType(), skipFieldRegistration, newPrefix, intoJoinAlias, null, new HashSet<>());
             }
 
             if (skipFieldRegistration != null && skipFieldRegistration.test(modelType)) {
@@ -184,7 +194,7 @@ private void loadJoinsAndFieldsAndForeignKeysDeep(Class<?> modelType, Predicate<
 
         Class<?> superClass = modelType.getSuperclass();
         if (superClass != Object.class) {
-            loadJoinsAndFieldsAndForeignKeysDeep(superClass, skipFieldRegistration, prefix, joinAlias, table);
+            loadJoinsAndFieldsAndForeignKeysDeep(superClass, skipFieldRegistration, prefix, joinAlias, table, seenFields);
         }
     }
 
@@ -375,6 +385,11 @@ private void registerField(Field field, Class<?> modelType, boolean selectable)
     public DBEntityAnalysis.DBEntityAnalysisBuilder<T> registerQueryField(QueryField queryField) {
         detectClash(jsonName2DbField, queryField.getJsonName(), queryField, "JSON key",
                 "Probably one or both of them has a invalid @JsonProperty");
+        String fieldPath = queryField.getFieldPath();
+        if (fieldPath != null) {
+            detectClash(javaFieldName2DbField, fieldPath, queryField, "JavaFieldName",
+                    "This should not be possible");
+        }
         if (queryField.isSelectable()) {
             Column column = Objects.requireNonNull(queryField.getSelectColumn(), "selectColumn");
             SqlIdentifier name = column.getName();
@@ -571,6 +586,7 @@ public DBEntityAnalysis<T> build() {
         return new DefaultDBEntityAnalysis<>(
                 entityType,
                 Collections.unmodifiableMap(jsonName2DbField),
+                Collections.unmodifiableMap(javaFieldName2DbField),
                 Collections.unmodifiableMap(selectName2DbField),
                 Collections.unmodifiableSet(declaredButNotSelectable),
                 Collections.unmodifiableList(allSelectableFields),
diff --git a/src/main/java/org/dcsa/core/query/impl/DelegatingCursorBackedFilterCondition.java b/src/main/java/org/dcsa/core/query/impl/DelegatingCursorBackedFilterCondition.java
new file mode 100644
index 0000000..e754208
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/DelegatingCursorBackedFilterCondition.java
@@ -0,0 +1,39 @@
+package org.dcsa.core.query.impl;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.extendedrequest.CursorBackedFilterCondition;
+import org.dcsa.core.extendedrequest.FilterCondition;
+import org.dcsa.core.extendedrequest.QueryField;
+import org.springframework.data.r2dbc.dialect.R2dbcDialect;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.r2dbc.core.binding.Bindings;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RequiredArgsConstructor(staticName = "of")
+public class DelegatingCursorBackedFilterCondition implements CursorBackedFilterCondition {
+
+    private final FilterCondition delegate;
+
+    @Getter
+    private final Map<String, List<String>> cursorParameters;
+
+    @Getter
+    private final Set<QueryField> referencedQueryFields;
+
+    @Getter
+    private final Bindings bindings;
+
+    @Override
+    public Condition computeCondition(R2dbcDialect r2dbcDialect) {
+        return delegate.computeCondition(r2dbcDialect);
+    }
+
+    @Override
+    public boolean isInlineable() {
+        return delegate.isInlineable();
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/InlineableFilterCondition.java b/src/main/java/org/dcsa/core/query/impl/InlineableFilterCondition.java
new file mode 100644
index 0000000..0ed4a8a
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/InlineableFilterCondition.java
@@ -0,0 +1,19 @@
+package org.dcsa.core.query.impl;
+
+import lombok.RequiredArgsConstructor;
+import org.dcsa.core.extendedrequest.FilterCondition;
+import org.springframework.data.r2dbc.dialect.R2dbcDialect;
+import org.springframework.data.relational.core.sql.Condition;
+
+@RequiredArgsConstructor(staticName = "of")
+public class InlineableFilterCondition implements FilterCondition {
+    private final Condition condition;
+
+    public Condition computeCondition(R2dbcDialect r2dbcDialect) {
+        return condition;
+    }
+
+    public boolean isInlineable() {
+        return true;
+    }
+}
diff --git a/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java b/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java
index db40e22..f2bd29d 100644
--- a/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java
+++ b/src/main/java/org/dcsa/core/query/impl/QueryFactoryBuilderImpl.java
@@ -1,7 +1,8 @@
 package org.dcsa.core.query.impl;
 
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
-import org.dcsa.core.extendedrequest.CursorBackedFilterCondition;
+import org.dcsa.core.extendedrequest.FilterCondition;
 import org.dcsa.core.extendedrequest.JoinDescriptor;
 import org.dcsa.core.extendedrequest.QueryField;
 import org.dcsa.core.extendedrequest.TableAndJoins;
@@ -9,18 +10,18 @@
 import org.dcsa.core.query.QueryFactoryBuilder;
 import org.springframework.data.r2dbc.dialect.R2dbcDialect;
 import org.springframework.data.relational.core.dialect.RenderContextFactory;
-import org.springframework.data.relational.core.sql.Condition;
-import org.springframework.data.relational.core.sql.Expression;
-import org.springframework.data.relational.core.sql.SelectBuilder;
+import org.springframework.data.relational.core.sql.*;
+import org.springframework.r2dbc.core.binding.BindMarker;
+import org.springframework.r2dbc.core.binding.Bindings;
+import org.springframework.r2dbc.core.binding.MutableBindings;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @RequiredArgsConstructor(staticName = "of")
-public class QueryFactoryBuilderImpl<T> implements QueryFactoryBuilder<T> {
+public class QueryFactoryBuilderImpl<T> implements QueryFactoryBuilder<T>, QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder<T>> {
 
     private static final String[] EMPTY_STRING_ARRAY = new String[0];
 
@@ -30,54 +31,108 @@ public class QueryFactoryBuilderImpl<T> implements QueryFactoryBuilder<T> {
     private final Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffset;
     private final Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> order;
     private final R2dbcDialect r2dbcDialect;
+    private final BindingInformation bindingInformation;
 
     public QueryFactoryBuilder<T> copyBuilder() {
         // Immutable, so we can just return this
         return this;
     }
 
+    public QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder<T>> freeze() {
+        // Immutable, so we can just return this
+        return this;
+    }
+
     public QueryFactoryBuilder<T> distinct() {
         if (selectDistinct) {
             return this;
         }
-        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, true, limitOffset, order, r2dbcDialect);
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, true, limitOffset, order, r2dbcDialect, bindingInformation);
     }
 
     public QueryFactoryBuilder<T> limitOffset(Function<SelectBuilder.SelectFromAndJoin, SelectBuilder.SelectFromAndJoin> limitOffsetFunction) {
         if (limitOffsetFunction == limitOffset) {
             return this;
         }
-        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffsetFunction, order, r2dbcDialect);
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffsetFunction, order, r2dbcDialect, bindingInformation);
     }
 
     public QueryFactoryBuilder<T> order(Function<SelectBuilder.SelectOrdered, SelectBuilder.BuildSelect> orderFunction) {
         if (orderFunction == order) {
             return this;
         }
-        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, orderFunction, r2dbcDialect);
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, orderFunction, r2dbcDialect, bindingInformation);
+    }
+
+    public QueryFactoryBuilder<T> order(BiFunction<SelectBuilder.SelectOrdered, DBEntityAnalysis<T>, SelectBuilder.BuildSelect> orderFunction) {
+        if (orderFunction == order) {
+            return this;
+        }
+        return order((b) -> orderFunction.apply(b, dbEntityAnalysis));
     }
 
     public QueryFactoryBuilder<T> r2dbcDialect(R2dbcDialect newR2dbcDialect) {
         if (newR2dbcDialect == this.r2dbcDialect) {
             return this;
         }
-        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, order, newR2dbcDialect);
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, order, newR2dbcDialect, bindingInformation);
     }
 
-    public AbstractQueryFactory<T> build(CursorBackedFilterCondition filterCondition) {
+    public ConditionBuilder<T> conditions() {
         if (r2dbcDialect == null) {
             throw new IllegalStateException("Missing r2dbcDialect parameter");
         }
-        Condition condition = filterCondition.computeCondition(r2dbcDialect);
+        ConditionBuilderImpl builder = new ConditionBuilderImpl();
+        builder.inheritedBindingInformation = bindingInformation;
+        return builder;
+    }
+
+    private static void addAliases(Set<String> joinAliasInUse, QueryField fieldInUse, TableAndJoins tableAndJoins) {
+        String joinAlias = fieldInUse.getTableJoinAlias();
+        while (joinAlias != null) {
+            JoinDescriptor descriptor = tableAndJoins.getJoinDescriptor(joinAlias);
+            if (descriptor == null) {
+                break;
+            }
+            String alias = descriptor.getJoinAliasId();
+            if (!joinAliasInUse.add(alias)) {
+                break;
+            }
+            joinAlias = descriptor.getDependentAlias();
+        }
+    }
+
+    public AbstractQueryFactory<T> build() {
+        BindingInformation binds = bindingInformation;
+        if (binds == null) {
+            binds = BindingInformation.EMPTY;
+        }
+        return doBuild(binds);
+    }
+
+    private AbstractQueryFactory<T> doBuild(BindingInformation bindingInformation) {
         Set<String> usedAliases = new HashSet<>();
         TableAndJoins tableAndJoins = dbEntityAnalysis.getTableAndJoins();
         List<Expression> expressions = dbEntityAnalysis.getAllSelectableFields().stream().map(queryField -> {
             addAliases(usedAliases, queryField, tableAndJoins);
             return queryField.getSelectColumn();
         }).collect(Collectors.toList());
-        for (QueryField queryField : filterCondition.getReferencedQueryFields()) {
-            addAliases(usedAliases, queryField, tableAndJoins);
+
+        Bindings bindings;
+        Condition condition;
+
+        if (!bindingInformation.conditions.isEmpty()) {
+            FilterCondition filterCondition = QueryGeneratorUtils.andAllFilters(bindingInformation.conditions, false);
+            condition = filterCondition.computeCondition(r2dbcDialect);
+            bindings = bindingInformation.bindings;
+            for (QueryField queryField : bindingInformation.referencedQueryFields) {
+                addAliases(usedAliases, queryField, tableAndJoins);
+            }
+        } else {
+            condition = TrueCondition.INSTANCE;
+            bindings = new Bindings();
         }
+
         return GenericQueryFactory.of(
                 dbEntityAnalysis,
                 selectDistinct,
@@ -87,22 +142,177 @@ public AbstractQueryFactory<T> build(CursorBackedFilterCondition filterCondition
                 condition,
                 expressions,
                 new RenderContextFactory(r2dbcDialect),
-                filterCondition.getBindings()
+                bindings
         );
     }
 
-    private static void addAliases(Set<String> joinAliasInUse, QueryField fieldInUse, TableAndJoins tableAndJoins) {
-        String joinAlias = fieldInUse.getTableJoinAlias();
-        while (joinAlias != null) {
-            JoinDescriptor descriptor = tableAndJoins.getJoinDescriptor(joinAlias);
-            if (descriptor == null) {
-                break;
+    private QueryFactoryBuilder<T> withBindingInformation(BindingInformation newBindingInformation) {
+        if (Objects.equals(newBindingInformation, this.bindingInformation)) {
+            return this;
+        }
+        return QueryFactoryBuilderImpl.of(dbEntityAnalysis, selectDistinct, limitOffset, order, r2dbcDialect, newBindingInformation);
+    }
+
+    @Data
+    @RequiredArgsConstructor(staticName = "of")
+    private static class BindingInformation {
+
+        public static BindingInformation EMPTY = BindingInformation.of(
+                new Bindings(),
+                Collections.emptyList(),
+                Collections.emptySet()
+        );
+
+        private final Bindings bindings;
+        private final List<FilterCondition> conditions;
+        private final Set<QueryField> referencedQueryFields;
+    }
+
+    @RequiredArgsConstructor
+    private class ConditionBuilderImpl implements ConditionBuilder<T>, FrozenBuilder<ConditionBuilder<T>> {
+        private BindingInformation inheritedBindingInformation;
+        private List<FilterCondition> conditions = new ArrayList<>();
+        private MutableBindings mutableBindings = new MutableBindings(r2dbcDialect.getBindMarkersFactory().create());
+        // Shadows the QueryFactoryBuilderImpl.bindingInformation field by intention.
+        private BindingInformation bindingInformation;
+        private Set<QueryField> referencedQueryFields = new HashSet<>();
+        private boolean isFrozen = false;
+
+        public ComparisonBuilder<T> fieldByJsonName(String jsonName) {
+            return withField(dbEntityAnalysis.getQueryFieldFromJSONName(jsonName));
+        }
+
+        public ComparisonBuilder<T> fieldByJavaField(String javaField) {
+            return withField(dbEntityAnalysis.getQueryFieldFromJavaFieldName(javaField));
+        }
+
+        public QueryFactoryBuilder<T> withQuery() {
+            if (!isFrozen) {
+                freeze();
             }
-            String alias = descriptor.getJoinAliasId();
-            if (!joinAliasInUse.add(alias)) {
-                break;
+            return withBindingInformation(bindingInformation);
+        }
+
+        private ComparisonBuilder<T> withField(QueryField queryField) {
+            ConditionBuilderImpl conditionBuilder = this;
+            if (isFrozen) {
+                conditionBuilder = new ConditionBuilderImpl();
+                conditionBuilder.inheritedBindingInformation = bindingInformation;
+                conditionBuilder.referencedQueryFields.addAll(referencedQueryFields);
+                conditionBuilder.conditions.addAll(conditions);
             }
-            joinAlias = descriptor.getDependentAlias();
+            return new ComparisonBuilderImpl(conditionBuilder, queryField);
+        }
+
+        public FrozenBuilder<ConditionBuilder<T>> freeze() {
+            if (isFrozen) {
+                return this;
+            }
+            referencedQueryFields = Set.copyOf(referencedQueryFields);
+            conditions = List.copyOf(conditions);
+            Bindings bindings;
+            if (inheritedBindingInformation != null) {
+                bindings = inheritedBindingInformation.bindings.and(mutableBindings);
+            } else {
+                bindings = new Bindings().and(mutableBindings);
+            }
+            bindingInformation = BindingInformation.of(bindings, conditions, referencedQueryFields);
+            mutableBindings = null;
+            isFrozen = true;
+            // We no longer need the inherited information as we copied all the data from it.  We might as well
+            // remove the reference to enable garbage collection to clean up the parent if it
+            // is no longer referenced.
+            inheritedBindingInformation = null;
+            return this;
+        }
+
+        public ConditionBuilder<T> copyBuilder() {
+            if (!isFrozen) {
+                freeze();
+            }
+            return this;
+        }
+
+        public AbstractQueryFactory<T> build() {
+            if (!isFrozen) {
+                freeze();
+            }
+            return doBuild(bindingInformation);
+        }
+    }
+
+    @RequiredArgsConstructor
+    private class ComparisonBuilderImpl implements ComparisonBuilder<T> {
+        private final ConditionBuilderImpl conditionBuilder;
+        private final QueryField queryField;
+
+        @Override
+        public ConditionBuilder<T> isNull() {
+            return nullComparison(ComparisonType.EQ);
+        }
+
+        @Override
+        public ConditionBuilder<T> isNotNull() {
+            return nullComparison(ComparisonType.NEQ);
+        }
+
+        @Override
+        public ConditionBuilder<T> greaterThan(Object value) {
+            return comparison(ComparisonType.GT, value);
+        }
+
+        @Override
+        public ConditionBuilder<T> greaterThanOrEqualTo(Object value) {
+            return comparison(ComparisonType.GTE, value);
+        }
+
+        @Override
+        public ConditionBuilder<T> equalTo(Object value) {
+            return comparison(ComparisonType.EQ, value);
+        }
+
+        @Override
+        public ConditionBuilder<T> lessThanOrEqualTo(Object value) {
+            return comparison(ComparisonType.LTE, value);
+        }
+
+        @Override
+        public ConditionBuilder<T> lessThan(Object value) {
+            return comparison(ComparisonType.LT, value);
+        }
+
+        @Override
+        public ConditionBuilder<T> oneOf(List<Object> values) {
+            FilterCondition filterCondition = ComparisonType.EQ.multiValueCondition(queryField,
+                    values.stream().map(v -> bindValue(queryField, v)).collect(Collectors.toList()));
+
+            return finish(filterCondition);
+        }
+
+        private ConditionBuilder<T> nullComparison(ComparisonType comparison) {
+            Condition condition = Conditions.isNull(comparison.defaultFieldConversion(queryField));
+            if (comparison == ComparisonType.NEQ) {
+                condition = condition.not();
+            }
+            return finish(InlineableFilterCondition.of(condition));
+        }
+
+        private Expression bindValue(QueryField queryField, Object value) {
+            MutableBindings bindings = conditionBuilder.mutableBindings;
+            BindMarker marker = bindings.nextMarker(queryField.getJsonName());
+            bindings.bind(marker, value);
+            return SQL.bindMarker(marker.getPlaceholder());
+        }
+
+        private ConditionBuilder<T> comparison(ComparisonType comparisonType, Object value) {
+            FilterCondition filterCondition = comparisonType.singleNonNullValueCondition(queryField, bindValue(queryField, value));
+            return finish(filterCondition);
+        }
+
+        private ConditionBuilder<T> finish(FilterCondition filterCondition) {
+            conditionBuilder.conditions.add(filterCondition);
+            conditionBuilder.referencedQueryFields.add(queryField);
+            return conditionBuilder;
         }
     }
 }
diff --git a/src/main/java/org/dcsa/core/query/impl/QueryGeneratorUtils.java b/src/main/java/org/dcsa/core/query/impl/QueryGeneratorUtils.java
new file mode 100644
index 0000000..bb7e012
--- /dev/null
+++ b/src/main/java/org/dcsa/core/query/impl/QueryGeneratorUtils.java
@@ -0,0 +1,51 @@
+package org.dcsa.core.query.impl;
+
+import org.dcsa.core.extendedrequest.FilterCondition;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Conditions;
+import org.springframework.data.relational.core.sql.TrueCondition;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class QueryGeneratorUtils {
+
+    public static final FilterCondition EMPTY_CONDITION = InlineableFilterCondition.of(TrueCondition.INSTANCE);
+
+    public static FilterCondition andAllFilters(List<FilterCondition> filters, boolean nestOnMultiple) {
+        if (filters.isEmpty()) {
+            return EMPTY_CONDITION;
+        }
+        if (filters.size() == 1) {
+            return filters.get(0);
+        }
+        if (filters.stream().allMatch(FilterCondition::isInlineable)) {
+            return InlineableFilterCondition.of(andAll(filters.stream().map(FilterCondition::computeCondition), nestOnMultiple));
+        }
+        return (r2dbcDialect) -> andAll(filters.stream().map(f -> f.computeCondition(r2dbcDialect)), nestOnMultiple);
+    }
+
+    public static Condition andAll(Stream<Condition> conditions, boolean nestOnMultiple) {
+        return andAll(conditions::iterator, nestOnMultiple);
+    }
+
+    public static Condition andAll(Iterable<Condition> conditions, boolean nestOnMultiple) {
+        Iterator<Condition> iter = conditions.iterator();
+        assert iter.hasNext();
+        Condition con = iter.next();
+        if (!iter.hasNext()) {
+            return con;
+        }
+        do {
+            con = con.and(iter.next());
+        } while (iter.hasNext());
+        if (!nestOnMultiple) {
+            return con;
+        }
+        return Conditions.nest(con);
+    }
+
+
+
+}
diff --git a/src/main/java/org/dcsa/core/service/ExtendedBaseService.java b/src/main/java/org/dcsa/core/service/ExtendedBaseService.java
index de81a19..4bfa18e 100644
--- a/src/main/java/org/dcsa/core/service/ExtendedBaseService.java
+++ b/src/main/java/org/dcsa/core/service/ExtendedBaseService.java
@@ -1,9 +1,13 @@
 package org.dcsa.core.service;
 
 import org.dcsa.core.extendedrequest.ExtendedRequest;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
 import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 
 public interface ExtendedBaseService<T, I> extends BaseService<T, I> {
     Class<T> getModelClass();
     Flux<T> findAllExtended(ExtendedRequest<T> extendedRequest);
+    Flux<T> findAllQuery(final AbstractQueryFactory<T> queryFactory);
+    Mono<T> findQuery(final AbstractQueryFactory<T> queryFactory);
 }
diff --git a/src/main/java/org/dcsa/core/service/impl/ExtendedBaseServiceImpl.java b/src/main/java/org/dcsa/core/service/impl/ExtendedBaseServiceImpl.java
index fe17dc0..57f961c 100644
--- a/src/main/java/org/dcsa/core/service/impl/ExtendedBaseServiceImpl.java
+++ b/src/main/java/org/dcsa/core/service/impl/ExtendedBaseServiceImpl.java
@@ -1,9 +1,11 @@
 package org.dcsa.core.service.impl;
 
 import org.dcsa.core.extendedrequest.ExtendedRequest;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
 import org.dcsa.core.repository.ExtendedRepository;
 import org.dcsa.core.service.ExtendedBaseService;
 import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 
 public abstract class ExtendedBaseServiceImpl<R extends ExtendedRepository<T, I>, T, I> extends BaseRepositoryBackedServiceImpl<R, T, I> implements ExtendedBaseService<T, I> {
 
@@ -19,4 +21,12 @@ public Flux<T> findAllExtended(ExtendedRequest<T> extendedRequest) {
                         getRepository().findAllExtended(extendedRequest)
         );
     }
+
+    public Flux<T> findAllQuery(final AbstractQueryFactory<T> queryFactory) {
+        return getRepository().findAllQuery(queryFactory);
+    }
+
+    public Mono<T> findQuery(final AbstractQueryFactory<T> queryFactory) {
+        return getRepository().findQuery(queryFactory);
+    }
 }
diff --git a/src/main/java/org/dcsa/core/util/ReflectUtility.java b/src/main/java/org/dcsa/core/util/ReflectUtility.java
index b96fb63..819d952 100644
--- a/src/main/java/org/dcsa/core/util/ReflectUtility.java
+++ b/src/main/java/org/dcsa/core/util/ReflectUtility.java
@@ -346,8 +346,9 @@ private static void visitAllFields(Class<?> clazz, Predicate<Field> matching, Co
         }
         while (currentClass != Object.class) {
             for (Field f : currentClass.getDeclaredFields()) {
-                if (!seenFields.contains(f.getName()) && matching.test(f)) {
-                    seenFields.add(f.getName());
+                String name = f.getName();
+                if (!seenFields.contains(name) && matching.test(f)) {
+                    seenFields.add(name);
                     fieldConsumer.accept(f);
                 }
             }
diff --git a/src/test/java/org/dcsa/core/ExtendedRequestTest.java b/src/test/java/org/dcsa/core/ExtendedRequestTest.java
index b8fb4f6..13e9220 100644
--- a/src/test/java/org/dcsa/core/ExtendedRequestTest.java
+++ b/src/test/java/org/dcsa/core/ExtendedRequestTest.java
@@ -53,7 +53,7 @@ public void testCustomerWithForeignKeyAddresses() {
 
     @Test
     public void testCustomerBook() {
-        String baseQuery = "SELECT customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\", customer_book_table.customer_id AS \"customer_id\""
+        String baseQuery = "SELECT customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.customer_id AS \"customer_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\""
                 + " FROM customer_book_table"
                 + " JOIN customer_table ON customer_book_table.customer_id = customer_table.customer_id"
                 + " JOIN address_table delivery_address ON customer_table.delivery_address_id = delivery_address.address_id"
@@ -63,7 +63,7 @@ public void testCustomerBook() {
 
     @Test
     public void testCityCustomerBook() {
-        String baseQuery = "SELECT city_table.id AS \"city.id\", city_table.city_name AS \"city.city_name\", city_table.country_id AS \"city.country_id\", customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.city_id AS \"city_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\", customer_book_table.customer_id AS \"customer_id\""
+        String baseQuery = "SELECT city_table.id AS \"city.id\", city_table.city_name AS \"city.city_name\", city_table.country_id AS \"city.country_id\", customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.city_id AS \"city_id\", customer_book_table.customer_id AS \"customer_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\""
                 + " FROM customer_book_table"
                 + " JOIN city_table ON customer_book_table.city_id = city_table.id"
                 + " JOIN customer_table ON customer_book_table.customer_id = customer_table.customer_id"
diff --git a/src/test/java/org/dcsa/core/QueryFactoryTest.java b/src/test/java/org/dcsa/core/QueryFactoryTest.java
new file mode 100644
index 0000000..abe375b
--- /dev/null
+++ b/src/test/java/org/dcsa/core/QueryFactoryTest.java
@@ -0,0 +1,191 @@
+package org.dcsa.core;
+
+import org.dcsa.core.mock.MockR2dbcDialect;
+import org.dcsa.core.models.combined.*;
+import org.dcsa.core.query.DBEntityAnalysis;
+import org.dcsa.core.query.QueryFactoryBuilder;
+import org.dcsa.core.query.impl.AbstractQueryFactory;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.data.domain.Sort;
+
+import java.time.OffsetDateTime;
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
+public class QueryFactoryTest {
+
+    private static final Pattern COLLAPSE_SPACE = Pattern.compile("\\s\\s++");
+    private static final Pattern PRETTY_PRINT_SPLIT =
+            Pattern.compile("\\s+(FROM|(?:LEFT|RIGHT)?\\s*(?:INNER|OUTER)?\\s*JOIN|WHERE|ORDER BY)\\s");
+
+    @Test
+    public void testCustomerWithAddress() {
+        String baseQuery = "SELECT customer_table.customer_id AS \"id\", customer_table.customer_name AS \"name\", address_table.street_name AS \"address\""
+                + " FROM customer_table"
+                + " JOIN address_table ON customer_table.address_id = address_table.address_id";
+        verify(CustomerWithAddress.class, baseQuery);
+    }
+
+    @Test
+    public void testCustomerWithForeignKeyAddresses() {
+        String baseQuery = "SELECT delivery_address.address_id AS \"deliveryAddress.address_id\", delivery_address.street_name AS \"deliveryAddress.street_name\", delivery_address.city_id AS \"deliveryAddress.city_id\", payment_address.address_id AS \"paymentAddress.address_id\", payment_address.street_name AS \"paymentAddress.street_name\", payment_address.city_id AS \"paymentAddress.city_id\", customer_table.customer_id AS \"customer_id\", customer_table.customer_name AS \"customer_name\", customer_table.delivery_address_id AS \"delivery_address_id\", customer_table.payment_address_id AS \"payment_address_id\""
+                + " FROM customer_table"
+                + " JOIN address_table delivery_address ON customer_table.delivery_address_id = delivery_address.address_id"
+                + " JOIN address_table payment_address ON customer_table.payment_address_id = payment_address.address_id";
+        verify(CustomerWithForeignKeyAddresses.class, baseQuery);
+    }
+
+    @Test
+    public void testCustomerBook() {
+        String baseQuery = "SELECT customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.customer_id AS \"customer_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\""
+                + " FROM customer_book_table"
+                + " JOIN customer_table ON customer_book_table.customer_id = customer_table.customer_id"
+                + " JOIN address_table delivery_address ON customer_table.delivery_address_id = delivery_address.address_id"
+                + " JOIN address_table payment_address ON customer_table.payment_address_id = payment_address.address_id";
+        verify(CustomerBook.class, baseQuery);
+    }
+
+    @Test
+    public void testCityCustomerBook() {
+        String baseQuery = "SELECT city_table.id AS \"city.id\", city_table.city_name AS \"city.city_name\", city_table.country_id AS \"city.country_id\", customer_table.customer_id AS \"customer.customer_id\", customer_table.customer_name AS \"customer.customer_name\", delivery_address.address_id AS \"customer.deliveryAddress.address_id\", delivery_address.street_name AS \"customer.deliveryAddress.street_name\", delivery_address.city_id AS \"customer.deliveryAddress.city_id\", customer_table.delivery_address_id AS \"customer.delivery_address_id\", payment_address.address_id AS \"customer.paymentAddress.address_id\", payment_address.street_name AS \"customer.paymentAddress.street_name\", payment_address.city_id AS \"customer.paymentAddress.city_id\", customer_table.payment_address_id AS \"customer.payment_address_id\", customer_book_table.city_id AS \"city_id\", customer_book_table.customer_id AS \"customer_id\", customer_book_table.customer_book_id AS \"customer_book_id\", customer_book_table.customer_book_name AS \"customer_book_name\""
+                + " FROM customer_book_table"
+                + " JOIN city_table ON customer_book_table.city_id = city_table.id"
+                + " JOIN customer_table ON customer_book_table.customer_id = customer_table.customer_id"
+                + " JOIN address_table delivery_address ON customer_table.delivery_address_id = delivery_address.address_id"
+                + " JOIN address_table payment_address ON customer_table.payment_address_id = payment_address.address_id";
+        verify(CityCustomerBook.class, baseQuery);
+    }
+
+    @Test
+    public void testOrderWithCustomerAndAddresses() {
+        String baseQuery = "SELECT order_table.orderline AS \"orderline\", customer_table.customer_name AS \"customerName\", customer_address.street_name AS \"customerAddress\", warehouse_address.street_name AS \"warehouseAddress\""
+                + " FROM order_table"
+                + " JOIN customer_table ON order_table.customer_id = customer_table.address_id"
+                + " JOIN address_table customer_address ON customer_table.address_id = customer_address.address_id"
+                + " JOIN address_table warehouse_address ON order_table.address_id = warehouse_address.address_id";
+
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<OrderInCountry>> baseBuilder = builderForClass(OrderInCountry.class)
+                .conditions().freeze();
+
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<OrderInCountry>> withWarehouse = baseBuilder.copyBuilder()
+                .fieldByJsonName("warehouse").equalTo("a").freeze();
+
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<OrderInCountry>> withWarehouseAndCustomerName = withWarehouse.copyBuilder()
+                .fieldByJsonName("customerName").equalTo("b").freeze();
+
+        verify(baseBuilder.copyBuilder().build(), baseQuery);
+
+        verify(withWarehouse.copyBuilder().build(),
+                baseQuery + " WHERE warehouse_address.street_name = :warehouse");
+
+        verify(withWarehouseAndCustomerName.copyBuilder().build(),
+                baseQuery
+                        + " WHERE warehouse_address.street_name = :warehouse"
+                        +  " AND customer_table.customer_name = :customerName"
+                );
+
+        verify(withWarehouseAndCustomerName.copyBuilder()
+                .fieldByJsonName("customerAddress").equalTo("c")
+                .withQuery()
+                .order((orderBuilder, dbAnalysis) -> orderBuilder.orderBy(
+                        dbAnalysis.getQueryFieldFromJSONName("customerAddress").asOrderByField(Sort.Direction.ASC),
+                        dbAnalysis.getQueryFieldFromJSONName("warehouse").asOrderByField(Sort.Direction.ASC)
+                )).build(),
+                baseQuery
+                        + " WHERE warehouse_address.street_name = :warehouse"
+                        + " AND customer_table.customer_name = :customerName"
+                        + " AND customer_address.street_name = :customerAddress"
+                        + " ORDER BY \"customerAddress\" ASC, \"warehouseAddress\" ASC"
+        );
+    }
+
+    @Test
+    public void testOrderByCountry() {
+        String baseQueryNoExtraJoins =
+                "SELECT order_table.orderline AS \"orderline\", customer_table.customer_name AS \"customerName\", customer_address.street_name AS \"customerAddress\", warehouse_address.street_name AS \"warehouseAddress\""
+                + " FROM order_table"
+                + " JOIN customer_table ON order_table.customer_id = customer_table.address_id"
+                + " JOIN address_table customer_address ON customer_table.address_id = customer_address.address_id"
+                + " JOIN address_table warehouse_address ON order_table.address_id = warehouse_address.address_id";
+        String extraJoins = " JOIN city_table ON customer_address.city_id = city_table.id"
+                +  " JOIN country_table ON city_table.country_id = country_table.id";
+
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<OrderInCountry>> builder = builderForClass(OrderInCountry.class)
+                .conditions().freeze();
+        verify(builder.copyBuilder().build(), baseQueryNoExtraJoins);
+
+        verify(builder.copyBuilder().fieldByJsonName("countryName").equalTo("dk").build(),
+                baseQueryNoExtraJoins + extraJoins + " WHERE country_table.country_name = :countryName");
+    }
+
+    @Test
+    public void testOrderWithEverything() {
+        String baseQueryNoExtraJoins =
+                "SELECT customer_table.customer_name AS \"customerName\", customer_address.street_name AS \"customerAddress\", warehouse_address.street_name AS \"warehouseAddress\", order_table.order_id AS \"order_id\", order_table.orderline AS \"orderline\", order_table.customer_id AS \"customer_id\", order_table.address_id AS \"address_id\", order_table.delivery_date AS \"delivery_date\""
+                        + " FROM order_table"
+                        + " JOIN customer_table ON order_table.customer_id = customer_table.address_id"
+                        + " JOIN address_table customer_address ON customer_table.address_id = customer_address.address_id"
+                        + " JOIN address_table warehouse_address ON order_table.address_id = warehouse_address.address_id";
+        String extraJoins = " JOIN city_table ON customer_address.city_id = city_table.id"
+                +  " JOIN country_table ON city_table.country_id = country_table.id";
+
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<OrderWithEverything>> builder = builderForClass(OrderWithEverything.class)
+                .conditions().freeze();
+
+        verify(builder.copyBuilder().build(), baseQueryNoExtraJoins);
+
+        verify(builder.copyBuilder().fieldByJsonName("countryName").equalTo("dk").build(),
+                baseQueryNoExtraJoins + extraJoins + " WHERE country_table.country_name = :countryName");
+    }
+
+    @Test
+    public void testExtendedOrder() {
+        String query =
+                "SELECT address_table.street_name AS \"warehouseAddress\", order_table.order_id AS \"order_id\", order_table.orderline AS \"orderline\", order_table.customer_id AS \"customer_id\", order_table.address_id AS \"address_id\", order_table.delivery_date AS \"delivery_date\""
+                        + " FROM order_table"
+                        + " JOIN address_table ON order_table.address_id = address_table.address_id";
+        QueryFactoryBuilder.FrozenBuilder<QueryFactoryBuilder.ConditionBuilder<ExtendedOrder>> builder = builderForClass(ExtendedOrder.class)
+                .conditions().freeze();
+
+        verify(builder.copyBuilder().build(), query);
+
+        verify(builder.copyBuilder().fieldByJsonName("deliveryDate").greaterThanOrEqualTo(OffsetDateTime.parse("2021-01-01T00:00:00Z")).build(),
+                query + " WHERE order_table.delivery_date >= :deliveryDate");
+    }
+
+    @Test
+    public void testExtendedOrderDistinct() {
+        String query =
+                "SELECT DISTINCT address_table.street_name AS \"warehouseAddress\", order_table.order_id AS \"order_id\", order_table.orderline AS \"orderline\", order_table.customer_id AS \"customer_id\", order_table.address_id AS \"address_id\", order_table.delivery_date AS \"delivery_date\""
+                        + " FROM order_table"
+                        + " JOIN address_table ON order_table.address_id = address_table.address_id";
+        verify(ExtendedOrder.class, builder -> builder.distinct().conditions().build(), query);
+    }
+
+
+    private static <T> QueryFactoryBuilder<T> builderForClass(Class<T> clazz) {
+        return QueryFactoryBuilder.builder(DBEntityAnalysis.builder(clazz).loadFieldsAndJoinsFromModel().build())
+                .r2dbcDialect(new MockR2dbcDialect());
+    }
+
+    private static <T> void verify(AbstractQueryFactory<T> factory, String expected) {
+        String generated = factory.generateSelectQuery().toQuery();
+        Assertions.assertEquals(prettifyQuery(expected), prettifyQuery(generated));
+    }
+
+    private static <T> void verify(Class<T> clazz, String expected) {
+        verify(clazz, b -> b.conditions().build(), expected);
+    }
+
+
+    private static <T> void verify(Class<T> clazz, Function<QueryFactoryBuilder<T>, AbstractQueryFactory<T>> mutator, String expected) {
+        verify(mutator.apply(builderForClass(clazz)), expected);
+    }
+
+    // makes IntelliJ's "show differences" view more useful in case of a mismatch
+    private static String prettifyQuery(String text) {
+        String intermediate = COLLAPSE_SPACE.matcher(text).replaceAll(" ");
+        return PRETTY_PRINT_SPLIT.matcher(intermediate).replaceAll("\n $1 ");
+    }
+}
diff --git a/src/test/java/org/dcsa/core/models/AbstractCustomerBook.java b/src/test/java/org/dcsa/core/models/AbstractCustomerBook.java
index 5f3c8a1..2c6d8ea 100644
--- a/src/test/java/org/dcsa/core/models/AbstractCustomerBook.java
+++ b/src/test/java/org/dcsa/core/models/AbstractCustomerBook.java
@@ -1,4 +1,17 @@
 package org.dcsa.core.models;
 
+import lombok.Data;
+import org.springframework.data.relational.core.mapping.Column;
+
+@Data
 public abstract class AbstractCustomerBook {
+    @Column("customer_book_id")
+    private Long id;
+
+    @Column("customer_book_name")
+    private String name;
+
+    @Column("customer_id")
+    private Long customerId;
+
 }
diff --git a/src/test/java/org/dcsa/core/models/combined/CustomerBook.java b/src/test/java/org/dcsa/core/models/combined/CustomerBook.java
index d26a3a3..7097980 100644
--- a/src/test/java/org/dcsa/core/models/combined/CustomerBook.java
+++ b/src/test/java/org/dcsa/core/models/combined/CustomerBook.java
@@ -1,6 +1,8 @@
 package org.dcsa.core.models.combined;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
 import org.dcsa.core.model.ForeignKey;
 import org.dcsa.core.models.AbstractCustomerBook;
 import org.springframework.data.annotation.Transient;
@@ -9,13 +11,11 @@
 
 @Data
 @Table("customer_book_table")
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
 public class CustomerBook extends AbstractCustomerBook {
-    @Column("customer_book_id")
-    private Long id;
-
-    @Column("customer_book_name")
-    private String name;
 
+    // Shadows super class field deliberately to test that this does not cause issue.
     @Column("customer_id")
     @ForeignKey(into="customer", foreignFieldName="id")
     private Long customerId;