Added generic query manager tests

lib/src/main/java/rife/database/types/SqlConversion.java

@@ -11,13 +11,13 @@ import rife.validation.Constrained;
 import java.sql.ResultSet;
 
 public interface SqlConversion {
-    public String getSqlValue(Object value);
+    String getSqlValue(Object value);
 
-    public String getSqlType(Class type, int precision, int scale);
+    String getSqlType(Class type, int precision, int scale);
 
-    public Object getTypedObject(ResultSet resultSet, int columnNumber, int type, Class targetType)
+    Object getTypedObject(ResultSet resultSet, int columnNumber, int type, Class targetType)
     throws DatabaseException;
 
-    public void setTypedParameter(DbPreparedStatement statement, int parameterIndex, Class targetType, String name, Object value, Constrained constrained)
+    void setTypedParameter(DbPreparedStatement statement, int parameterIndex, Class targetType, String name, Object value, Constrained constrained)
     throws DatabaseException;
 }

lib/src/main/java/rife/database/types/databasedrivers/Common.java

@@ -144,7 +144,7 @@ public abstract class Common implements SqlConversion {
                         } else if (targetType.isEnum()) {
                             return Enum.valueOf(targetType, result.toString());
                         } else if (targetType == UUID.class) {
-                            return result.toString();
+                            return UUID.fromString(result.toString());
                         } else {
                             return null;
                         }

lib/src/test/java/rife/database/querymanagers/generic/AggregatingCallbacksBeanListener.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import rife.database.querymanagers.generic.beans.CallbacksBean;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class AggregatingCallbacksBeanListener implements GenericQueryManagerListener<CallbacksBean> {
+    private Map<String, Object> mHistory = new LinkedHashMap<String, Object>();
+
+    public void clearHistory() {
+        mHistory.clear();
+    }
+
+    public Map<String, Object> getHistory() {
+        return mHistory;
+    }
+
+    public void installed() {
+        mHistory.put("installed" + mHistory.size(), null);
+    }
+
+    public void removed() {
+        mHistory.put("removed" + mHistory.size(), null);
+    }
+
+    public void inserted(CallbacksBean bean) {
+        mHistory.put("inserted" + mHistory.size(), bean);
+        bean.setTestString("listener inserted");
+    }
+
+    public void updated(CallbacksBean bean) {
+        mHistory.put("updated" + mHistory.size(), bean);
+        bean.setTestString("listener updated");
+    }
+
+    public void restored(CallbacksBean bean) {
+        mHistory.put("restored" + mHistory.size(), bean);
+        bean.setTestString("listener restored");
+    }
+
+    public void deleted(int objectId) {
+        mHistory.put("deleted" + mHistory.size(), objectId);
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/TestCountQuery.java

@@ -0,0 +1,654 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.exceptions.UnsupportedSqlFeatureException;
+import rife.database.queries.Select;
+import rife.database.querymanagers.generic.beans.BeanImpl;
+import rife.database.querymanagers.generic.beans.LinkBean;
+import rife.database.querymanagers.generic.beans.SimpleBean;
+
+import java.math.BigDecimal;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestCountQuery {
+    private GenericQueryManager<SimpleBean> manager_ = null;
+    private GenericQueryManager<LinkBean> linkManager_ = null;
+    private GenericQueryManager<BeanImpl> bigBeanManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        manager_ = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class);
+        linkManager_ = GenericQueryManagerFactory.getInstance(datasource, LinkBean.class);
+        bigBeanManager_ = GenericQueryManagerFactory.getInstance(datasource, BeanImpl.class);
+        manager_.install();
+        linkManager_.install();
+        bigBeanManager_.install();
+    }
+
+    protected void tearDown() {
+        manager_.remove();
+        linkManager_.remove();
+        bigBeanManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testCloneToStringAndClear(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var query = manager_.getCountQuery().where("testString", "=", "bean set 1");
+
+            assertEquals(query.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'");
+
+            var query_clone = query.clone();
+
+            assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'");
+
+            query_clone.where("testString", "!=", "bean set 2");
+
+            assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1' AND testString != 'bean set 2'");
+
+            query_clone.clear();
+
+            assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'");
+
+            query.clear();
+
+            assertEquals(query.toString(), "SELECT count(*) FROM SimpleBean");
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetDatasource(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertEquals(datasource, manager_.getCountQuery().getDatasource());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetFrom(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertEquals(manager_
+                .getCountQuery()
+                .getFrom(), SimpleBean.class
+                .getName()
+                .replaceAll(SimpleBean.class
+                                .getPackage()
+                                .getName() + ".", ""));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetParameters(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var select = new Select(datasource);
+            select
+                .from("simplebean")
+                .whereParameter("testString", "=");
+
+            var query = new CountQuery(select);
+
+            assertEquals(query.getParameters().getOrderedNames().size(), 1);
+            assertTrue(query.getParameters().getOrderedNames().contains("testString"));
+
+            assertEquals(query.getParameters().getOrderedNamesArray().length, 1);
+            assertEquals(query.getParameters().getOrderedNamesArray()[0], "testString");
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testJoin(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var linkbean1 = new LinkBean();
+            var linkbean2 = new LinkBean();
+
+            linkbean1.setTestString("linkbean 1");
+            linkbean2.setTestString("linkbean 2");
+
+            linkManager_.save(linkbean1);
+            linkManager_.save(linkbean2);
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(linkbean1.getId());
+            bean2.setLinkBean(linkbean1.getId());
+            bean3.setLinkBean(linkbean1.getId());
+            bean4.setLinkBean(linkbean2.getId());
+            bean5.setLinkBean(linkbean2.getId());
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var table = manager_.getTable();
+            var table2 = linkManager_.getTable();
+
+            var query = manager_.getCountQuery()
+                .join(table2)
+                .where(table2 + ".id = " + table + ".linkBean")
+                .whereAnd(table + ".linkBean", "=", linkbean2.getId());
+
+            assertEquals(2, manager_.count(query));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testJoinCross(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var linkbean1 = new LinkBean();
+            var linkbean2 = new LinkBean();
+
+            linkbean1.setTestString("linkbean 1");
+            linkbean2.setTestString("linkbean 2");
+
+            linkManager_.save(linkbean1);
+            linkManager_.save(linkbean2);
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(linkbean1.getId());
+            bean2.setLinkBean(linkbean1.getId());
+            bean3.setLinkBean(linkbean1.getId());
+            bean4.setLinkBean(linkbean2.getId());
+            bean5.setLinkBean(linkbean2.getId());
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var table = manager_.getTable();
+            var table2 = linkManager_.getTable();
+
+            var query = manager_.getCountQuery()
+                .joinCross(table2)
+                .where(table2 + ".id = " + table + ".linkBean")
+                .whereAnd(table + ".linkBean", "=", linkbean2.getId());
+
+            try {
+                assertEquals(2, manager_.count(query));
+
+                if ("org.hsqldb.jdbcDriver".equals(datasource.getAliasedDriver()) ||
+                    "org.apache.derby.jdbc.EmbeddedDriver".equals(datasource.getAliasedDriver())) {
+                    fail();
+                }
+            } catch (UnsupportedSqlFeatureException e) {
+                assertEquals("CROSS JOIN", e.getFeature());
+                assertTrue("org.hsqldb.jdbcDriver".equals(e.getDriver()) ||
+                           "org.apache.derby.jdbc.EmbeddedDriver".equals(e.getDriver()));
+            }
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testJoinInner(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var link_bean1 = new LinkBean();
+            var link_bean2 = new LinkBean();
+
+            link_bean1.setTestString("linkbean 1");
+            link_bean2.setTestString("linkbean 2");
+
+            linkManager_.save(link_bean1);
+            linkManager_.save(link_bean2);
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(link_bean1.getId());
+            bean2.setLinkBean(link_bean1.getId());
+            bean3.setLinkBean(link_bean1.getId());
+            bean4.setLinkBean(link_bean2.getId());
+            bean5.setLinkBean(link_bean2.getId());
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var table = manager_.getTable();
+            var table2 = linkManager_.getTable();
+
+            var query = manager_.getCountQuery()
+                .joinInner(table2, Select.ON, "0 = 0") // evals to true for mysql sake
+                .where(table2 + ".id = " + table + ".linkBean")
+                .whereAnd(table + ".linkBean", "=", link_bean2.getId());
+
+            assertEquals(2, manager_.count(query));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testJoinOuter(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var link_bean1 = new LinkBean();
+            var link_bean2 = new LinkBean();
+
+            link_bean1.setTestString("linkbean 1");
+            link_bean2.setTestString("linkbean 2");
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(1);
+            bean2.setLinkBean(1);
+            bean3.setLinkBean(1);
+            bean4.setLinkBean(2);
+            bean5.setLinkBean(2);
+
+            linkManager_.save(link_bean1);
+            linkManager_.save(link_bean2);
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var table = manager_.getTable();
+            var table2 = linkManager_.getTable();
+
+            var query = manager_.getCountQuery()
+                .joinOuter(table2, Select.LEFT, Select.ON, table2 + ".id = " + table + ".linkBean") // evals to true for mysql sake
+                .where(table + ".linkBean = 2");
+
+            assertEquals(2, manager_.count(query));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testJoinCustom(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var link_bean1 = new LinkBean();
+            var link_bean2 = new LinkBean();
+
+            link_bean1.setTestString("linkbean 1");
+            link_bean2.setTestString("linkbean 2");
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(1);
+            bean2.setLinkBean(1);
+            bean3.setLinkBean(1);
+            bean4.setLinkBean(2);
+            bean5.setLinkBean(2);
+
+            linkManager_.save(link_bean1);
+            linkManager_.save(link_bean2);
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var table = manager_.getTable();
+            var table2 = linkManager_.getTable();
+
+            var query = manager_.getCountQuery()
+                .joinCustom("LEFT OUTER JOIN " + table2 + " ON " + table2 + ".id = " + table + ".linkBean") // evals to true for mysql sake
+                .where(table + ".linkBean = 2");
+
+            assertEquals(2, manager_.count(query));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhere(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            bigBeanManager_.save(bean1);
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyString = 'nostringhere'")));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyBoolean", "=", false)));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyByte", "=", (byte) 90)));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyChar", "=", 'w')));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyDouble", "=", 37478.34d)));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("ABS(propertyFloat - 34241.2) < 0.001")));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyLong", "=", 23432L)));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyShort", "=", (short) 44)));
+
+            // cheating because the GQM doesn't currently return any queries with a where clause already
+            var query = new CountQuery(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).getDelegate());
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyString = 'nostringhere'")));
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyBoolean", "=", false)));
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyByte", "=", (byte) 90)));
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyChar", "=", 'w')));
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyDouble", "=", 37478.34d)));
+
+            assertEquals(1, bigBeanManager_.count(query.where("ABS(propertyFloat - 34241.2) < 0.001")));
+
+            assertEquals(1, bigBeanManager_.count(query.where("id", "=", bean1.getId()))); // primary key
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyLong", "=", 23432L)));
+
+            assertEquals(1, bigBeanManager_.count(query.where("propertyShort", "=", (short) 44)));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereAnd(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            bigBeanManager_.save(bean1);
+
+            assertEquals(1, bigBeanManager_.count(
+                bigBeanManager_.getCountQuery()
+                    .where("id", "=", bean1.getId())
+                    .whereAnd("propertyString = 'nostringhere'")
+                    .whereAnd("propertyBoolean", "=", false)
+                    .whereAnd("propertyByte", "=", (byte) 90)
+                    .whereAnd("propertyChar", "=", 'w')
+                    .whereAnd("propertyDouble", "=", 37478.34d)
+                    .whereAnd("propertyLong", "=", 23432L)
+                    .whereAnd("propertyString", "=", "nostringhere")
+                    .whereAnd("propertyIntegerObject", "=", 421)
+                    .whereAnd("propertyShort", "=", (short) 44)
+            ));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).whereAnd("ABS(propertyFloat - 34241.2) < 0.001")));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereOr(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            bigBeanManager_.save(bean1);
+
+            assertEquals(1, bigBeanManager_.count(
+                bigBeanManager_.getCountQuery()
+                    .where("id", "=", bean1.getId())
+                    .whereOr("propertyString = 'nostringhere'")
+                    .whereOr("propertyBoolean", "=", false)
+                    .whereOr("propertyByte", "=", (byte) 90)
+                    .whereOr("propertyChar", "=", 'w')
+                    .whereOr("propertyDouble", "=", 37478.34d)
+                    .whereOr("propertyLong", "=", 23432L)
+                    .whereOr("propertyIntegerObject", "=", 421)
+                    .whereOr("propertyShort", "=", (short) 44)
+                    .whereOr("propertyString", "=", "nostringhere")
+            ));
+
+            assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).whereOr("ABS(propertyFloat - 34241.2) < 0.001")));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testUnion(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var query = manager_.getCountQuery();
+
+            query
+                .union("uexpr1")
+                .union(new Select(datasource).field("count(*)").from("table2"));
+
+
+            assertEquals(query.getSql(), "SELECT count(*) FROM SimpleBean UNION uexpr1 UNION SELECT count(*) FROM table2");
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereSubSelect(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var linkbean1 = new LinkBean();
+            var linkbean2 = new LinkBean();
+
+            linkbean1.setTestString("linkbean 1");
+            linkbean2.setTestString("linkbean 2");
+
+            linkManager_.save(linkbean1);
+            linkManager_.save(linkbean2);
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(linkbean1.getId());
+            bean2.setLinkBean(linkbean1.getId());
+            bean3.setLinkBean(linkbean1.getId());
+            bean4.setLinkBean(linkbean2.getId());
+            bean5.setLinkBean(linkbean2.getId());
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var select = new Select(datasource);
+            select
+                .from(linkManager_.getTable())
+                .field("id")
+                .where("id", "=", linkbean1.getId());
+
+            var query = manager_.getCountQuery();
+            query
+                .where("linkBean = (" + select.getSql() + ")")
+                .whereSubselect(select);
+
+            assertEquals(3, manager_.count(query));
+        } finally {
+            tearDown();
+        }
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/TestDeleteQuery.java

@@ -0,0 +1,441 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.queries.Delete;
+import rife.database.queries.Select;
+import rife.database.querymanagers.generic.beans.BeanImpl;
+import rife.database.querymanagers.generic.beans.LinkBean;
+import rife.database.querymanagers.generic.beans.SimpleBean;
+
+import java.math.BigDecimal;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class TestDeleteQuery {
+    private GenericQueryManager<BeanImpl> bigBeanManager_ = null;
+    private GenericQueryManager<SimpleBean> manager_ = null;
+    private GenericQueryManager<LinkBean> linkManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        manager_ = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class);
+        linkManager_ = GenericQueryManagerFactory.getInstance(datasource, LinkBean.class);
+        bigBeanManager_ = GenericQueryManagerFactory.getInstance(datasource, BeanImpl.class);
+        manager_.install();
+        linkManager_.install();
+        bigBeanManager_.install();
+    }
+
+    protected void tearDown() {
+        manager_.remove();
+        linkManager_.remove();
+        bigBeanManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testCloneToStringAndClear(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var query = bigBeanManager_.getDeleteQuery().where("propertyString", "=", "bean set 1");
+
+            assertEquals(query.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'");
+
+            var query_clone = query.clone();
+
+            assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'");
+
+            query_clone.where("propertyString", "!=", "bean set 2");
+
+            assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1' AND propertyString != 'bean set 2'");
+
+            query_clone.clear();
+
+            assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'");
+
+            query.clear();
+
+            assertEquals(query.toString(), "DELETE FROM BeanImpl");
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetParameters(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var delete = new Delete(datasource);
+            delete
+                .from("simplebean")
+                .whereParameter("testString", "=");
+
+            var query = new DeleteQuery(delete);
+
+            assertEquals(query.getParameters().getOrderedNames().size(), 1);
+            assertTrue(query.getParameters().getOrderedNames().contains("testString"));
+
+            assertEquals(query.getParameters().getOrderedNamesArray().length, 1);
+            assertEquals(query.getParameters().getOrderedNamesArray()[0], "testString");
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetDatasource(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertEquals(datasource, bigBeanManager_.getDeleteQuery().getDatasource());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetFrom(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertEquals(bigBeanManager_
+                .getDeleteQuery()
+                .getFrom(), BeanImpl.class
+                .getName()
+                .replaceAll(BeanImpl.class
+                                .getPackage()
+                                .getName() + ".", ""));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhere(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            var bean1id = bigBeanManager_.save(bean1);
+            bigBeanManager_.save(BeanImpl.getPopulatedBean());
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyString = 'nostringhere'"));
+            var list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyBoolean", "=", false));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyByte", "=", (byte) 90));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyChar", "=", 'w'));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyDouble", "=", 37478.34d));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("ABS(propertyFloat - 34241.2) < 0.001"));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyLong", "=", 23432L));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyShort", "=", (short) 44));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+
+            var query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyString = 'nostringhere'"));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyBoolean", "=", false));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyByte", "=", (byte) 90));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyChar", "=", 'w'));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyDouble", "=", 37478.34d));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("ABS(propertyFloat - 34241.2) < 0.001"));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("id", "=", bean1id)); // primary key
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyLong", "=", 23432L));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+            bean1id = bigBeanManager_.save(bean1);
+            query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate());
+
+            bigBeanManager_.delete(query.where("propertyShort", "=", (short) 44));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereAnd(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            var bean1id = bigBeanManager_.save(bean1);
+            bigBeanManager_.save(BeanImpl.getPopulatedBean());
+
+            bigBeanManager_.delete(
+                bigBeanManager_.getDeleteQuery()
+                    .where("id", "=", bean1id)
+                    .whereAnd("propertyString = 'nostringhere'")
+                    .whereAnd("propertyBoolean", "=", false)
+                    .whereAnd("propertyByte", "=", (byte) 90)
+                    .whereAnd("propertyChar", "=", 'w')
+                    .whereAnd("propertyDouble", "=", 37478.34d)
+                    .whereAnd("propertyLong", "=", 23432L)
+                    .whereAnd("propertyString", "=", "nostringhere")
+                    .whereAnd("propertyIntegerObject", "=", 421)
+                    .whereAnd("propertyShort", "=", (short) 44)
+            );
+
+            var list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+
+            bean1id = bigBeanManager_.save(bean1);
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).whereAnd("ABS(propertyFloat - 34241.2) < 0.001"));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereOr(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new BeanImpl();
+
+            var cal = Calendar.getInstance();
+            cal.set(2004, Calendar.JULY, 19, 16, 27, 15);
+            cal.set(Calendar.MILLISECOND, 765);
+            bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483"));
+            bean1.setPropertyBoolean(false);
+            bean1.setPropertyBooleanObject(true);
+            bean1.setPropertyByte((byte) 90);
+            bean1.setPropertyByteObject((byte) 35);
+            bean1.setPropertyCalendar(cal);
+            bean1.setPropertyChar('w');
+            bean1.setPropertyCharacterObject('s');
+            bean1.setPropertyDate(cal.getTime());
+            bean1.setPropertyDouble(37478.34d);
+            bean1.setPropertyDoubleObject(384724.692d);
+            bean1.setPropertyFloat(34241.2f);
+            bean1.setPropertyFloatObject(3432.7f);
+            bean1.setPropertyLong(23432L);
+            bean1.setPropertyLongObject(23423L);
+            bean1.setPropertyShort((short) 44);
+            bean1.setPropertyShortObject((short) 69);
+            bean1.setPropertyIntegerObject(421);
+            bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+            bean1.setPropertyString("nostringhere");
+            bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff"));
+            bean1.setPropertyTime(new Time(cal.getTime().getTime()));
+            bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+            var bean1id = bigBeanManager_.save(bean1);
+            bigBeanManager_.save(BeanImpl.getPopulatedBean());
+
+            bigBeanManager_.delete(
+                bigBeanManager_.getDeleteQuery()
+                    .where("id", "=", bean1id)
+                    .whereOr("propertyString = 'nostringhere'")
+                    .whereOr("propertyBoolean", "=", false)
+                    .whereOr("propertyByte", "=", (byte) 90)
+                    .whereOr("propertyChar", "=", 'w')
+                    .whereOr("propertyDouble", "=", 37478.34d)
+                    .whereOr("propertyLong", "=", 23432L)
+                    .whereOr("propertyIntegerObject", "=", 421)
+                    .whereOr("propertyShort", "=", (short) 44)
+                    .whereOr("propertyString", "=", "nostringhere")
+            );
+
+            var list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+
+            bean1id = bigBeanManager_.save(bean1);
+
+            bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).whereOr("ABS(propertyFloat - 34241.2) < 0.001"));
+            list = bigBeanManager_.restore();
+            assertEquals(list.size(), 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testWhereSubselect(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            var link_bean1 = new LinkBean();
+            var link_bean2 = new LinkBean();
+
+            link_bean1.setTestString("linkbean 1");
+            link_bean2.setTestString("linkbean 2");
+
+            linkManager_.save(link_bean1);
+            linkManager_.save(link_bean2);
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            bean1.setLinkBean(link_bean1.getId());
+            bean2.setLinkBean(link_bean1.getId());
+            bean3.setLinkBean(link_bean1.getId());
+            bean4.setLinkBean(link_bean2.getId());
+            bean5.setLinkBean(link_bean2.getId());
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            var select = new Select(datasource);
+            select
+                .from(linkManager_.getTable())
+                .field("id")
+                .where("id", "=", link_bean1.getId());
+
+            var query = manager_.getDeleteQuery();
+            query
+                .where("linkBean = (" + select.getSql() + ")")
+                .whereSubselect(select);
+
+            manager_.delete(query);
+            var list = manager_.restore();
+            assertEquals(list.size(), 2);
+        } finally {
+            tearDown();
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerBinary.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.querymanagers.generic.beans.BinaryBean;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerBinary {
+    protected GenericQueryManager<BinaryBean> setUp(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, BinaryBean.class);
+        manager.install();
+        return manager;
+    }
+
+    protected void tearDown(GenericQueryManager<BinaryBean> manager) {
+        manager.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            assertSame(BinaryBean.class, manager.getBaseClass());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreBinary(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean = new BinaryBean();
+            BinaryBean newbean = null;
+
+            var bytes1 = new byte[]{1, 3, 5, 7, 11, 13, 17, 19, 23};
+            bean.setTheBytes(bytes1);
+
+            var id = manager.save(bean);
+
+            newbean = manager.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+            assertArrayEquals(newbean.getTheBytes(), bean.getTheBytes());
+            assertEquals(newbean.getId(), id);
+
+            var bytes2 = new byte[]{10, 30, 50, 70, 110};
+            bean.setId(id);
+            bean.setTheBytes(bytes2);
+
+            assertEquals(manager.save(bean), id);
+            assertEquals(bean.getId(), id);
+
+            newbean = manager.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+
+            assertArrayEquals(newbean.getTheBytes(), bytes2);
+
+            var bytes3 = new byte[]{89, 22, 9, 31, 89};
+            bean.setId(999999);
+            bean.setTheBytes(bytes3);
+
+            assertNotEquals(999999, manager.save(bean));
+            assertEquals(bean.getId(), id + 1);
+
+            var manager_othertable = GenericQueryManagerFactory.getInstance(datasource, BinaryBean.class, "othertable");
+            manager_othertable.install();
+
+            var bytes4 = new byte[]{79, 15, 88, 42};
+            var bean2 = new BinaryBean();
+            bean2.setTheBytes(bytes4);
+
+            manager_othertable.save(bean2);
+
+            var bean3 = manager_othertable.restore(bean2.getId());
+
+            assertArrayEquals(bean3.getTheBytes(), bean2.getTheBytes());
+
+            manager_othertable.remove();
+        } finally {
+            tearDown(manager);
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerCallbacks.java

@@ -0,0 +1,960 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.querymanagers.generic.beans.*;
+import rife.tools.StringUtils;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerCallbacks {
+    protected GenericQueryManager<CallbacksBean> setUpCallbacksBeanManager(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksBean.class);
+        try {
+            var listener = new AggregatingCallbacksBeanListener();
+            manager.addListener(listener);
+            manager.install();
+            assertEquals(1, listener.getHistory().size());
+            assertEquals("installed0", listener.getHistory().entrySet().iterator().next().getKey());
+        } finally {
+            manager.removeListeners();
+        }
+        return manager;
+    }
+
+    protected void tearDownCallbacksBean(GenericQueryManager<CallbacksBean> manager) {
+        try {
+            var listener = new AggregatingCallbacksBeanListener();
+            manager.addListener(listener);
+            manager.remove();
+            assertEquals(1, listener.getHistory().size());
+            assertEquals("removed0", listener.getHistory().entrySet().iterator().next().getKey());
+        } finally {
+            manager.removeListeners();
+        }
+    }
+
+    protected GenericQueryManager<CallbacksSparseBean> setUpCallbacksSparseBeanManager(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksSparseBean.class);
+        manager.install();
+        return manager;
+    }
+
+    protected void tearDownCallbacksSparseBean(GenericQueryManager<CallbacksSparseBean> manager) {
+        manager.remove();
+    }
+
+    protected GenericQueryManager<CallbacksProviderBean> setUpCallbacksProviderBeanManager(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksProviderBean.class);
+        manager.install();
+        return manager;
+    }
+
+    protected void tearDownCallbacksProviderBean(GenericQueryManager<CallbacksProviderBean> manager) {
+        manager.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            assertSame(CallbacksBean.class, manager.getBaseClass());
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClassSparse(Datasource datasource) {
+        var manager = setUpCallbacksSparseBeanManager(datasource);
+        try {
+            assertSame(CallbacksSparseBean.class, manager.getBaseClass());
+        } finally {
+            tearDownCallbacksSparseBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClassProvider(Datasource datasource) {
+        var manager = setUpCallbacksProviderBeanManager(datasource);
+        try {
+            assertSame(CallbacksProviderBean.class, manager.getBaseClass());
+        } finally {
+            tearDownCallbacksProviderBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuerySparse(Datasource datasource) {
+        var manager = setUpCallbacksSparseBeanManager(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDownCallbacksSparseBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQueryProvider(Datasource datasource) {
+        var manager = setUpCallbacksProviderBeanManager(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDownCallbacksProviderBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidateCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            manager.validate(bean);
+            assertEquals("beforeValidate -1;This is my test string\n" +
+                         "afterValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            manager.validate(bean);
+            assertEquals("beforeValidate -1;This is a new test string\n" +
+                         "afterValidate -1;This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            manager.validate(bean);
+            assertEquals("beforeValidate 999999;This is another test string\n" +
+                         "afterValidate 999999;This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidateCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            bean.setBeforeValidateReturn(false);
+            manager.validate(bean);
+            assertEquals("beforeValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeValidateReturn(true);
+            bean.setAfterValidateReturn(false);
+            manager.validate(bean);
+            assertEquals("beforeValidate -1;This is my test string\n" +
+                         "afterValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            var id = manager.save(bean);
+            assertEquals("beforeSave -1;This is my test string\n" +
+                         "beforeInsert -1;This is my test string\n" +
+                         "afterInsert true " + id + ";This is my test string\n" +
+                         "afterSave true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            id = manager.save(bean);
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string\n" +
+                         "afterUpdate true " + id + ";This is a new test string\n" +
+                         "afterSave true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            id = manager.save(bean);
+            assertEquals("beforeSave 999999;This is another test string\n" +
+                         "beforeUpdate 999999;This is another test string\n" +
+                         "afterUpdate false 999999;This is another test string\n" +
+                         "beforeInsert 999999;This is another test string\n" +
+                         "afterInsert true " + id + ";This is another test string\n" +
+                         "afterSave true " + id + ";This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            // test immediate inserts
+            bean.setBeforeSaveReturn(false);
+            manager.save(bean);
+            assertEquals("beforeSave -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertNull(manager.restore(1));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeSaveReturn(true);
+            bean.setBeforeInsertReturn(false);
+            manager.save(bean);
+            assertEquals("beforeSave -1;This is my test string\n" +
+                         "beforeInsert -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertNull(manager.restore(1));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeInsertReturn(true);
+            bean.setAfterInsertReturn(false);
+            var id = manager.save(bean);
+            assertEquals("beforeSave -1;This is my test string\n" +
+                         "beforeInsert -1;This is my test string\n" +
+                         "afterInsert true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertNotNull(manager.restore(id));
+
+            // test updates
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            bean.setBeforeUpdateReturn(false);
+            bean.setAfterInsertReturn(true);
+            assertEquals(-1, manager.save(bean));
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertEquals("This is my test string", manager.restore(id).getTestString());
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeUpdateReturn(true);
+            bean.setAfterUpdateReturn(false);
+            assertEquals(id, manager.save(bean));
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string\n" +
+                         "afterUpdate true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertEquals("This is a new test string", manager.restore(id).getTestString());
+
+            // test insert after failed update
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            bean.setAfterUpdateReturn(true);
+            bean.setBeforeInsertReturn(false);
+
+            assertEquals(-1, manager.save(bean));
+            assertEquals("""
+                beforeSave 999999;This is another test string
+                beforeUpdate 999999;This is another test string
+                afterUpdate false 999999;This is another test string
+                beforeInsert 999999;This is another test string""", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertNull(manager.restore(999999));
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeInsertReturn(true);
+            bean.setAfterInsertReturn(false);
+
+            assertEquals(id + 1, manager.save(bean));
+            id = id + 1;
+            assertEquals("beforeSave 999999;This is another test string\n" +
+                         "beforeUpdate 999999;This is another test string\n" +
+                         "afterUpdate false 999999;This is another test string\n" +
+                         "beforeInsert 999999;This is another test string\n" +
+                         "afterInsert true " + id + ";This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            assertNotNull(manager.restore(id));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveCallbacksSparse(Datasource datasource) {
+        var manager = setUpCallbacksSparseBeanManager(datasource);
+        try {
+            var bean = new CallbacksSparseBean();
+
+            bean.setId(1000);
+            bean.setTestString("Test String");
+
+            var id = manager.save(bean);
+            assertEquals("beforeSave " + id + ";Test String\n" +
+                         "beforeInsert " + id + ";Test String\n" +
+                         "afterInsert true " + id + ";Test String\n" +
+                         "afterSave true " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            id = manager.save(bean);
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeInsert " + id + ";This is a new test string\n" +
+                         "afterInsert false " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string\n" +
+                         "afterUpdate true " + id + ";This is a new test string\n" +
+                         "afterSave true " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksSparseBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveCallbacksSparseReturns(Datasource datasource) {
+        var manager = setUpCallbacksSparseBeanManager(datasource);
+        try {
+            var bean = new CallbacksSparseBean();
+
+            bean.setId(1000);
+            bean.setTestString("Test String");
+
+            var id = 1000;
+
+            // test immediate insert
+            bean.setBeforeSaveReturn(false);
+            assertEquals(-1, manager.save(bean));
+            assertEquals("beforeSave " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeSaveReturn(true);
+            bean.setBeforeInsertReturn(false);
+
+            assertEquals(-1, manager.save(bean));
+            assertEquals("beforeSave " + id + ";Test String\n" +
+                         "beforeInsert " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeInsertReturn(true);
+            bean.setAfterInsertReturn(false);
+
+            assertEquals(id, manager.save(bean));
+            assertEquals("beforeSave " + id + ";Test String\n" +
+                         "beforeInsert " + id + ";Test String\n" +
+                         "afterInsert true " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+
+            // test update after failed insert
+            bean.setTestString("This is a new test string");
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.setAfterInsertReturn(true);
+            bean.setBeforeUpdateReturn(false);
+
+            assertEquals(-1, manager.save(bean));
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeInsert " + id + ";This is a new test string\n" +
+                         "afterInsert false " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+
+            bean.setBeforeUpdateReturn(true);
+            bean.setAfterUpdateReturn(false);
+
+            assertEquals(id, manager.save(bean));
+            assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                         "beforeInsert " + id + ";This is a new test string\n" +
+                         "afterInsert false " + id + ";This is a new test string\n" +
+                         "beforeUpdate " + id + ";This is a new test string\n" +
+                         "afterUpdate true " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksSparseBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveListeners(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var listener = new AggregatingCallbacksBeanListener();
+            manager.addListener(listener);
+            try {
+                var bean = new CallbacksBean();
+
+                bean.setTestString("This is my test string");
+
+                var id = manager.save(bean);
+                var history = listener.getHistory();
+                assertEquals(1, history.size());
+                var entry = history.entrySet().iterator().next();
+                assertEquals("inserted0", entry.getKey());
+                assertSame(bean, entry.getValue());
+                assertEquals("beforeSave -1;This is my test string\n" +
+                             "beforeInsert -1;This is my test string\n" +
+                             "afterInsert true " + id + ";listener inserted\n" +
+                             "afterSave true " + id + ";listener inserted", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                CallbacksBean.clearExecuteCallbacks();
+                listener.clearHistory();
+                assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                bean.setTestString("This is a new test string");
+
+                id = manager.save(bean);
+                assertEquals(1, history.size());
+                entry = history.entrySet().iterator().next();
+                assertEquals("updated0", entry.getKey());
+                assertSame(bean, entry.getValue());
+                assertEquals("beforeSave " + id + ";This is a new test string\n" +
+                             "beforeUpdate " + id + ";This is a new test string\n" +
+                             "afterUpdate true " + id + ";listener updated\n" +
+                             "afterSave true " + id + ";listener updated", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                CallbacksBean.clearExecuteCallbacks();
+                listener.clearHistory();
+                assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                bean.setId(999999);
+                bean.setTestString("This is another test string");
+
+                id = manager.save(bean);
+                assertEquals(1, history.size());
+                entry = history.entrySet().iterator().next();
+                assertEquals("inserted0", entry.getKey());
+                assertSame(bean, entry.getValue());
+                assertEquals("beforeSave 999999;This is another test string\n" +
+                             "beforeUpdate 999999;This is another test string\n" +
+                             "afterUpdate false 999999;This is another test string\n" +
+                             "beforeInsert 999999;This is another test string\n" +
+                             "afterInsert true " + id + ";listener inserted\n" +
+                             "afterSave true " + id + ";listener inserted", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            } finally {
+                manager.removeListeners();
+            }
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInsertCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            var id = manager.insert(bean);
+            assertEquals("beforeInsert -1;This is my test string\n" +
+                         "afterInsert true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInsertCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            bean.setBeforeInsertReturn(false);
+            manager.insert(bean);
+            assertEquals("beforeInsert -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            assertNull(manager.restore(1));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testUpdateCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            manager.update(bean);
+            assertEquals("beforeUpdate -1;This is my test string\n" +
+                         "afterUpdate false -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            var id = manager.insert(bean);
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            manager.update(bean);
+            assertEquals("beforeUpdate " + id + ";This is a new test string\n" +
+                         "afterUpdate true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testUpdateCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+            bean.setTestString("This is my test string");
+
+            var id = manager.insert(bean);
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            bean.setTestString("This is a new test string");
+
+            bean.setBeforeUpdateReturn(false);
+            manager.update(bean);
+            assertEquals("beforeUpdate " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            assertEquals("This is my test string", manager.restore(id).getTestString());
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDeleteCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            var id = manager.save(bean);
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            manager.delete(id);
+            assertEquals("beforeDelete " + id + "\n" +
+                         "afterDelete true " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDeleteCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            var id = manager.save(bean);
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.setBeforeDeleteReturn(false);
+            manager.delete(id);
+            assertEquals("beforeDelete " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            assertNotNull(manager.restore(id));
+
+            CallbacksBean.setBeforeDeleteReturn(true);
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDeleteListeners(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksBean();
+
+            bean.setTestString("This is my test string");
+
+            var id = manager.save(bean);
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            var listener = new AggregatingCallbacksBeanListener();
+            try {
+                manager.addListener(listener);
+                manager.delete(id);
+                var history = listener.getHistory();
+                assertEquals(1, history.size());
+                var entry = history.entrySet().iterator().next();
+                assertEquals("deleted0", entry.getKey());
+                assertEquals(id, entry.getValue());
+                assertEquals("beforeDelete " + id + "\n" +
+                             "afterDelete true " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+            } finally {
+                manager.removeListeners();
+            }
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreCallbacks(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean1 = new CallbacksBean();
+            var bean2 = new CallbacksBean();
+            var bean3 = new CallbacksBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            var id1 = manager.save(bean1);
+            var id2 = manager.save(bean2);
+            var id3 = manager.save(bean3);
+
+            CallbacksBean.clearExecuteCallbacks();
+
+            // restore all beans
+            assertEquals(3, manager.restore(manager.getRestoreQuery().orderBy("id")).size());
+
+            assertEquals("afterRestore " + id1 + ";This is bean1\n" +
+                         "afterRestore " + id2 + ";This is bean2\n" +
+                         "afterRestore " + id3 + ";This is bean3", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            // restore a specific bean
+            manager.restore(bean2.getId());
+
+            assertEquals("afterRestore " + id2 + ";This is bean2", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            // restore the first bean
+            manager.restoreFirst(manager.getRestoreQuery().orderBy("id"));
+
+            assertEquals("afterRestore " + id1 + ";This is bean1", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.clearExecuteCallbacks();
+            CallbacksBean.setAfterRestoreReturn(true);
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreCallbacksReturns(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean1 = new CallbacksBean();
+            var bean2 = new CallbacksBean();
+            var bean3 = new CallbacksBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            var id = manager.save(bean1);
+            manager.save(bean2);
+            manager.save(bean3);
+
+            CallbacksBean.clearExecuteCallbacks();
+            CallbacksBean.setAfterRestoreReturn(false);
+
+            assertEquals(1, manager.restore(manager.getRestoreQuery().orderBy("id")).size());
+
+            assertEquals("afterRestore " + id + ";This is bean1", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+            CallbacksBean.setAfterRestoreReturn(true);
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreListeners(Datasource datasource) {
+        var manager = setUpCallbacksBeanManager(datasource);
+        try {
+            CallbacksBean.clearExecuteCallbacks();
+
+            var bean1 = new CallbacksBean();
+            var bean2 = new CallbacksBean();
+            var bean3 = new CallbacksBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            var id1 = manager.save(bean1);
+            var id2 = manager.save(bean2);
+            var id3 = manager.save(bean3);
+
+            CallbacksBean.clearExecuteCallbacks();
+
+            var listener = new AggregatingCallbacksBeanListener();
+            manager.addListener(listener);
+            try {
+                // restore all beans
+                var restored = manager.restore(manager.getRestoreQuery().orderBy("id"));
+                assertEquals(3, restored.size());
+
+                Map<String, Object> history;
+                Iterator<Map.Entry<String, Object>> it;
+                Map.Entry<String, Object> entry;
+
+                history = listener.getHistory();
+                assertEquals(3, history.size());
+                it = history.entrySet().iterator();
+                entry = it.next();
+                assertEquals("restored0", entry.getKey());
+                assertSame(restored.get(0), entry.getValue());
+                entry = it.next();
+                assertEquals("restored1", entry.getKey());
+                assertSame(restored.get(1), entry.getValue());
+                entry = it.next();
+                assertEquals("restored2", entry.getKey());
+                assertSame(restored.get(2), entry.getValue());
+                assertEquals("afterRestore " + id1 + ";listener restored\n" +
+                             "afterRestore " + id2 + ";listener restored\n" +
+                             "afterRestore " + id3 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                CallbacksBean.clearExecuteCallbacks();
+                listener.clearHistory();
+                assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                // restore a specific bean
+                var restored_specific = manager.restore(bean2.getId());
+
+                history = listener.getHistory();
+                assertEquals(1, history.size());
+                it = history.entrySet().iterator();
+                entry = it.next();
+                assertEquals("restored0", entry.getKey());
+                assertSame(restored_specific, entry.getValue());
+                assertEquals("afterRestore " + id2 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                CallbacksBean.clearExecuteCallbacks();
+                listener.clearHistory();
+                assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                // restore the first bean
+                var restored_first = manager.restoreFirst(manager.getRestoreQuery().orderBy("id"));
+
+                history = listener.getHistory();
+                assertEquals(1, history.size());
+                it = history.entrySet().iterator();
+                entry = it.next();
+                assertEquals("restored0", entry.getKey());
+                assertSame(restored_first, entry.getValue());
+                assertEquals("afterRestore " + id1 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n"));
+
+                CallbacksBean.clearExecuteCallbacks();
+                listener.clearHistory();
+                CallbacksBean.setAfterRestoreReturn(true);
+            } finally {
+                manager.removeListeners();
+            }
+        } finally {
+            tearDownCallbacksBean(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testCallbacksProvider(Datasource datasource) {
+        var manager = setUpCallbacksProviderBeanManager(datasource);
+        try {
+            CallbacksProviderBean.clearExecuteCallbacks();
+
+            var bean = new CallbacksProviderBean();
+            CallbacksProviderBean new_bean = null;
+
+            bean.setTestString("This is my test string");
+
+            var id1 = manager.save(bean);
+
+            new_bean = manager.restore(id1);
+
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+            assertEquals(new_bean.getTestString(), bean.getTestString());
+            assertEquals(new_bean.getId(), id1);
+
+            bean.setId(id1);
+            bean.setTestString("This is a new test string");
+
+            assertEquals(manager.save(bean), id1);
+            assertEquals(bean.getId(), id1);
+
+            new_bean = manager.restore(id1);
+
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+
+            assertEquals(new_bean.getTestString(), "This is a new test string");
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            var id2 = id1 + 1;
+
+            assertEquals(id2, manager.save(bean));
+            assertNotEquals(999999, id2);
+            assertEquals(bean.getId(), id1 + 1);
+
+            bean.setId(76876);
+            bean.setTestString("This is a last test string");
+
+            var id3 = id2 + 1;
+            assertEquals(id3, manager.insert(bean));
+
+            bean.setTestString("This is an updated test string");
+            assertEquals(id3, manager.update(bean));
+
+            assertTrue(manager.delete(id2));
+            assertEquals(2, manager.restore().size());
+
+            assertEquals("beforeSave -1;This is my test string\n" +
+                         "beforeInsert -1;This is my test string\n" +
+                         "afterInsert true " + id1 + ";This is my test string\n" +
+                         "afterSave true " + id1 + ";This is my test string\n" +
+                         "afterRestore " + id1 + ";This is my test string\n" +
+                         "beforeSave " + id1 + ";This is a new test string\n" +
+                         "beforeUpdate " + id1 + ";This is a new test string\n" +
+                         "afterUpdate true " + id1 + ";This is a new test string\n" +
+                         "afterSave true " + id1 + ";This is a new test string\n" +
+                         "afterRestore " + id1 + ";This is a new test string\n" +
+                         "beforeSave 999999;This is another test string\n" +
+                         "beforeUpdate 999999;This is another test string\n" +
+                         "afterUpdate false 999999;This is another test string\n" +
+                         "beforeInsert 999999;This is another test string\n" +
+                         "afterInsert true " + id2 + ";This is another test string\n" +
+                         "afterSave true " + id2 + ";This is another test string\n" +
+                         "beforeInsert 76876;This is a last test string\n" +
+                         "afterInsert true " + id3 + ";This is a last test string\n" +
+                         "beforeUpdate " + id3 + ";This is an updated test string\n" +
+                         "afterUpdate true " + id3 + ";This is an updated test string\n" +
+                         "beforeDelete " + id2 + "\n" +
+                         "afterDelete true " + id2 + "\n" +
+                         "afterRestore " + id1 + ";This is a new test string\n" +
+                         "afterRestore " + id3 + ";This is an updated test string", StringUtils.join(CallbacksProviderBean.getExecutedCallbacks(), "\n"));
+        } finally {
+            tearDownCallbacksProviderBean(manager);
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerChild.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.querymanagers.generic.beans.ChildBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+public class TestGenericQueryManagerChild {
+    protected GenericQueryManager<ChildBean> setUp(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, ChildBean.class);
+        manager.install();
+        return manager;
+    }
+
+    protected void tearDown(GenericQueryManager<ChildBean> manager) {
+        manager.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            assertSame(ChildBean.class, manager.getBaseClass());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testChildBean(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean = new ChildBean();
+
+            bean.setParentString("This is bean");
+            bean.setChildString("This is childbean");
+
+            var id = manager.save(bean);
+
+            var rbean = manager.restore(id);
+
+            assertEquals(rbean.getParentString(), bean.getParentString());
+            assertEquals(rbean.getChildString(), bean.getChildString());
+        } finally {
+            tearDown(manager);
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerConstrained.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.exceptions.DatabaseException;
+import rife.database.querymanagers.generic.beans.ConstrainedBean;
+import rife.database.querymanagers.generic.beans.LinkBean;
+import rife.validation.ValidationError;
+
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerConstrained {
+    private GenericQueryManager<LinkBean> linkManager_ = null;
+    private GenericQueryManager<ConstrainedBean> constrainedManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        linkManager_ = new TestGenericQueryManagerDelegate.GQMLinkBean(datasource);
+        constrainedManager_ = new TestGenericQueryManagerDelegate.GQMConstrainedBean(datasource);
+        linkManager_.install();
+        constrainedManager_.install();
+    }
+
+    protected void tearDown() {
+        constrainedManager_.remove();
+        linkManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertSame(LinkBean.class, linkManager_.getBaseClass());
+            assertSame(ConstrainedBean.class, constrainedManager_.getBaseClass());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        setUp(datasource);
+        try {
+            constrainedManager_.remove();
+            linkManager_.remove();
+
+            linkManager_.install(linkManager_.getInstallTableQuery());
+            constrainedManager_.install(constrainedManager_.getInstallTableQuery());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreConstrained(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new ConstrainedBean();
+            ConstrainedBean new_bean = null;
+
+            bean.setTestString("This is my test string");
+
+            var id = constrainedManager_.save(bean);
+
+            new_bean = constrainedManager_.restore(id);
+
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+            assertEquals(new_bean.getTestString(), bean.getTestString());
+            assertEquals(new_bean.getIdentifier(), id);
+
+            bean.setIdentifier(id);
+            bean.setTestString("This is a new test string");
+
+            assertEquals(constrainedManager_.save(bean), id);
+            assertEquals(bean.getIdentifier(), id);
+
+            new_bean = constrainedManager_.restore(id);
+
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+
+            assertEquals(new_bean.getTestString(), "This is a new test string");
+
+            bean.setIdentifier(999999);
+            bean.setTestString("This is another test string");
+
+            assertNotEquals(999999, constrainedManager_.save(bean));
+            assertEquals(bean.getIdentifier(), id + 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextManyToOne(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var link_bean1 = new LinkBean();
+            var link_bean2 = new LinkBean();
+            var link_bean3 = new LinkBean();
+
+            link_bean1.setTestString("linkbean 1");
+            link_bean2.setTestString("linkbean 2");
+            link_bean3.setTestString("linkbean 3");
+
+            linkManager_.save(link_bean1);
+            linkManager_.save(link_bean2);
+            linkManager_.save(link_bean3);
+
+            var bean1 = new ConstrainedBean();
+            bean1.setTestString("test_string1");
+            assertTrue(bean1.validate(constrainedManager_));
+            var id1 = constrainedManager_.save(bean1);
+
+            var bean2 = new ConstrainedBean();
+            bean2.setTestString("test_string2");
+            bean2.setLinkBean(link_bean1.getId());
+            assertTrue(bean2.validate(constrainedManager_));
+            var id2 = constrainedManager_.save(bean2);
+            assertTrue(id1 != id2);
+
+            var bean3 = new ConstrainedBean();
+            bean3.setTestString("test_string2");
+            bean3.setLinkBean(23);
+            assertFalse(bean3.validate(constrainedManager_));
+            var error = (ValidationError) bean3.getValidationErrors().iterator().next();
+            assertEquals(error.getSubject(), "linkBean");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            try {
+                constrainedManager_.save(bean3);
+                fail("exception not thrown");
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            bean3.resetValidation();
+            bean3.setLinkBean(link_bean3.getId());
+            assertTrue(bean3.validate(constrainedManager_));
+            var id3 = constrainedManager_.save(bean3);
+            assertTrue(id2 != id3);
+        } finally {
+            tearDown();
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerDelegate.java

@@ -0,0 +1,341 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.*;
+import rife.database.querymanagers.generic.beans.ChildBean;
+import rife.database.querymanagers.generic.beans.ConstrainedBean;
+import rife.database.querymanagers.generic.beans.LinkBean;
+import rife.database.querymanagers.generic.beans.SimpleBean;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerDelegate {
+    static class GQMSimpleBean extends GenericQueryManagerDelegate<SimpleBean> {
+        GQMSimpleBean(Datasource datasource) {
+            super(datasource, SimpleBean.class);
+        }
+    }
+
+    static class GQMLinkBean extends GenericQueryManagerDelegate<LinkBean> {
+        GQMLinkBean(Datasource datasource) {
+            super(datasource, LinkBean.class);
+        }
+    }
+
+    static class GQMChildBean extends GenericQueryManagerDelegate<ChildBean> {
+        GQMChildBean(Datasource datasource) {
+            super(datasource, ChildBean.class);
+        }
+    }
+
+    static class GQMConstrainedBean extends GenericQueryManagerDelegate<ConstrainedBean> {
+        GQMConstrainedBean(Datasource datasource) {
+            super(datasource, ConstrainedBean.class);
+        }
+    }
+
+    private GQMSimpleBean manager_ = null;
+    private GQMLinkBean linkManager_ = null;
+    private GQMChildBean childManager_ = null;
+    private GQMConstrainedBean constrainedManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        manager_ = new GQMSimpleBean(datasource);
+        linkManager_ = new GQMLinkBean(datasource);
+        childManager_ = new GQMChildBean(datasource);
+        constrainedManager_ = new GQMConstrainedBean(datasource);
+
+        manager_.install();
+        linkManager_.install();
+        childManager_.install();
+        constrainedManager_.install();
+    }
+
+    protected void tearDown() {
+        constrainedManager_.remove();
+        manager_.remove();
+        linkManager_.remove();
+        childManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestore(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new SimpleBean();
+            SimpleBean newbean = null;
+
+            bean.setTestString("This is my test string");
+
+            var id = manager_.save(bean);
+
+            newbean = manager_.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+            assertEquals(newbean.getTestString(), bean.getTestString());
+            assertEquals(newbean.getId(), id);
+
+            bean.setId(id);
+            bean.setTestString("This is a new test string");
+
+            assertEquals(manager_.save(bean), id);
+            assertEquals(bean.getId(), id);
+
+            newbean = manager_.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+
+            assertEquals(newbean.getTestString(), "This is a new test string");
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            assertNotEquals(999999, manager_.save(bean));
+            assertEquals(bean.getId(), id + 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreConstrained(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new ConstrainedBean();
+            ConstrainedBean newbean = null;
+
+            bean.setTestString("This is my test string");
+
+            var id = constrainedManager_.save(bean);
+
+            newbean = constrainedManager_.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+            assertEquals(newbean.getTestString(), bean.getTestString());
+            assertEquals(newbean.getIdentifier(), id);
+
+            bean.setIdentifier(id);
+            bean.setTestString("This is a new test string");
+
+            assertEquals(constrainedManager_.save(bean), id);
+            assertEquals(bean.getIdentifier(), id);
+
+            newbean = constrainedManager_.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+
+            assertEquals(newbean.getTestString(), "This is a new test string");
+
+            bean.setIdentifier(999999);
+            bean.setTestString("This is another test string");
+
+            assertNotEquals(999999, constrainedManager_.save(bean));
+            assertEquals(bean.getIdentifier(), id + 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDelete(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new SimpleBean();
+
+            bean.setTestString("This is my test string");
+
+            var id1 = manager_.save(bean);
+            assertNotNull(manager_.restore(id1));
+            manager_.delete(id1);
+            assertNull(manager_.restoreFirst(manager_.getRestoreQuery(id1)));
+
+            var id2 = manager_.save(bean);
+            assertNotNull(manager_.restoreFirst(manager_.getRestoreQuery(id2)));
+            manager_.delete(manager_.getDeleteQuery(id2));
+            assertNull(manager_.restore(id2));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestore(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+
+            var list = manager_.restore();
+
+            assertEquals(list.size(), 3);
+
+            for (var bean : list) {
+                assertNotNull(bean);
+                assertTrue(bean != bean1 || bean != bean2 || bean != bean3);
+                assertTrue(
+                    bean.getTestString().equals("This is bean1") ||
+                    bean.getTestString().equals("This is bean2") ||
+                    bean.getTestString().equals("This is bean3"));
+            }
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreRowProcessor(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+
+            final var count = new int[]{0};
+            manager_.restore(new DbRowProcessor() {
+                public boolean processRow(ResultSet resultSet)
+                throws SQLException {
+                    count[0]++;
+
+                    var test_string = resultSet.getString("testString");
+                    assertTrue(
+                        test_string.equals("This is bean1") ||
+                        test_string.equals("This is bean2") ||
+                        test_string.equals("This is bean3"));
+
+                    return true;
+                }
+            });
+
+            assertEquals(count[0], 3);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreQueryRowProcessor(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            bean1.setTestString("This is bean1");
+            bean2.setTestString("This is bean2");
+            bean3.setTestString("This is bean3");
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+
+            final var count = new int[]{0};
+            manager_.restore(manager_.getRestoreQuery().where("testString", "LIKE", "%bean2"), new DbRowProcessor() {
+                public boolean processRow(ResultSet resultSet)
+                throws SQLException {
+                    count[0]++;
+
+                    var test_string = resultSet.getString("testString");
+                    assertEquals("This is bean2", test_string);
+
+                    return true;
+                }
+            });
+
+            assertEquals(count[0], 1);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testChildBean(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new ChildBean();
+
+            bean.setParentString("This is bean");
+            bean.setChildString("This is childbean");
+
+            var id = childManager_.save(bean);
+
+            var rbean = childManager_.restore(id);
+
+            assertEquals(rbean.getParentString(), bean.getParentString());
+            assertEquals(rbean.getChildString(), bean.getChildString());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testCount(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            manager_.save(bean1);
+            manager_.save(bean2);
+            manager_.save(bean3);
+            manager_.save(bean4);
+            manager_.save(bean5);
+
+            assertEquals(manager_.count(), 5);
+
+            manager_.delete(bean1.getId());
+            manager_.delete(bean2.getId());
+            manager_.delete(bean3.getId());
+
+            assertEquals(manager_.count(), 2);
+        } finally {
+            tearDown();
+        }
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToMany.java

@@ -0,0 +1,398 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.*;
+import rife.database.queries.Select;
+import rife.database.querymanagers.generic.beans.MMFirstBean;
+import rife.database.querymanagers.generic.beans.MMSecondBean;
+import rife.validation.ValidationError;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerManyToMany {
+    private GenericQueryManager<MMFirstBean> firstManager_ = null;
+    private GenericQueryManager<MMSecondBean> secondManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        firstManager_ = GenericQueryManagerFactory.getInstance(datasource, MMFirstBean.class);
+        secondManager_ = GenericQueryManagerFactory.getInstance(datasource, MMSecondBean.class);
+        secondManager_.install();
+        firstManager_.install();
+    }
+
+    protected void tearDown() {
+        firstManager_.remove();
+        secondManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertSame(MMFirstBean.class, firstManager_.getBaseClass());
+            assertSame(MMSecondBean.class, secondManager_.getBaseClass());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        setUp(datasource);
+        try {
+            firstManager_.remove();
+            secondManager_.remove();
+
+            secondManager_.install(secondManager_.getInstallTableQuery());
+            firstManager_.install(firstManager_.getInstallTableQuery());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreConstrained(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new MMFirstBean();
+            MMFirstBean new_bean = null;
+
+            bean.setFirstString("This is my test string");
+
+            // add the many-to-many relations to the bean instance
+            var bean2a = new MMSecondBean();
+            bean2a.setSecondString("MMSecondBeanA");
+
+            var bean2b = new MMSecondBean();
+            bean2b.setSecondString("MMSecondBeanB");
+
+            var bean2c = new MMSecondBean();
+            bean2c.setSecondString("MMSecondBeanC");
+
+            Collection<MMSecondBean> second_beans = new ArrayList<>();
+            second_beans.add(bean2a);
+            second_beans.add(bean2b);
+            second_beans.add(bean2c);
+            bean.setSecondBeans(second_beans);
+
+            // assert that the many-to-many relations have not been saved too
+            assertNull(bean2a.getIdentifier());
+            assertNull(bean2b.getIdentifier());
+            assertNull(bean2c.getIdentifier());
+
+            // save the bean instance
+            Integer id = firstManager_.save(bean);
+
+            // assert that the many-to-many relations have been saved too
+            assertNotNull(bean2a.getIdentifier());
+            assertNotNull(bean2b.getIdentifier());
+            assertNotNull(bean2c.getIdentifier());
+
+            // restore the bean instance
+            new_bean = firstManager_.restore(id);
+
+            // assert that the bean has correctly been restored
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+            assertEquals(new_bean.getFirstString(), bean.getFirstString());
+            assertEquals(new_bean.getIdentifier(), id);
+
+            // assert that the many-to-many relationships have correctly been restored
+            var second_beans_restored = new_bean.getSecondBeans();
+            var bean2a_found = false;
+            var bean2b_found = false;
+            var bean2c_found = false;
+            for (var second_bean : second_beans_restored) {
+                if ("MMSecondBeanA".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2a_found);
+                    assertEquals(bean2a.getIdentifier(), second_bean.getIdentifier());
+                    assertEquals(bean2a.getSecondString(), second_bean.getSecondString());
+                    bean2a_found = true;
+                } else if ("MMSecondBeanB".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2b_found);
+                    assertEquals(bean2b.getIdentifier(), second_bean.getIdentifier());
+                    assertEquals(bean2b.getSecondString(), second_bean.getSecondString());
+                    bean2b_found = true;
+                } else if ("MMSecondBeanC".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2c_found);
+                    assertEquals(bean2c.getIdentifier(), second_bean.getIdentifier());
+                    assertEquals(bean2c.getSecondString(), second_bean.getSecondString());
+                    bean2c_found = true;
+                }
+
+                assertNotNull(second_bean.getFirstBeans());
+                assertEquals(1, second_bean.getFirstBeans().size());
+
+                var first_bean = second_bean.getFirstBeans().iterator().next();
+                assertEquals(new_bean.getIdentifier(), first_bean.getIdentifier());
+                assertEquals(new_bean.getFirstString(), first_bean.getFirstString());
+            }
+            assertTrue(bean2a_found);
+            assertTrue(bean2b_found);
+            assertTrue(bean2c_found);
+
+            // perform update with changed many-to-many relationships
+            // only the data of those that haven't been saved before will
+            // be stored
+            bean.setIdentifier(id);
+            bean.setFirstString("This is a new test string");
+
+            bean2a.setSecondString("MMSecondBeanAUpdated");
+
+            var bean2d = new MMSecondBean();
+            bean2d.setSecondString("MMSecondBeanD");
+            second_beans = new ArrayList<>();
+            second_beans.add(bean2a);
+            second_beans.add(bean2c);
+            second_beans.add(bean2d);
+            bean.setSecondBeans(second_beans);
+
+            assertEquals(firstManager_.save(bean), id.intValue());
+            assertEquals(bean.getIdentifier(), id);
+
+            // restore the updated bean
+            new_bean = firstManager_.restore(id);
+
+            assertNotNull(new_bean);
+            assertNotSame(new_bean, bean);
+
+            // assert that the updated bean has been stored correctly
+            assertEquals(new_bean.getFirstString(), "This is a new test string");
+
+            // assert that the many-to-many relationships have correctly been stored and restored
+            second_beans_restored = new_bean.getSecondBeans();
+            bean2a_found = false;
+            bean2b_found = false;
+            bean2c_found = false;
+            var bean2d_found = false;
+            for (var second_bean : second_beans_restored) {
+                if ("MMSecondBeanA".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2a_found);
+                    assertEquals(bean2a.getIdentifier(), second_bean.getIdentifier());
+                    // the data of this many-to-many association hasn't been updated since the entity already was saved before
+                    assertNotEquals(bean2a.getSecondString(), second_bean.getSecondString());
+                    bean2a_found = true;
+                } else if ("MMSecondBeanB".equals(second_bean.getSecondString())) {
+                    bean2b_found = true;
+                } else if ("MMSecondBeanC".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2c_found);
+                    assertEquals(bean2c.getIdentifier(), second_bean.getIdentifier());
+                    assertEquals(bean2c.getSecondString(), second_bean.getSecondString());
+                    bean2c_found = true;
+                } else if ("MMSecondBeanD".equals(second_bean.getSecondString())) {
+                    assertFalse(bean2d_found);
+                    assertEquals(bean2d.getIdentifier(), second_bean.getIdentifier());
+                    assertEquals(bean2d.getSecondString(), second_bean.getSecondString());
+                    bean2d_found = true;
+                }
+
+                assertNotNull(second_bean.getFirstBeans());
+                assertEquals(1, second_bean.getFirstBeans().size());
+
+                var first_bean = second_bean.getFirstBeans().iterator().next();
+                assertEquals(new_bean.getIdentifier(), first_bean.getIdentifier());
+                assertEquals(new_bean.getFirstString(), first_bean.getFirstString());
+            }
+            assertTrue(bean2a_found);
+            assertFalse(bean2b_found);
+            assertTrue(bean2c_found);
+            assertTrue(bean2d_found);
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDelete(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new MMFirstBean();
+
+            bean.setFirstString("This is my test string");
+
+            // add the many-to-many relations to the bean instance
+            var bean2a = new MMSecondBean();
+            bean2a.setSecondString("MMSecondBeanA");
+
+            var bean2b = new MMSecondBean();
+            bean2b.setSecondString("MMSecondBeanB");
+
+            Collection<MMSecondBean> second_beans = new ArrayList<>();
+            second_beans.add(bean2a);
+            second_beans.add(bean2b);
+            bean.setSecondBeans(second_beans);
+
+            // save the bean instance
+            var id1 = firstManager_.save(bean);
+
+            // ensure that everything was saved correctly
+            assertNotNull(firstManager_.restore(id1));
+            assertEquals(2, new DbQueryManager(datasource)
+                .executeGetFirstInt(new Select(datasource)
+                    .field("count(*)")
+                    .from("mmfirstbean_mmsecondbean")
+                    .where("mmfirstbean_identifier", "=", id1)));
+            assertEquals(2, secondManager_.count());
+
+            // delete the first bean
+            firstManager_.delete(id1);
+
+            // ensure that everything was deleted correctly
+            assertNull(firstManager_.restore(id1));
+            assertEquals(0, new DbQueryManager(datasource)
+                .executeGetFirstInt(new Select(datasource)
+                    .field("count(*)")
+                    .from("mmfirstbean_mmsecondbean")
+                    .where("mmfirstbean_identifier", "=", id1)));
+            assertEquals(2, secondManager_.count());
+
+            // add another many-to-many relationship
+            var bean2c = new MMSecondBean();
+            bean2b.setSecondString("MMSecondBeanC");
+            second_beans.add(bean2c);
+
+            // save the bean instance again
+            var id2 = firstManager_.save(bean);
+
+            // ensure that everything was saved correctly
+            assertNotNull(firstManager_.restore(id2));
+            assertEquals(3, new DbQueryManager(datasource)
+                .executeGetFirstInt(new Select(datasource)
+                    .field("count(*)")
+                    .from("mmfirstbean_mmsecondbean")
+                    .where("mmfirstbean_identifier", "=", id2)));
+            assertEquals(3, secondManager_.count());
+
+            // delete the second bean
+            firstManager_.delete(id2);
+
+            // ensure that everything was deleted correctly
+            assertNull(firstManager_.restore(id2));
+            assertEquals(0, new DbQueryManager(datasource)
+                .executeGetFirstInt(new Select(datasource)
+                    .field("count(*)")
+                    .from("mmfirstbean_mmsecondbean")
+                    .where("mmfirstbean_identifier", "=", id2)));
+            assertEquals(3, secondManager_.count());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextManyToMany(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new MMFirstBean();
+
+            bean.setFirstString("This is my test string");
+
+            // add the many-to-many relations to the bean instance
+            var bean2a = new MMSecondBean();
+            bean2a.setIdentifier(23);
+            bean2a.setSecondString("MMSecondBeanA");
+
+            var bean2b = new MMSecondBean();
+            bean2b.setIdentifier(24);
+            bean2b.setSecondString("MMSecondBeanB");
+
+            Collection<MMSecondBean> second_beans = new ArrayList<>();
+            second_beans.add(bean2a);
+            second_beans.add(bean2b);
+            bean.setSecondBeans(second_beans);
+
+            // validate the bean instance
+            ValidationError error;
+            assertFalse(bean.validate(firstManager_));
+            error = bean.getValidationErrors().iterator().next();
+            assertEquals(error.getSubject(), "secondBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+
+            bean.resetValidation();
+
+            // store the first associated bean
+            secondManager_.save(bean2a);
+
+            // validate the bean instance again
+            assertFalse(bean.validate(firstManager_));
+            error = bean.getValidationErrors().iterator().next();
+            assertEquals(error.getSubject(), "secondBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+
+            // store the second associated bean
+            secondManager_.save(bean2b);
+
+            bean.resetValidation();
+
+            // validate the bean instance a last time
+            assertTrue(bean.validate(firstManager_));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextManyToManyAssociation(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean2 = new MMSecondBean();
+            bean2.setSecondString("This is my test string");
+
+            // add the many-to-many association relations to the bean instance
+            var bean1a = new MMFirstBean();
+            bean1a.setIdentifier(23);
+            bean1a.setFirstString("MMFirstBeanA");
+
+            var bean1b = new MMFirstBean();
+            bean1b.setIdentifier(24);
+            bean1b.setFirstString("MMFirstBeanB");
+
+            Collection<MMFirstBean> first_beans = new ArrayList<>();
+            first_beans.add(bean1a);
+            first_beans.add(bean1b);
+            bean2.setFirstBeans(first_beans);
+
+            // validate the bean instance
+            ValidationError error;
+            assertFalse(bean2.validate(secondManager_));
+            error = bean2.getValidationErrors().iterator().next();
+            assertEquals(error.getSubject(), "firstBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+
+            bean2.resetValidation();
+
+            // store the first associated bean
+            firstManager_.save(bean1a);
+
+            // validate the bean instance again
+            assertFalse(bean2.validate(secondManager_));
+            error = bean2.getValidationErrors().iterator().next();
+            assertEquals(error.getSubject(), "firstBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+
+            // store the second associated bean
+            firstManager_.save(bean1b);
+
+            bean2.resetValidation();
+
+            // validate the bean instance a last time
+            assertTrue(bean2.validate(secondManager_));
+        } finally {
+            tearDown();
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToOne.java

@@ -0,0 +1,533 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.validation.ValidationError;
+import rifetestmodels.MOFirstBean;
+import rifetestmodels.MOSecondBean;
+import rifetestmodels.MOThirdBean;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerManyToOne {
+    private GenericQueryManager<MOFirstBean> firstManager_ = null;
+    private GenericQueryManager<MOSecondBean> secondManager_ = null;
+    private GenericQueryManager<MOThirdBean> thirdManager_ = null;
+
+    protected void setUp(Datasource datasource) {
+        firstManager_ = GenericQueryManagerFactory.getInstance(datasource, MOFirstBean.class);
+        secondManager_ = GenericQueryManagerFactory.getInstance(datasource, MOSecondBean.class);
+        thirdManager_ = GenericQueryManagerFactory.getInstance(datasource, MOThirdBean.class);
+        thirdManager_.install();
+        secondManager_.install();
+        firstManager_.install();
+    }
+
+    protected void tearDown() {
+        firstManager_.remove();
+        secondManager_.remove();
+        thirdManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertSame(MOFirstBean.class, firstManager_.getBaseClass());
+            assertSame(MOSecondBean.class, secondManager_.getBaseClass());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        setUp(datasource);
+        try {
+            firstManager_.remove();
+            secondManager_.remove();
+
+            secondManager_.install(secondManager_.getInstallTableQuery());
+            firstManager_.install(firstManager_.getInstallTableQuery());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreConstrained(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean_a = new MOFirstBean();
+            var bean_b = new MOFirstBean();
+            MOFirstBean new_bean_a = null;
+            MOFirstBean new_bean_b = null;
+
+            bean_a.setFirstString("This is my test string");
+            bean_b.setFirstString("This is my test string B");
+
+            // add the many-to-one relations to the bean instance
+            var bean_2a = new MOSecondBean();
+            bean_2a.setSecondString("MOSecondBeanA");
+
+            var bean_2b = new MOSecondBean();
+            bean_2b.setSecondString("MOSecondBeanB");
+
+            var bean_2c = new MOSecondBean();
+            bean_2c.setSecondString("MOSecondBeanC");
+
+            var bean_3a = new MOThirdBean();
+            bean_3a.setThirdString("MOThirdBeanA");
+
+            var bean_3b = new MOThirdBean();
+            bean_3a.setThirdString("MOThirdBeanB");
+
+            bean_a.setSecondBean(bean_2a);
+            bean_a.setSecondBean2(bean_2b);
+            bean_a.setThirdBean(bean_3a);
+
+            bean_b.setSecondBean(bean_2b);
+            bean_b.setSecondBean2(bean_2c);
+            bean_b.setThirdBean(bean_3b);
+
+            // assert that the many-to-one relations have not been saved too
+            assertNull(bean_2a.getIdentifier());
+            assertNull(bean_2b.getIdentifier());
+            assertNull(bean_2c.getIdentifier());
+            assertNull(bean_3a.getId());
+            assertNull(bean_3b.getId());
+
+            // save the bean instances
+            Integer ida = firstManager_.save(bean_a);
+            Integer idb = firstManager_.save(bean_b);
+
+            // assert that the many-to-one relations have been saved too
+            assertNotNull(bean_2a.getIdentifier());
+            assertNotNull(bean_2b.getIdentifier());
+            assertNotNull(bean_2c.getIdentifier());
+            assertNotNull(bean_3a.getId());
+            assertNotNull(bean_3b.getId());
+
+            // restore the bean instances
+            new_bean_a = firstManager_.restore(ida);
+            new_bean_b = firstManager_.restore(idb);
+
+            // assert that the first bean has correctly been restored
+            assertNotNull(new_bean_a);
+            assertNotSame(new_bean_a, bean_a);
+            assertEquals(new_bean_a.getFirstString(), bean_a.getFirstString());
+            assertEquals(new_bean_a.getIdentifier(), ida);
+
+            // assert that the first bean's many-to-one relationships have correctly been restored
+            var second_bean_a = new_bean_a.getSecondBean();
+            assertNotNull(second_bean_a);
+            assertEquals(bean_2a.getIdentifier(), second_bean_a.getIdentifier());
+            assertEquals(bean_2a.getSecondString(), second_bean_a.getSecondString());
+
+            // assert that the second bean has correctly been restored
+            assertNotNull(new_bean_b);
+            assertNotSame(new_bean_b, bean_b);
+            assertEquals(new_bean_b.getFirstString(), bean_b.getFirstString());
+            assertEquals(new_bean_b.getIdentifier(), idb);
+
+            // assert that the second bean's many-to-one relationships have correctly been restored
+            var second_bean_b = new_bean_b.getSecondBean();
+            assertNotNull(second_bean_b);
+            assertEquals(bean_2b.getIdentifier(), second_bean_b.getIdentifier());
+            assertEquals(bean_2b.getSecondString(), second_bean_b.getSecondString());
+
+            // assert that exactly the same instance is returned the next time the property is retrieved
+            assertSame(second_bean_a, new_bean_a.getSecondBean());
+            assertSame(second_bean_a, new_bean_a.getSecondBean());
+            assertSame(second_bean_b, new_bean_b.getSecondBean());
+            assertSame(second_bean_b, new_bean_b.getSecondBean());
+
+/* TODO : requires the lazy loading bytecode infrastructure
+
+            // set the property to null to cause a new instance to be fetched
+            new_bean_a.setSecondBean(null);
+            var second_bean_c = new_bean_a.getSecondBean();
+            assertNotNull(second_bean_c);
+            assertEquals(second_bean_c.getIdentifier(), second_bean_a.getIdentifier());
+            assertEquals(second_bean_c.getSecondString(), second_bean_a.getSecondString());
+            assertNotSame(second_bean_c, second_bean_a);
+
+            new_bean_b.setSecondBean(null);
+            var second_bean_d = new_bean_b.getSecondBean();
+            assertNotNull(second_bean_d);
+            assertEquals(second_bean_d.getIdentifier(), second_bean_b.getIdentifier());
+            assertEquals(second_bean_d.getSecondString(), second_bean_b.getSecondString());
+            assertNotSame(second_bean_d, second_bean_b);
+*/
+
+            // assert that the other many-to-one relationships have correctly been restored
+            var second_bean_2a = new_bean_a.getSecondBean2();
+            assertNotNull(second_bean_2a);
+            assertEquals(bean_2b.getIdentifier(), second_bean_2a.getIdentifier());
+            assertEquals(bean_2b.getSecondString(), second_bean_2a.getSecondString());
+
+            var third_bean_a = new_bean_a.getThirdBean();
+            assertNotNull(third_bean_a);
+            assertEquals(bean_3a.getId(), third_bean_a.getId());
+            assertEquals(bean_3a.getThirdString(), third_bean_a.getThirdString());
+
+            var second_bean_2b = new_bean_b.getSecondBean2();
+            assertNotNull(second_bean_2b);
+            assertEquals(bean_2c.getIdentifier(), second_bean_2b.getIdentifier());
+            assertEquals(bean_2c.getSecondString(), second_bean_2b.getSecondString());
+
+            var third_bean_b = new_bean_b.getThirdBean();
+            assertNotNull(third_bean_b);
+            assertEquals(bean_3b.getId(), third_bean_b.getId());
+            assertEquals(bean_3b.getThirdString(), third_bean_b.getThirdString());
+
+            // perform update with changed many-to-one relationships
+            // only the data of those that haven't been saved before will
+            // be stored
+            bean_a.setIdentifier(ida);
+            bean_a.setFirstString("This is a new test string");
+
+            bean_2a.setSecondString("MOSecondBeanAUpdated");
+
+            var bean2d = new MOSecondBean();
+            bean2d.setSecondString("MOSecondBeanD");
+            bean_a.setSecondBean2(bean2d);
+
+            assertEquals(firstManager_.save(bean_a), ida.intValue());
+            assertEquals(bean_a.getIdentifier(), ida);
+
+            // restore the updated bean
+            new_bean_a = firstManager_.restore(ida);
+
+            assertNotNull(new_bean_a);
+            assertNotSame(new_bean_a, bean_a);
+
+            // assert that the updated bean has been stored correctly
+            assertEquals(new_bean_a.getFirstString(), "This is a new test string");
+
+            // assert that the many-to-one relationships have correctly been stored and restored
+            second_bean_a = new_bean_a.getSecondBean();
+            assertNotNull(second_bean_a);
+            assertEquals(bean_2a.getIdentifier(), second_bean_a.getIdentifier());
+            // the data of this many-to-one association hasn't been updated since the entity already was saved before
+            assertNotEquals(bean_2a.getSecondString(), second_bean_a.getSecondString());
+
+            var second_bean3 = new_bean_a.getSecondBean2();
+            assertNotNull(second_bean3);
+            assertEquals(bean2d.getIdentifier(), second_bean3.getIdentifier());
+            assertEquals(bean2d.getSecondString(), second_bean3.getSecondString());
+
+            third_bean_a = new_bean_a.getThirdBean();
+            assertNotNull(third_bean_a);
+            assertEquals(bean_3a.getId(), third_bean_a.getId());
+            assertEquals(bean_3a.getThirdString(), third_bean_a.getThirdString());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestoreConstrainedAssociation(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean1a = new MOFirstBean();
+            bean1a.setFirstString("This is my test string");
+            var bean2 = new MOSecondBean();
+            bean2.setSecondString("MOSecondBeanA");
+            bean1a.setSecondBean(bean2);
+
+            // save the bean instance
+            Integer id = firstManager_.save(bean1a);
+
+            // save a second instance of the first bean type
+            var bean1b = new MOFirstBean();
+            bean1b.setFirstString("This is my test string B");
+            bean1b.setSecondBean(bean2);
+            firstManager_.save(bean1b);
+
+            // restore the second bean
+            var second_bean = secondManager_.restore(bean2.getIdentifier());
+
+            // assert that the second bean association links are correct
+            var first_beans = second_bean.getFirstBeans();
+            assertNotNull(first_beans);
+            assertEquals(2, first_beans.size());
+            for (var bean_assoc_restored : first_beans) {
+                if (bean_assoc_restored.getIdentifier().equals(bean1a.getIdentifier())) {
+                    assertEquals(bean_assoc_restored.getFirstString(), bean1a.getFirstString());
+                } else if (bean_assoc_restored.getIdentifier().equals(bean1b.getIdentifier())) {
+                    assertEquals(bean_assoc_restored.getFirstString(), bean1b.getFirstString());
+                } else {
+                    fail();
+                }
+                assertEquals(bean2.getIdentifier(), bean_assoc_restored.getSecondBean().getIdentifier());
+                assertEquals(bean2.getSecondString(), bean_assoc_restored.getSecondBean().getSecondString());
+            }
+
+            // store the second bean with updated links
+            first_beans.remove(first_beans.iterator().next());
+            secondManager_.save(second_bean);
+            second_bean = secondManager_.restore(bean2.getIdentifier());
+            first_beans = second_bean.getFirstBeans();
+            assertNotNull(first_beans);
+            assertEquals(1, first_beans.size());
+
+            // save a third instance of the first bean type and an updated
+            // version of the first instance, which will not be saved
+            var bean1c = new MOFirstBean();
+            bean1c.setFirstString("This is my test string C");
+            assertNull(bean1c.getIdentifier());
+            List<MOFirstBean> firstbeans2 = new ArrayList<MOFirstBean>();
+            firstbeans2.add(bean1a);
+            bean1a.setFirstString("This is my test string updated");
+            firstbeans2.add(bean1c);
+            second_bean.setFirstBeans(firstbeans2);
+            secondManager_.save(second_bean);
+            assertNotNull(bean1c.getIdentifier());
+
+            second_bean = secondManager_.restore(bean2.getIdentifier());
+            first_beans = second_bean.getFirstBeans();
+            assertNotNull(first_beans);
+            assertEquals(2, first_beans.size());
+            for (var bean_assoc_restored : first_beans) {
+                if (bean_assoc_restored.getIdentifier().equals(bean1a.getIdentifier())) {
+                    assertEquals(bean_assoc_restored.getFirstString(), "This is my test string");
+                    assertNotEquals(bean_assoc_restored.getFirstString(), bean1a.getFirstString());
+                } else if (bean_assoc_restored.getIdentifier().equals(bean1c.getIdentifier())) {
+                    assertEquals(bean_assoc_restored.getFirstString(), bean1c.getFirstString());
+                } else {
+                    fail();
+                }
+                assertEquals(bean2.getIdentifier(), bean_assoc_restored.getSecondBean().getIdentifier());
+                assertEquals(bean2.getSecondString(), bean_assoc_restored.getSecondBean().getSecondString());
+            }
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDelete(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertEquals(0, secondManager_.count());
+            assertEquals(0, thirdManager_.count());
+
+            var bean = new MOFirstBean();
+
+            bean.setFirstString("This is my test string");
+
+            // add the many-to-one relations to the bean instance
+            var bean_2a = new MOSecondBean();
+            bean_2a.setSecondString("MOSecondBeanA");
+
+            var bean_3 = new MOThirdBean();
+            bean_3.setThirdString("MOThirdBean");
+
+            bean.setSecondBean(bean_2a);
+            bean.setThirdBean(bean_3);
+
+            // save the bean instance
+            var id1 = firstManager_.save(bean);
+
+            // ensure that everything was saved correctly
+            assertNotNull(firstManager_.restore(id1));
+            assertEquals(1, secondManager_.count());
+            assertEquals(1, thirdManager_.count());
+
+            // delete the first bean
+            firstManager_.delete(id1);
+
+            // ensure that everything was deleted correctly
+            assertNull(firstManager_.restore(id1));
+            assertEquals(1, secondManager_.count());
+            assertEquals(1, thirdManager_.count());
+
+            // add another many-to-one relationship
+            var bean_2c = new MOSecondBean();
+            bean_2c.setSecondString("MOSecondBeanC");
+
+            bean.setSecondBean2(bean_2c);
+
+            // save the bean instance again
+            var id2 = firstManager_.save(bean);
+
+            // ensure that everything was saved correctly
+            assertNotNull(firstManager_.restore(id2));
+            assertEquals(2, secondManager_.count());
+            assertEquals(1, thirdManager_.count());
+
+            // delete the second bean
+            firstManager_.delete(id2);
+
+            // ensure that everything was deleted correctly
+            assertNull(firstManager_.restore(id2));
+            assertEquals(2, secondManager_.count());
+            assertEquals(1, thirdManager_.count());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDeleteAssociation(Datasource datasource) {
+        setUp(datasource);
+        try {
+            final var bean_1a = new MOFirstBean();
+            bean_1a.setFirstString("This is my test string");
+
+            final var bean_1b = new MOFirstBean();
+            bean_1b.setFirstString("This is my test string B");
+
+            var bean_2 = new MOSecondBean();
+            bean_2.setSecondString("MOSecondBeanA");
+            bean_2.setFirstBeans(new ArrayList<MOFirstBean>() {{
+                add(bean_1a);
+                add(bean_1b);
+            }});
+
+            // save the second bean
+            assertTrue(secondManager_.save(bean_2) > -1);
+
+            // restore the second bean
+            var second_bean = secondManager_.restore(bean_2.getIdentifier());
+            assertEquals(2, second_bean.getFirstBeans().size());
+
+            // delete the second bean
+            assertTrue(secondManager_.delete(bean_2.getIdentifier()));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextManyToOne(Datasource datasource) {
+        setUp(datasource);
+        try {
+            var bean = new MOFirstBean();
+
+            bean.setFirstString("This is my test string");
+
+            // add the many-to-one relations to the bean instance
+            var bean_2a = new MOSecondBean();
+            bean_2a.setIdentifier(23);
+            bean_2a.setSecondString("MOSecondBeanA");
+
+            var bean_2b = new MOSecondBean();
+            bean_2b.setIdentifier(24);
+            bean_2b.setSecondString("MOSecondBeanB");
+
+            bean.setSecondBean(bean_2a);
+            bean.setSecondBean2(bean_2b);
+
+            // validate the bean instance
+            ValidationError error;
+            assertFalse(bean.validate(firstManager_));
+            assertEquals(2, bean.getValidationErrors().size());
+            var error_it = bean.getValidationErrors().iterator();
+            error = error_it.next();
+            assertEquals(error.getSubject(), "secondBean");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            error = error_it.next();
+            assertEquals(error.getSubject(), "secondBean2");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            assertFalse(error_it.hasNext());
+
+            bean.resetValidation();
+
+            // store the first associated bean
+            secondManager_.save(bean_2a);
+
+            // validate the bean instance again
+            assertFalse(bean.validate(firstManager_));
+            assertEquals(1, bean.getValidationErrors().size());
+            error_it = bean.getValidationErrors().iterator();
+            error = error_it.next();
+            assertEquals(error.getSubject(), "secondBean2");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            assertFalse(error_it.hasNext());
+
+            // store the second associated bean
+            secondManager_.save(bean_2b);
+
+            bean.resetValidation();
+
+            // validate the bean instance a last time
+            assertTrue(bean.validate(firstManager_));
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextManyToOneAssociation(Datasource datasource) {
+        setUp(datasource);
+        try {
+            final var bean_1a = new MOFirstBean();
+            bean_1a.setIdentifier(23);
+            bean_1a.setFirstString("This is my test string");
+
+            final var bean_1b = new MOFirstBean();
+            bean_1b.setIdentifier(27);
+            bean_1b.setFirstString("This is my test string B");
+
+            var bean_2 = new MOSecondBean();
+            bean_2.setSecondString("MOSecondBeanA");
+            bean_2.setFirstBeans(new ArrayList<MOFirstBean>() {{
+                add(bean_1a);
+                add(bean_1b);
+            }});
+
+            // validate the bean instance
+            ValidationError error;
+            assertFalse(bean_2.validate(secondManager_));
+            assertEquals(1, bean_2.getValidationErrors().size());
+            var error_it = bean_2.getValidationErrors().iterator();
+            error = error_it.next();
+            assertEquals(error.getSubject(), "firstBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            assertFalse(error_it.hasNext());
+
+            bean_2.resetValidation();
+
+            // store the first associated bean
+            firstManager_.save(bean_1a);
+
+            // validate the bean instance
+            assertFalse(bean_2.validate(secondManager_));
+            assertEquals(1, bean_2.getValidationErrors().size());
+            error_it = bean_2.getValidationErrors().iterator();
+            error = error_it.next();
+            assertEquals(error.getSubject(), "firstBeans");
+            assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID);
+            assertFalse(error_it.hasNext());
+
+            bean_2.resetValidation();
+
+            // store the first associated bean
+            firstManager_.save(bean_1b);
+
+            // validate the bean instance a last time
+            assertTrue(bean_2.validate(secondManager_));
+        } finally {
+            tearDown();
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerSimple.java

@@ -0,0 +1,379 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.UUID;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.*;
+import rife.database.exceptions.DatabaseException;
+import rife.database.querymanagers.generic.beans.*;
+import rife.database.querymanagers.generic.exceptions.MissingDefaultConstructorException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerSimple {
+    protected GenericQueryManager<SimpleBean> setUp(Datasource datasource) {
+        var manager = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class);
+        manager.install();
+        return manager;
+    }
+
+    protected void tearDown(GenericQueryManager<SimpleBean> manager) {
+        manager.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testNoDefaultConstructor(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            GenericQueryManagerFactory.getInstance(datasource, NoDefaultConstructorBean.class);
+            fail("MissingDefaultConstructorException exception wasn't thrown");
+        } catch (MissingDefaultConstructorException e) {
+            assertSame(e.getBeanClass(), NoDefaultConstructorBean.class);
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            assertSame(SimpleBean.class, manager.getBaseClass());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            manager.remove();
+            manager.install(manager.getInstallTableQuery());
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSaveRestore(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean = new SimpleBean();
+            SimpleBean newbean = null;
+
+            var uuid1 = UUID.randomUUID();
+            bean.setTestString("This is my test string");
+            bean.setUuid(uuid1);
+            bean.setEnum(SomeEnum.VALUE_TWO);
+
+            var id = manager.save(bean);
+
+            newbean = manager.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+            assertEquals(newbean.getTestString(), bean.getTestString());
+            assertEquals(newbean.getId(), id);
+            assertEquals(newbean.getUuid(), uuid1);
+            assertEquals(newbean.getEnum(), SomeEnum.VALUE_TWO);
+
+            var uuid2 = UUID.randomUUID();
+            bean.setId(id);
+            bean.setTestString("This is a new test string");
+            bean.setUuid(uuid2);
+            bean.setEnum(SomeEnum.VALUE_THREE);
+
+            assertEquals(manager.save(bean), id);
+            assertEquals(bean.getId(), id);
+
+            newbean = manager.restore(id);
+
+            assertNotNull(newbean);
+            assertNotSame(newbean, bean);
+
+            assertEquals(newbean.getTestString(), "This is a new test string");
+            assertEquals(newbean.getUuid(), uuid2);
+            assertEquals(newbean.getEnum(), SomeEnum.VALUE_THREE);
+
+            bean.setId(999999);
+            bean.setTestString("This is another test string");
+
+            assertNotEquals(999999, manager.save(bean));
+            assertEquals(bean.getId(), id + 1);
+
+            var manager_othertable = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class, "othertable");
+            manager_othertable.install();
+
+            var bean2 = new SimpleBean();
+            bean2.setTestString("test");
+
+            manager_othertable.save(bean2);
+
+            var bean3 = manager_othertable.restore(bean2.getId());
+
+            assertEquals(bean3.getTestString(), bean2.getTestString());
+
+            manager_othertable.remove();
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testSparseIdentifier(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var manager_sparsebean = GenericQueryManagerFactory.getInstance(datasource, SparseBean.class);
+            var sparse_bean = new SparseBean();
+
+            manager_sparsebean.install();
+
+            sparse_bean.setId(1000);
+            sparse_bean.setTestString("Test String");
+            assertEquals(1000, manager_sparsebean.save(sparse_bean));
+
+            var restored_sparsebean = manager_sparsebean.restore(1000);
+            assertEquals(restored_sparsebean.getId(), 1000);
+            assertEquals(restored_sparsebean.getTestString(), "Test String");
+
+            try {
+                manager_sparsebean.insert(sparse_bean);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(true);
+            }
+            assertEquals(1000, manager_sparsebean.update(sparse_bean));
+
+            sparse_bean.setId(1001);
+            assertEquals(-1, manager_sparsebean.update(sparse_bean));    // not there; update should fail
+
+            manager_sparsebean.remove();
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testDelete(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean = new SimpleBean();
+
+            bean.setTestString("This is my test string");
+
+            var id1 = manager.save(bean);
+            assertNotNull(manager.restore(id1));
+            manager.delete(id1);
+            assertNull(manager.restoreFirst(manager.getRestoreQuery(id1)));
+
+            var id2 = manager.save(bean);
+            assertNotNull(manager.restoreFirst(manager.getRestoreQuery(id2)));
+            manager.delete(manager.getDeleteQuery(id2));
+            assertNull(manager.restore(id2));
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestore(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            var uuid1 = UUID.randomUUID();
+            var uuid2 = UUID.randomUUID();
+            var uuid3 = UUID.randomUUID();
+
+            bean1.setTestString("This is bean1");
+            bean1.setUuid(uuid1);
+            bean1.setEnum(SomeEnum.VALUE_ONE);
+            bean2.setTestString("This is bean2");
+            bean2.setUuid(uuid2);
+            bean2.setEnum(SomeEnum.VALUE_TWO);
+            bean3.setTestString("This is bean3");
+            bean3.setUuid(uuid3);
+            bean3.setEnum(SomeEnum.VALUE_THREE);
+
+            manager.save(bean1);
+            manager.save(bean2);
+            manager.save(bean3);
+
+            var list = manager.restore();
+
+            assertEquals(list.size(), 3);
+
+            for (var bean : list) {
+                assertNotNull(bean);
+                assertTrue(bean != bean1 || bean != bean2 || bean != bean3);
+                assertTrue(
+                    bean.getTestString().equals("This is bean1") &&
+                    bean.getUuid().equals(uuid1) &&
+                    bean.getEnum().equals(SomeEnum.VALUE_ONE) ||
+
+                    bean.getTestString().equals("This is bean2") &&
+                    bean.getUuid().equals(uuid2) &&
+                    bean.getEnum().equals(SomeEnum.VALUE_TWO) ||
+
+                    bean.getTestString().equals("This is bean3") &&
+                    bean.getUuid().equals(uuid3) &&
+                    bean.getEnum().equals(SomeEnum.VALUE_THREE));
+            }
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreRowProcessor(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            final var uuid1 = UUID.randomUUID();
+            final var uuid2 = UUID.randomUUID();
+            final var uuid3 = UUID.randomUUID();
+
+            bean1.setTestString("This is bean1");
+            bean1.setUuid(uuid1);
+            bean1.setEnum(SomeEnum.VALUE_ONE);
+            bean2.setTestString("This is bean2");
+            bean2.setUuid(uuid2);
+            bean2.setEnum(SomeEnum.VALUE_TWO);
+            bean3.setTestString("This is bean3");
+            bean3.setUuid(uuid3);
+            bean3.setEnum(SomeEnum.VALUE_THREE);
+
+            manager.save(bean1);
+            manager.save(bean2);
+            manager.save(bean3);
+
+            final var count = new int[]{0};
+            manager.restore(new DbRowProcessor() {
+                public boolean processRow(ResultSet resultSet)
+                throws SQLException {
+                    count[0]++;
+
+                    var test_string = resultSet.getString("testString");
+                    assertTrue(
+                        test_string.equals("This is bean1") ||
+                        test_string.equals("This is bean2") ||
+                        test_string.equals("This is bean3"));
+
+                    var uuid = resultSet.getString("uuid");
+                    assertTrue(
+                        uuid.equals(uuid1.toString()) ||
+                        uuid.equals(uuid2.toString()) ||
+                        uuid.equals(uuid3.toString()));
+
+                    return true;
+                }
+            });
+
+            assertEquals(count[0], 3);
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testRestoreQueryRowProcessor(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+
+            final var uuid1 = UUID.randomUUID();
+            final var uuid2 = UUID.randomUUID();
+            final var uuid3 = UUID.randomUUID();
+
+            bean1.setTestString("This is bean1");
+            bean1.setUuid(uuid1);
+            bean2.setTestString("This is bean2");
+            bean2.setUuid(uuid2);
+            bean3.setTestString("This is bean3");
+            bean3.setUuid(uuid3);
+
+            manager.save(bean1);
+            manager.save(bean2);
+            manager.save(bean3);
+
+            final var count = new int[]{0};
+            manager.restore(manager.getRestoreQuery().where("testString", "LIKE", "%bean2"), new DbRowProcessor() {
+                public boolean processRow(ResultSet resultSet)
+                throws SQLException {
+                    count[0]++;
+
+                    var test_string = resultSet.getString("testString");
+                    assertEquals("This is bean2", test_string);
+
+                    var uuid = resultSet.getString("uuid");
+                    assertEquals(uuid, uuid2.toString());
+
+                    return true;
+                }
+            });
+
+            assertEquals(count[0], 1);
+        } finally {
+            tearDown(manager);
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testCount(Datasource datasource) {
+        var manager = setUp(datasource);
+        try {
+            var bean1 = new SimpleBean();
+            var bean2 = new SimpleBean();
+            var bean3 = new SimpleBean();
+            var bean4 = new SimpleBean();
+            var bean5 = new SimpleBean();
+
+            bean1.setTestString("bean set 1");
+            bean2.setTestString("bean set 1");
+            bean3.setTestString("bean set 1");
+            bean4.setTestString("bean set 2");
+            bean5.setTestString("bean set 2");
+
+            manager.save(bean1);
+            manager.save(bean2);
+            manager.save(bean3);
+            manager.save(bean4);
+            manager.save(bean5);
+
+            assertEquals(manager.count(), 5);
+
+            manager.delete(bean1.getId());
+            manager.delete(bean2.getId());
+            manager.delete(bean3.getId());
+
+            assertEquals(manager.count(), 2);
+        } finally {
+            tearDown(manager);
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerUnique.java

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import rife.database.Datasource;
+import rife.database.TestDatasources;
+import rife.database.exceptions.DatabaseException;
+import rife.database.querymanagers.generic.beans.UniqueBean;
+
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestGenericQueryManagerUnique {
+    private GenericQueryManager<UniqueBean> uniqueManager_ = null;
+
+    private UniqueBean createNewUniqueBean() {
+        return new UniqueBean();
+    }
+
+    protected void setUp(Datasource datasource) {
+        uniqueManager_ = GenericQueryManagerFactory.getInstance(datasource, UniqueBean.class);
+        uniqueManager_.install();
+    }
+
+    protected void tearDown() {
+        uniqueManager_.remove();
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGetBaseClass(Datasource datasource) {
+        setUp(datasource);
+        try {
+            assertSame(UniqueBean.class, uniqueManager_.getBaseClass());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testInstallCustomQuery(Datasource datasource) {
+        setUp(datasource);
+        try {
+            uniqueManager_.remove();
+            uniqueManager_.install(uniqueManager_.getInstallTableQuery());
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testValidationContextUnique(Datasource datasource) {
+        setUp(datasource);
+        try {
+            // uniqueness of individual properties
+            UniqueBean bean1 = createNewUniqueBean();
+            bean1.setTestString("test_string");
+            bean1.setAnotherString("another_string_one");
+            bean1.setThirdString("third_string_one");
+            assertTrue(bean1.validate(uniqueManager_));
+            int id1 = uniqueManager_.save(bean1);
+
+            bean1 = uniqueManager_.restore(id1);
+            bean1.setTestString("test_string_one");
+            assertTrue(bean1.validate(uniqueManager_));
+            assertEquals(id1, uniqueManager_.save(bean1));
+
+            UniqueBean bean2 = createNewUniqueBean();
+            bean2.setTestString("test_string_one");
+            bean2.setAnotherString("another_string_two");
+            bean2.setThirdString("third_string_two");
+            assertFalse(bean2.validate(uniqueManager_));
+            try {
+                uniqueManager_.save(bean2);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            bean2.resetValidation();
+            bean2.setTestString("test_string_two");
+            bean2.setAnotherString("another_string_two");
+            assertTrue(bean2.validate(uniqueManager_));
+            int id2 = uniqueManager_.save(bean2);
+            assertTrue(id1 != id2);
+
+            bean1.resetValidation();
+            bean1.setTestString("test_string_two");
+            assertFalse(bean1.validate(uniqueManager_));
+            try {
+                uniqueManager_.save(bean1);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            // uniqueness of multiple properties
+            UniqueBean bean3 = createNewUniqueBean();
+            bean3.setTestString("test_string_three");
+            bean3.setAnotherString("another_string");
+            bean3.setThirdString("third_string");
+            assertTrue(bean3.validate(uniqueManager_));
+            int id3 = uniqueManager_.save(bean3);
+
+            bean3 = uniqueManager_.restore(id3);
+            bean3.setAnotherString("another_string_three");
+            bean3.setThirdString("third_string_three");
+            assertTrue(bean3.validate(uniqueManager_));
+            assertEquals(id3, uniqueManager_.save(bean3));
+
+            UniqueBean bean4 = createNewUniqueBean();
+            bean4.setTestString("test_string_four");
+            bean4.setAnotherString("another_string_three");
+            bean4.setThirdString("third_string_three");
+            assertFalse(bean4.validate(uniqueManager_));
+            try {
+                uniqueManager_.save(bean4);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            bean4.resetValidation();
+            bean4.setAnotherString("another_string_four");
+            bean4.setThirdString("third_string_four");
+            assertTrue(bean4.validate(uniqueManager_));
+            int id4 = uniqueManager_.save(bean4);
+            assertTrue(id3 != id4);
+
+            bean3.resetValidation();
+            bean3.setAnotherString("another_string_four");
+            bean3.setThirdString("third_string_four");
+            assertFalse(bean3.validate(uniqueManager_));
+            try {
+                uniqueManager_.save(bean3);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            UniqueBean bean5 = createNewUniqueBean();
+            bean5.setTestString("test_string_five");
+            bean5.setAnotherString("another_string_five");
+            assertTrue(bean5.validate(uniqueManager_));
+            uniqueManager_.save(bean5);
+
+            UniqueBean bean6 = createNewUniqueBean();
+            bean6.setTestString("test_string_six");
+            bean6.setAnotherString("another_string_five");
+            assertTrue(bean6.validate(uniqueManager_));
+            // this is DB-specific
+//			try
+//			{
+//				uniqueManager_.save(bean6);
+//				fail();
+//			}
+//			catch (DatabaseException e)
+//			{
+//				assertTrue(e.getCause() instanceof SQLException);
+//			}
+        } finally {
+            tearDown();
+        }
+    }
+
+    @ParameterizedTest
+    @ArgumentsSource(TestDatasources.class)
+    public void testGroupValidationContextUnique(Datasource datasource) {
+        setUp(datasource);
+        try {
+            // uniqueness of individual properties
+            UniqueBean bean1 = createNewUniqueBean();
+            bean1.setTestString("test_string");
+            bean1.setAnotherString("another_string_one");
+            bean1.setThirdString("third_string_one");
+            assertTrue(bean1.validateGroup("group1", uniqueManager_));
+            bean1.resetValidation();
+            assertTrue(bean1.validateGroup("group2", uniqueManager_));
+            int id1 = uniqueManager_.save(bean1);
+
+            bean1 = uniqueManager_.restore(id1);
+            bean1.setTestString("test_string_one");
+            assertTrue(bean1.validateGroup("group1", uniqueManager_));
+            bean1.resetValidation();
+            assertTrue(bean1.validateGroup("group2", uniqueManager_));
+            assertEquals(id1, uniqueManager_.save(bean1));
+
+            UniqueBean bean2 = createNewUniqueBean();
+            bean2.setTestString("test_string_one");
+            bean2.setAnotherString("another_string_two");
+            bean2.setThirdString("third_string_two");
+            assertFalse(bean2.validateGroup("group1", uniqueManager_));
+            bean2.resetValidation();
+            assertFalse(bean2.validateGroup("group2", uniqueManager_));
+            try {
+                uniqueManager_.save(bean2);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+
+            bean2.resetValidation();
+            bean2.setTestString("test_string_two");
+            bean2.setAnotherString("another_string_two");
+            assertTrue(bean2.validateGroup("group1", uniqueManager_));
+            bean2.resetValidation();
+            assertTrue(bean2.validateGroup("group2", uniqueManager_));
+            int id2 = uniqueManager_.save(bean2);
+            assertTrue(id1 != id2);
+
+            bean1.resetValidation();
+            bean1.setTestString("test_string_two");
+            assertFalse(bean1.validateGroup("group1", uniqueManager_));
+            bean1.resetValidation();
+            assertFalse(bean1.validateGroup("group2", uniqueManager_));
+            try {
+                uniqueManager_.save(bean1);
+                fail();
+            } catch (DatabaseException e) {
+                assertTrue(e.getCause() instanceof SQLException);
+            }
+        } finally {
+            tearDown();
+        }
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/beans/BeanImpl.java

@@ -0,0 +1,312 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.Validation;
+
+import java.math.BigDecimal;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+
+public class BeanImpl extends Validation {
+    private int id_ = -1;
+
+    private String propertyString_ = null;
+    private StringBuffer propertyStringBuffer_ = null;
+    private java.util.Date propertyDate_ = null;
+    private java.util.Calendar propertyCalendar_ = null;
+    private java.sql.Date propertySqlDate_ = null;
+    private java.sql.Time propertyTime_ = null;
+    private java.sql.Timestamp propertyTimestamp_ = null;
+    private char propertyChar_ = 0;
+    private Character propertyCharacterObject_ = null;
+    private boolean propertyBoolean_ = false;
+    private Boolean propertyBooleanObject_ = null;
+    private byte propertyByte_ = 0;
+    private Byte propertyByteObject_ = null;
+    private double propertyDouble_ = 0.0d;
+    private Double propertyDoubleObject_ = null;
+    private float propertyFloat_ = 0.0f;
+    private Float propertyFloatObject_ = null;
+    private int propertyInt_ = 0;
+    private Integer propertyIntegerObject_ = null;
+    private long propertyLong_ = 0;
+    private Long propertyLongObject_ = null;
+    private short propertyShort_ = 0;
+    private Short propertyShortObject_ = null;
+    private BigDecimal propertyBigDecimal_ = null;
+
+    public BeanImpl() {
+    }
+
+    protected void activateValidation() {
+        addConstraint(new ConstrainedProperty("propertyBigDecimal").precision(18).scale(5));
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public String getPropertyString() {
+        return propertyString_;
+    }
+
+    public void setPropertyString(String propertyString) {
+        this.propertyString_ = propertyString;
+    }
+
+    public StringBuffer getPropertyStringBuffer() {
+        return propertyStringBuffer_;
+    }
+
+    public void setPropertyStringBuffer(StringBuffer propertyStringBuffer) {
+        propertyStringBuffer = propertyStringBuffer;
+    }
+
+    public java.util.Date getPropertyDate() {
+        return propertyDate_;
+    }
+
+    public void setPropertyDate(java.util.Date propertyDate) {
+        propertyDate_ = propertyDate;
+    }
+
+    public java.util.Calendar getPropertyCalendar() {
+        return propertyCalendar_;
+    }
+
+    public void setPropertyCalendar(java.util.Calendar propertyCalendar) {
+        propertyCalendar_ = propertyCalendar;
+    }
+
+    public java.sql.Date getPropertySqlDate() {
+        return propertySqlDate_;
+    }
+
+    public void setPropertySqlDate(java.sql.Date propertySqlDate) {
+        propertySqlDate_ = propertySqlDate;
+    }
+
+    public java.sql.Time getPropertyTime() {
+        return propertyTime_;
+    }
+
+    public void setPropertyTime(java.sql.Time propertyTime) {
+        propertyTime_ = propertyTime;
+    }
+
+    public java.sql.Timestamp getPropertyTimestamp() {
+        return propertyTimestamp_;
+    }
+
+    public void setPropertyTimestamp(java.sql.Timestamp propertyTimestamp) {
+        propertyTimestamp_ = propertyTimestamp;
+    }
+
+    public boolean isPropertyBoolean() {
+        return propertyBoolean_;
+    }
+
+    public void setPropertyBoolean(boolean propertyBoolean) {
+        propertyBoolean_ = propertyBoolean;
+    }
+
+    public Boolean getPropertyBooleanObject() {
+        return propertyBooleanObject_;
+    }
+
+    public void setPropertyBooleanObject(Boolean propertyBooleanObject) {
+        propertyBooleanObject_ = propertyBooleanObject;
+    }
+
+    public byte getPropertyByte() {
+        return propertyByte_;
+    }
+
+    public Byte getPropertyByteObject() {
+        return propertyByteObject_;
+    }
+
+    public void setPropertyByte(byte propertyByte) {
+        propertyByte_ = propertyByte;
+    }
+
+    public void setPropertyByteObject(Byte propertyByteObject) {
+        propertyByteObject_ = propertyByteObject;
+    }
+
+    public double getPropertyDouble() {
+        return propertyDouble_;
+    }
+
+    public void setPropertyDouble(double propertyDouble) {
+        propertyDouble_ = propertyDouble;
+    }
+
+    public void setPropertyDoubleObject(Double propertyDoubleObject) {
+        propertyDoubleObject_ = propertyDoubleObject;
+    }
+
+    public Double getPropertyDoubleObject() {
+        return propertyDoubleObject_;
+    }
+
+    public float getPropertyFloat() {
+        return propertyFloat_;
+    }
+
+    public void setPropertyFloat(float propertyFloat) {
+        propertyFloat_ = propertyFloat;
+    }
+
+    public void setPropertyFloatObject(Float propertyFloatObject) {
+        propertyFloatObject_ = propertyFloatObject;
+    }
+
+    public Float getPropertyFloatObject() {
+        return propertyFloatObject_;
+    }
+
+    public int getPropertyInt() {
+        return propertyInt_;
+    }
+
+    public void setPropertyInt(int propertyInt) {
+        propertyInt_ = propertyInt;
+    }
+
+    public Integer getPropertyIntegerObject() {
+        return propertyIntegerObject_;
+    }
+
+    public void setPropertyIntegerObject(Integer propertyIntegerObject) {
+        propertyIntegerObject_ = propertyIntegerObject;
+    }
+
+    public long getPropertyLong() {
+        return propertyLong_;
+    }
+
+    public void setPropertyLong(long propertyLong) {
+        propertyLong_ = propertyLong;
+    }
+
+    public Long getPropertyLongObject() {
+        return propertyLongObject_;
+    }
+
+    public void setPropertyLongObject(Long propertyLongObject) {
+        propertyLongObject_ = propertyLongObject;
+    }
+
+    public short getPropertyShort() {
+        return propertyShort_;
+    }
+
+    public void setPropertyShort(short propertyShort) {
+        propertyShort_ = propertyShort;
+    }
+
+    public Short getPropertyShortObject() {
+        return propertyShortObject_;
+    }
+
+    public void setPropertyShortObject(Short propertyShortObject) {
+        propertyShortObject_ = propertyShortObject;
+    }
+
+    public char getPropertyChar() {
+        return propertyChar_;
+    }
+
+    public void setPropertyChar(char propertyChar) {
+        propertyChar_ = propertyChar;
+    }
+
+    public Character getPropertyCharacterObject() {
+        return propertyCharacterObject_;
+    }
+
+    public void setPropertyCharacterObject(Character propertyCharacterObject) {
+        propertyCharacterObject_ = propertyCharacterObject;
+    }
+
+    public BigDecimal getPropertyBigDecimal() {
+        return propertyBigDecimal_;
+    }
+
+    public void setPropertyBigDecimal(BigDecimal propertyBigDecimal) {
+        propertyBigDecimal_ = propertyBigDecimal;
+    }
+
+    public static BeanImpl getPopulatedBean() {
+        BeanImpl bean = new BeanImpl();
+        Calendar cal = Calendar.getInstance();
+        cal.set(2002, Calendar.JUNE, 18, 15, 26, 14);
+        cal.set(Calendar.MILLISECOND, 764);
+        bean.setPropertyBigDecimal(new BigDecimal("219038743.392874"));
+        bean.setPropertyBoolean(true);
+        bean.setPropertyBooleanObject(false);
+        bean.setPropertyByte((byte) 89);
+        bean.setPropertyByteObject((byte) 34);
+        bean.setPropertyCalendar(cal);
+        bean.setPropertyChar('v');
+        bean.setPropertyCharacterObject('r');
+        bean.setPropertyDate(cal.getTime());
+        bean.setPropertyDouble(53348.34d);
+        bean.setPropertyDoubleObject(143298.692d);
+        bean.setPropertyFloat(98634.2f);
+        bean.setPropertyFloatObject(8734.7f);
+        bean.setPropertyInt(545);
+        bean.setPropertyIntegerObject(968);
+        bean.setPropertyLong(34563L);
+        bean.setPropertyLongObject(66875L);
+        bean.setPropertyShort((short) 43);
+        bean.setPropertyShortObject((short) 68);
+        bean.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime()));
+        bean.setPropertyString("someotherstring");
+        bean.setPropertyStringBuffer(new StringBuffer("someotherstringbuff"));
+        bean.setPropertyTime(new Time(cal.getTime().getTime()));
+        bean.setPropertyTimestamp(new Timestamp(cal.getTime().getTime()));
+
+        return bean;
+    }
+
+    public static BeanImpl getNullBean() {
+        BeanImpl bean = new BeanImpl();
+        bean.setPropertyBigDecimal(null);
+        bean.setPropertyBoolean(false);
+        bean.setPropertyBooleanObject(false);
+        bean.setPropertyByte((byte) 0);
+        bean.setPropertyByteObject((byte) 0);
+        bean.setPropertyDate(null);
+        bean.setPropertyCalendar(null);
+        bean.setPropertyChar((char) 0);
+        bean.setPropertyCharacterObject(null);
+        bean.setPropertyDouble(0d);
+        bean.setPropertyDoubleObject(0d);
+        bean.setPropertyFloat(0f);
+        bean.setPropertyFloatObject(0f);
+        bean.setPropertyInt(0);
+        bean.setPropertyIntegerObject(0);
+        bean.setPropertyLong(0L);
+        bean.setPropertyLongObject(0L);
+        bean.setPropertyShort((short) 0);
+        bean.setPropertyShortObject((short) 0);
+        bean.setPropertySqlDate(null);
+        bean.setPropertyString(null);
+        bean.setPropertyStringBuffer(null);
+        bean.setPropertyTime(null);
+        bean.setPropertyTimestamp(null);
+
+        return bean;
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/beans/BinaryBean.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+public class BinaryBean {
+    private int id_ = -1;
+    private byte[] theBytes_;
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public byte[] getTheBytes() {
+        return theBytes_;
+    }
+
+    public void setTheBytes(byte[] binary) {
+        theBytes_ = binary;
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksBean.java

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.database.querymanagers.generic.Callbacks;
+import rife.validation.ConstrainedProperty;
+import rife.validation.Validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CallbacksBean extends Validation implements Callbacks<CallbacksBean> {
+    private int id_ = -1;
+    private String testString_ = null;
+
+    private static List<String> sExecutedCallbacks = new ArrayList<>();
+
+    private boolean beforeValidateReturn_ = true;
+    private boolean beforeInsertReturn_ = true;
+    private static boolean sBeforeDeleteReturn = true;
+    private boolean beforeSaveReturn_ = true;
+    private boolean beforeUpdateReturn_ = true;
+    private boolean afterValidateReturn_ = true;
+    private boolean afterInsertReturn_ = true;
+    private static boolean sAfterDeleteReturn = true;
+    private boolean afterSaveReturn_ = true;
+    private boolean afterUpdateReturn_ = true;
+    private static boolean sAfterRestoreReturn = true;
+
+    public CallbacksBean() {
+    }
+
+    protected void activateValidation() {
+        addConstraint(new ConstrainedProperty("id").identifier(true).notNull(true));
+        addConstraint(new ConstrainedProperty("testString").notNull(true));
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public String toString() {
+        return id_ + ";" + testString_;
+    }
+
+    public static List<String> getExecutedCallbacks() {
+        return sExecutedCallbacks;
+    }
+
+    public static void clearExecuteCallbacks() {
+        sExecutedCallbacks = new ArrayList<String>();
+    }
+
+    public void setBeforeValidateReturn(boolean beforeValidateReturn) {
+        beforeValidateReturn_ = beforeValidateReturn;
+    }
+
+    public void setBeforeInsertReturn(boolean beforeInsertReturn) {
+        beforeInsertReturn_ = beforeInsertReturn;
+    }
+
+    public static void setBeforeDeleteReturn(boolean beforeDeleteReturn) {
+        sBeforeDeleteReturn = beforeDeleteReturn;
+    }
+
+    public void setBeforeSaveReturn(boolean beforeSaveReturn) {
+        beforeSaveReturn_ = beforeSaveReturn;
+    }
+
+    public void setBeforeUpdateReturn(boolean beforeUpdateReturn) {
+        beforeUpdateReturn_ = beforeUpdateReturn;
+    }
+
+    public void setAfterValidateReturn(boolean afterValidateReturn) {
+        afterValidateReturn_ = afterValidateReturn;
+    }
+
+    public void setAfterInsertReturn(boolean afterInsertReturn) {
+        afterInsertReturn_ = afterInsertReturn;
+    }
+
+    public static void setAfterDeleteReturn(boolean afterDeleteReturn) {
+        sAfterDeleteReturn = afterDeleteReturn;
+    }
+
+    public void setAfterSaveReturn(boolean afterSaveReturn) {
+        afterSaveReturn_ = afterSaveReturn;
+    }
+
+    public void setAfterUpdateReturn(boolean afterUpdateReturn) {
+        afterUpdateReturn_ = afterUpdateReturn;
+    }
+
+    public static void setAfterRestoreReturn(boolean afterRestoreReturn) {
+        sAfterRestoreReturn = afterRestoreReturn;
+    }
+
+    public boolean beforeValidate(CallbacksBean object) {
+        sExecutedCallbacks.add("beforeValidate " + object.toString());
+        return beforeValidateReturn_;
+    }
+
+    public boolean beforeInsert(CallbacksBean object) {
+        sExecutedCallbacks.add("beforeInsert " + object.toString());
+        return beforeInsertReturn_;
+    }
+
+    public boolean beforeDelete(int objectId) {
+        sExecutedCallbacks.add("beforeDelete " + objectId);
+        return sBeforeDeleteReturn;
+    }
+
+    public boolean beforeSave(CallbacksBean object) {
+        sExecutedCallbacks.add("beforeSave " + object.toString());
+        return beforeSaveReturn_;
+    }
+
+    public boolean beforeUpdate(CallbacksBean object) {
+        sExecutedCallbacks.add("beforeUpdate " + object.toString());
+        return beforeUpdateReturn_;
+    }
+
+    public boolean afterValidate(CallbacksBean object) {
+        sExecutedCallbacks.add("afterValidate " + object.toString());
+        return afterValidateReturn_;
+    }
+
+    public boolean afterInsert(CallbacksBean object, boolean success) {
+        sExecutedCallbacks.add("afterInsert " + success + " " + object.toString());
+        return afterInsertReturn_;
+    }
+
+    public boolean afterDelete(int objectId, boolean success) {
+        sExecutedCallbacks.add("afterDelete " + success + " " + objectId);
+        return sAfterDeleteReturn;
+    }
+
+    public boolean afterSave(CallbacksBean object, boolean success) {
+        sExecutedCallbacks.add("afterSave " + success + " " + object.toString());
+        return afterSaveReturn_;
+    }
+
+    public boolean afterUpdate(CallbacksBean object, boolean success) {
+        sExecutedCallbacks.add("afterUpdate " + success + " " + object.toString());
+        return afterUpdateReturn_;
+    }
+
+    public boolean afterRestore(CallbacksBean object) {
+        sExecutedCallbacks.add("afterRestore " + object.toString());
+        return sAfterRestoreReturn;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksProviderBean.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import rife.database.querymanagers.generic.Callbacks;
+import rife.database.querymanagers.generic.CallbacksProvider;
+
+public class CallbacksProviderBean implements CallbacksProvider<CallbacksProviderBean> {
+    private int id_ = -1;
+    private String testString_ = null;
+
+    static TheCallbacks callbacks_ = new TheCallbacks();
+
+    public CallbacksProviderBean() {
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public Callbacks<CallbacksProviderBean> getCallbacks() {
+        return callbacks_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public String toString() {
+        return id_ + ";" + testString_;
+    }
+
+    public static List<String> getExecutedCallbacks() {
+        return callbacks_.getExecutedCallbacks();
+    }
+
+    public static void clearExecuteCallbacks() {
+        callbacks_.clearExecuteCallbacks();
+    }
+
+    public static class TheCallbacks implements Callbacks<CallbacksProviderBean> {
+        private List<String> mExecutedCallbacks = new ArrayList<String>();
+
+        public List<String> getExecutedCallbacks() {
+            return mExecutedCallbacks;
+        }
+
+        public void clearExecuteCallbacks() {
+            mExecutedCallbacks = new ArrayList<String>();
+        }
+
+        public boolean beforeValidate(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("beforeValidate " + object.toString());
+            return true;
+        }
+
+        public boolean beforeInsert(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("beforeInsert " + object.toString());
+            return true;
+        }
+
+        public boolean beforeDelete(int objectId) {
+            mExecutedCallbacks.add("beforeDelete " + objectId);
+            return true;
+        }
+
+        public boolean beforeSave(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("beforeSave " + object.toString());
+            return true;
+        }
+
+        public boolean beforeUpdate(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("beforeUpdate " + object.toString());
+            return true;
+        }
+
+        public boolean afterValidate(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("afterValidate " + object.toString());
+            return true;
+        }
+
+        public boolean afterInsert(CallbacksProviderBean object, boolean success) {
+            mExecutedCallbacks.add("afterInsert " + success + " " + object.toString());
+            return true;
+        }
+
+        public boolean afterDelete(int objectId, boolean success) {
+            mExecutedCallbacks.add("afterDelete " + success + " " + objectId);
+            return true;
+        }
+
+        public boolean afterSave(CallbacksProviderBean object, boolean success) {
+            mExecutedCallbacks.add("afterSave " + success + " " + object.toString());
+            return true;
+        }
+
+        public boolean afterUpdate(CallbacksProviderBean object, boolean success) {
+            mExecutedCallbacks.add("afterUpdate " + success + " " + object.toString());
+            return true;
+        }
+
+        public boolean afterRestore(CallbacksProviderBean object) {
+            mExecutedCallbacks.add("afterRestore " + object.toString());
+            return true;
+        }
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksSparseBean.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.database.querymanagers.generic.Callbacks;
+import rife.validation.ConstrainedProperty;
+import rife.validation.Validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CallbacksSparseBean extends Validation implements Callbacks<CallbacksSparseBean> {
+    private int id_ = -1;
+    private String testString_ = null;
+
+    private List<String> executedCallbacks_ = new ArrayList<>();
+
+    private boolean beforeValidateReturn_ = true;
+    private boolean beforeInsertReturn_ = true;
+    private boolean beforeDeleteReturn_ = true;
+    private boolean beforeSaveReturn_ = true;
+    private boolean beforeUpdateReturn_ = true;
+    private boolean afterValidateReturn_ = true;
+    private boolean afterInsertReturn_ = true;
+    private boolean afterDeleteReturn_ = true;
+    private boolean afterSaveReturn_ = true;
+    private boolean afterUpdateReturn_ = true;
+    private boolean afterRestoreReturn_ = true;
+
+    public void activateValidation() {
+        addConstraint(new ConstrainedProperty("id").identifier(true).sparse(true));
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public String toString() {
+        return id_ + ";" + testString_;
+    }
+
+    public List<String> getExecutedCallbacks() {
+        return executedCallbacks_;
+    }
+
+    public void clearExecuteCallbacks() {
+        executedCallbacks_ = new ArrayList<String>();
+    }
+
+    public void setBeforeValidateReturn(boolean beforeValidateReturn) {
+        beforeValidateReturn_ = beforeValidateReturn;
+    }
+
+    public void setBeforeInsertReturn(boolean beforeInsertReturn) {
+        beforeInsertReturn_ = beforeInsertReturn;
+    }
+
+    public void setBeforeDeleteReturn(boolean beforeDeleteReturn) {
+        beforeDeleteReturn_ = beforeDeleteReturn;
+    }
+
+    public void setBeforeSaveReturn(boolean beforeSaveReturn) {
+        beforeSaveReturn_ = beforeSaveReturn;
+    }
+
+    public void setBeforeUpdateReturn(boolean beforeUpdateReturn) {
+        beforeUpdateReturn_ = beforeUpdateReturn;
+    }
+
+    public void setAfterValidateReturn(boolean afterValidateReturn) {
+        afterValidateReturn_ = afterValidateReturn;
+    }
+
+    public void setAfterInsertReturn(boolean afterInsertReturn) {
+        afterInsertReturn_ = afterInsertReturn;
+    }
+
+    public void setAfterDeleteReturn(boolean afterDeleteReturn) {
+        afterDeleteReturn_ = afterDeleteReturn;
+    }
+
+    public void setAfterSaveReturn(boolean afterSaveReturn) {
+        afterSaveReturn_ = afterSaveReturn;
+    }
+
+    public void setAfterUpdateReturn(boolean afterUpdateReturn) {
+        afterUpdateReturn_ = afterUpdateReturn;
+    }
+
+    public void setAfterRestoreReturn(boolean afterRestoreReturn) {
+        afterRestoreReturn_ = afterRestoreReturn;
+    }
+
+    public boolean beforeValidate(CallbacksSparseBean object) {
+        executedCallbacks_.add("beforeValidate " + object.toString());
+        return beforeValidateReturn_;
+    }
+
+    public boolean beforeInsert(CallbacksSparseBean object) {
+        executedCallbacks_.add("beforeInsert " + object.toString());
+        return beforeInsertReturn_;
+    }
+
+    public boolean beforeDelete(int objectId) {
+        executedCallbacks_.add("beforeDelete " + objectId);
+        return beforeDeleteReturn_;
+    }
+
+    public boolean beforeSave(CallbacksSparseBean object) {
+        executedCallbacks_.add("beforeSave " + object.toString());
+        return beforeSaveReturn_;
+    }
+
+    public boolean beforeUpdate(CallbacksSparseBean object) {
+        executedCallbacks_.add("beforeUpdate " + object.toString());
+        return beforeUpdateReturn_;
+    }
+
+    public boolean afterValidate(CallbacksSparseBean object) {
+        executedCallbacks_.add("afterValidate " + object.toString());
+        return afterValidateReturn_;
+    }
+
+    public boolean afterInsert(CallbacksSparseBean object, boolean success) {
+        executedCallbacks_.add("afterInsert " + success + " " + object.toString());
+        return afterInsertReturn_;
+    }
+
+    public boolean afterDelete(int objectId, boolean success) {
+        executedCallbacks_.add("afterDelete " + success + " " + objectId);
+        return afterDeleteReturn_;
+    }
+
+    public boolean afterSave(CallbacksSparseBean object, boolean success) {
+        executedCallbacks_.add("afterSave " + success + " " + object.toString());
+        return afterSaveReturn_;
+    }
+
+    public boolean afterUpdate(CallbacksSparseBean object, boolean success) {
+        executedCallbacks_.add("afterUpdate " + success + " " + object.toString());
+        return afterUpdateReturn_;
+    }
+
+    public boolean afterRestore(CallbacksSparseBean object) {
+        executedCallbacks_.add("afterRestore " + object.toString());
+        return afterRestoreReturn_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/ChildBean.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+public class ChildBean extends ParentBean {
+    private String childString_ = null;
+
+    public void setChildString(String childString) {
+        childString_ = childString;
+    }
+
+    public String getChildString() {
+        return childString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/ConstrainedBean.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.MetaData;
+
+public class ConstrainedBean extends MetaData {
+    private int identifier_ = -1;
+    private Integer linkBean_ = null;
+    private String testString_ = null;
+
+    public ConstrainedBean() {
+    }
+
+    public void activateMetaData() {
+        addConstraint(new ConstrainedProperty("identifier").identifier(true));
+        addConstraint(new ConstrainedProperty("linkBean").manyToOne(LinkBean.class, "id"));
+    }
+
+    public void setIdentifier(int identifier) {
+        identifier_ = identifier;
+    }
+
+    public int getIdentifier() {
+        return identifier_;
+    }
+
+    public void setLinkBean(Integer linkBean) {
+        linkBean_ = linkBean;
+    }
+
+    public Integer getLinkBean() {
+        return linkBean_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/LinkBean.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+public class LinkBean {
+    private int id_ = -1;
+    private String testString_ = null;
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/MMFirstBean.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.MetaData;
+
+import java.util.Collection;
+
+public class MMFirstBean extends MetaData {
+    private Integer identifier_;
+    private Collection<MMSecondBean> secondBeans_;
+    private String firstString_;
+
+    public MMFirstBean() {
+    }
+
+    public void activateMetaData() {
+        addConstraint(new ConstrainedProperty("identifier").identifier(true));
+        addConstraint(new ConstrainedProperty("secondBeans").manyToMany());
+    }
+
+    public void setIdentifier(Integer identifier) {
+        identifier_ = identifier;
+    }
+
+    public Integer getIdentifier() {
+        return identifier_;
+    }
+
+    public void setSecondBeans(Collection<MMSecondBean> secondBeans) {
+        secondBeans_ = secondBeans;
+    }
+
+    public Collection<MMSecondBean> getSecondBeans() {
+        return secondBeans_;
+    }
+
+    public void setFirstString(String firstString) {
+        firstString_ = firstString;
+    }
+
+    public String getFirstString() {
+        return firstString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/MMSecondBean.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.MetaData;
+
+import java.util.Collection;
+
+public class MMSecondBean extends MetaData {
+    private Integer identifier_;
+    private Collection<MMFirstBean> firstBeans_;
+    private String secondString_;
+
+    public MMSecondBean() {
+    }
+
+    public void activateMetaData() {
+        addConstraint(new ConstrainedProperty("identifier").identifier(true));
+        addConstraint(new ConstrainedProperty("firstBeans").manyToManyAssociation());
+    }
+
+    public void setIdentifier(Integer identifier) {
+        identifier_ = identifier;
+    }
+
+    public Integer getIdentifier() {
+        return identifier_;
+    }
+
+    public void setFirstBeans(Collection<MMFirstBean> firstBeans) {
+        firstBeans_ = firstBeans;
+    }
+
+    public Collection<MMFirstBean> getFirstBeans() {
+        return firstBeans_;
+    }
+
+    public void setSecondString(String secondString) {
+        secondString_ = secondString;
+    }
+
+    public String getSecondString() {
+        return secondString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/NoDefaultConstructorBean.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+public class NoDefaultConstructorBean {
+    private int id_ = -1;
+    private int linkBean_ = -1;
+    private String testString_ = null;
+
+    public NoDefaultConstructorBean(int id) {
+        id_ = id;
+    }
+
+    public void setLinkBean(int linkBean) {
+        linkBean_ = linkBean;
+    }
+
+    public int getLinkBean() {
+        return linkBean_;
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public String toString() {
+        return id_ + ";" + linkBean_ + ";" + testString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/ParentBean.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+public class ParentBean {
+    protected int id_ = -1;
+    protected String parentString_ = null;
+
+    public void setParentString(String parentString) {
+        parentString_ = parentString;
+    }
+
+    public String getParentString() {
+        return parentString_;
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/SimpleBean.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.database.SomeEnum;
+
+import java.util.UUID;
+
+public class SimpleBean {
+    private int id_ = -1;
+    private int linkBean_ = -1;
+    private String testString_ = null;
+    private UUID uuid_ = null;
+    private SomeEnum enum_;
+
+    public void setLinkBean(int linkBean) {
+        linkBean_ = linkBean;
+    }
+
+    public int getLinkBean() {
+        return linkBean_;
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public String toString() {
+        return id_ + ";" + linkBean_ + ";" + testString_;
+    }
+
+    public UUID getUuid() {
+        return uuid_;
+    }
+
+    public void setUuid(UUID uuid) {
+        uuid_ = uuid;
+    }
+
+    public void setEnum(SomeEnum e) {
+        enum_ = e;
+    }
+
+    public SomeEnum getEnum() {
+        return enum_;
+    }
+}

lib/src/test/java/rife/database/querymanagers/generic/beans/SparseBean.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.MetaData;
+
+public class SparseBean extends MetaData {
+    private int id_ = -1;
+    private String testString_ = null;
+
+    public void activateMetaData() {
+        addConstraint(new ConstrainedProperty("id").identifier(true).sparse(true));
+    }
+
+    public void setId(int id) {
+        id_ = id;
+    }
+
+    public int getId() {
+        return id_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBean.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+import rife.validation.Validation;
+
+public class UniqueBean extends Validation {
+    private int identifier_ = -1;
+    private String testString_ = null;
+    private String anotherString_ = null;
+    private String thirdString_ = null;
+
+    public UniqueBean() {
+    }
+
+    protected void activateValidation() {
+        addConstraint(new ConstrainedProperty("identifier").identifier(true));
+        addGroup("group1")
+            .addConstraint(new ConstrainedProperty("testString").unique(true).maxLength(20).notNull(true))
+            .addConstraint(new ConstrainedProperty("anotherString").maxLength(20).notNull(true));
+        addGroup("group2")
+            .addConstraint(new ConstrainedProperty("thirdString").maxLength(20));
+
+        addConstraint(new rife.validation.ConstrainedBean().unique("anotherString", "thirdString"));
+    }
+
+    public void setIdentifier(int identifier) {
+        identifier_ = identifier;
+    }
+
+    public int getIdentifier() {
+        return identifier_;
+    }
+
+    public void setTestString(String testString) {
+        this.testString_ = testString;
+    }
+
+    public String getTestString() {
+        return testString_;
+    }
+
+    public void setAnotherString(String anotherString) {
+        anotherString_ = anotherString;
+    }
+
+    public String getAnotherString() {
+        return anotherString_;
+    }
+
+    public void setThirdString(String thirdString) {
+        thirdString_ = thirdString;
+    }
+
+    public String getThirdString() {
+        return thirdString_;
+    }
+}
+

lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBeanNotNull.java

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com)
+ * Licensed under the Apache License, Version 2.0 (the "License")
+ */
+package rife.database.querymanagers.generic.beans;
+
+import rife.validation.ConstrainedProperty;
+
+public class UniqueBeanNotNull extends UniqueBean {
+    protected void activateValidation() {
+        super.activateValidation();
+
+        addConstraint(new ConstrainedProperty("thirdString").maxLength(50).notNull(true).defaultValue(""));
+    }
+}
+