From b7d384c6347fb54746e255adfc4980c57bc401cc Mon Sep 17 00:00:00 2001
From: Simon Danner <simon.danner@gmx.de>
Date: Fri, 20 Mar 2020 23:41:54 +0100
Subject: [PATCH] Added @PersistAsBaseType to support persistent base/abstract
 bean container types

---
 .idea/codeStyles/Project.xml                  |  11 +-
 .../java/de/adito/ojcms/beans/OJBean.java     |  19 +-
 .../literals/fields/types/AbstractField.java  |  49 ++--
 .../persistence/OJPersistenceException.java   |   3 +-
 .../de/adito/ojcms/persistence/Persist.java   |   9 +-
 .../ojcms/persistence/PersistAsBaseType.java  |  32 +++
 .../datasource/AbstractBeanContent.java       |  19 +-
 .../datasource/BeanContentForContainer.java   |  40 ++-
 .../datasource/BeanPersistenceUtil.java       |  25 +-
 .../datasource/BeanProducerExtension.java     | 212 +++++++++++++---
 .../datasource/ContainerContent.java          |  69 +++--
 .../datasource/SingleBeanContent.java         |   8 +-
 .../datasource/StartupBeanRegistration.java   |   2 +
 .../ojcms/persistence/BeanLoaderForTest.java  |  38 ++-
 .../ojcms/persistence/BeanStorageForTest.java |  12 +-
 .../adito/ojcms/persistence/BeanTestData.java |  32 +--
 .../PersistentBaseContainerTest.java          | 136 ++++++++++
 .../persistence/PersistentContainerTest.java  |  48 ++--
 .../persistence/PersistentSingleBeanTest.java |   2 +-
 ...Beans.java => RegisteredBeansForTest.java} |  30 ++-
 .../cleanup/ObsoleteTableCleanup.java         |   4 +-
 .../model/BaseContainerPersistenceModel.java  | 135 ++++++++++
 .../model/ContainerPersistenceModel.java      | 235 ++++++++++++------
 .../datasource/model/PersistenceModels.java   |  23 ++
 .../model/column/BeanColumnDefinition.java    |  27 +-
 .../persistence/SQLBeanDataLoader.java        |   7 +
 .../persistence/SQLBeanDataStorage.java       |  14 +-
 .../datasource/util/DatabaseConstants.java    |   1 +
 .../model/AbstractDatabaseTest.java           |  57 ++++-
 .../BaseContainerPersistenceModelTest.java    |  81 ++++++
 .../model/ContainerPersistenceModelTest.java  |   5 +-
 .../transactions/ManagedTransaction.java      |  30 ++-
 .../transactions/TransactionalChanges.java    | 124 ++++-----
 .../ojcms/transactions/api/BeanAddition.java  |  79 ++++++
 .../ojcms/transactions/api/ITransaction.java  |  15 +-
 .../transactions/api/PersistentBeanData.java  |   8 +-
 .../transactions/spi/IBeanDataLoader.java     |  10 +
 .../transactions/spi/IBeanDataStorage.java    |  14 +-
 .../transactions/BeanTransactionTest.java     |  46 +++-
 39 files changed, 1376 insertions(+), 335 deletions(-)
 create mode 100644 ojcms-persistence/src/main/java/de/adito/ojcms/persistence/PersistAsBaseType.java
 create mode 100644 ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentBaseContainerTest.java
 rename ojcms-persistence/src/test/java/de/adito/ojcms/persistence/{RegisteredBeans.java => RegisteredBeansForTest.java} (68%)
 create mode 100644 ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModel.java
 create mode 100644 ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModelTest.java
 create mode 100644 ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/BeanAddition.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 74761e0..1b44fdc 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -53,17 +53,26 @@
       </indentOptions>
     </codeStyleSettings>
     <codeStyleSettings language="JAVA">
+      <option name="RIGHT_MARGIN" value="140" />
       <option name="LINE_COMMENT_AT_FIRST_COLUMN" value="false" />
       <option name="BLOCK_COMMENT_AT_FIRST_COLUMN" value="false" />
+      <option name="KEEP_LINE_BREAKS" value="false" />
+      <option name="KEEP_CONTROL_STATEMENT_IN_ONE_LINE" value="false" />
       <option name="BRACE_STYLE" value="2" />
       <option name="CLASS_BRACE_STYLE" value="2" />
       <option name="METHOD_BRACE_STYLE" value="2" />
+      <option name="LAMBDA_BRACE_STYLE" value="2" />
       <option name="ELSE_ON_NEW_LINE" value="true" />
       <option name="WHILE_ON_NEW_LINE" value="true" />
       <option name="CATCH_ON_NEW_LINE" value="true" />
       <option name="FINALLY_ON_NEW_LINE" value="true" />
-      <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
+      <option name="ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION" value="true" />
       <option name="ALIGN_MULTILINE_ARRAY_INITIALIZER_EXPRESSION" value="true" />
+      <option name="CALL_PARAMETERS_WRAP" value="1" />
+      <option name="PREFER_PARAMETERS_WRAP" value="true" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
+      <option name="WRAP_LONG_LINES" value="true" />
+      <option name="WRAP_ON_TYPING" value="0" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/ojcms-beans/src/main/java/de/adito/ojcms/beans/OJBean.java b/ojcms-beans/src/main/java/de/adito/ojcms/beans/OJBean.java
index 4cf2c04..f4416d3 100644
--- a/ojcms-beans/src/main/java/de/adito/ojcms/beans/OJBean.java
+++ b/ojcms-beans/src/main/java/de/adito/ojcms/beans/OJBean.java
@@ -96,9 +96,11 @@ private void _checkForDuplicateFieldsAndFireCreation()
   private void _checkForDuplicateFields()
   {
     final Set<IField<?>> checker = new HashSet<>();
-    final List<IField<?>> duplicates = streamFields()
-        .filter(pField -> !checker.add(pField))
+
+    final List<IField<?>> duplicates = streamFields() //
+        .filter(pField -> !checker.add(pField)) //
         .collect(Collectors.toList());
+
     if (!duplicates.isEmpty())
       throw new BeanFieldDuplicateException(duplicates);
   }
@@ -106,8 +108,8 @@ private void _checkForDuplicateFields()
   @Override
   public String toString()
   {
-    return getClass().getSimpleName() + "{" + stream()
-        .map(Objects::toString)
+    return getClass().getSimpleName() + "{" + stream() //
+        .map(Objects::toString) //
         .collect(Collectors.joining(", ")) + "}";
   }
 
@@ -118,12 +120,13 @@ public boolean equals(Object pOther)
       return true;
     if (pOther == null || getClass() != pOther.getClass())
       return false;
+
     final Set<FieldValueTuple<?>> identifiers = getIdentifiers();
     if (identifiers.isEmpty())
       return false;
 
     final OJBean other = (OJBean) pOther;
-    return identifiers.stream()
+    return identifiers.stream() //
         .allMatch(pIdentifier -> Objects.equals(pIdentifier.getValue(), other.getValue(pIdentifier.getField())));
   }
 
@@ -131,8 +134,8 @@ public boolean equals(Object pOther)
   public int hashCode()
   {
     final Set<FieldValueTuple<?>> identifiers = getIdentifiers();
-    return identifiers.isEmpty() ? super.hashCode() : Objects.hash(identifiers.stream()
-                                                                       .map(FieldValueTuple::getValue)
-                                                                       .toArray(Object[]::new));
+    return identifiers.isEmpty() ? super.hashCode() : Objects.hash(identifiers.stream() //
+        .map(FieldValueTuple::getValue) //
+        .toArray(Object[]::new));
   }
 }
diff --git a/ojcms-beans/src/main/java/de/adito/ojcms/beans/literals/fields/types/AbstractField.java b/ojcms-beans/src/main/java/de/adito/ojcms/beans/literals/fields/types/AbstractField.java
index 02131d9..06fe293 100644
--- a/ojcms-beans/src/main/java/de/adito/ojcms/beans/literals/fields/types/AbstractField.java
+++ b/ojcms-beans/src/main/java/de/adito/ojcms/beans/literals/fields/types/AbstractField.java
@@ -79,9 +79,9 @@ public <TARGET> Optional<Function<VALUE, TARGET>> getFromConverter(Class<TARGET>
   public <ANNOTATION extends Annotation> Optional<ANNOTATION> getAnnotation(Class<ANNOTATION> pType)
   {
     //noinspection unchecked
-    return annotations.stream()
-        .filter(pAnnotation -> pAnnotation.annotationType().equals(pType))
-        .findAny()
+    return annotations.stream() //
+        .filter(pAnnotation -> pAnnotation.annotationType().equals(pType)) //
+        .findAny() //
         .map(pAnnotation -> (ANNOTATION) pAnnotation);
   }
 
@@ -101,7 +101,7 @@ public Collection<Annotation> getAnnotations()
   public <INFO> Optional<INFO> getAdditionalInformation(IAdditionalMemberInfo<INFO> pIdentifier)
   {
     //noinspection unchecked
-    return Optional.ofNullable(additionalInformation.get(pIdentifier))
+    return Optional.ofNullable(additionalInformation.get(pIdentifier)) //
         .map(pInfo -> (INFO) pInfo);
   }
 
@@ -110,6 +110,7 @@ public <INFO> void addAdditionalInformation(IAdditionalMemberInfo<INFO> pIdentif
   {
     if (!pIdentifier.getDataType().isAssignableFrom(pValue.getClass()))
       throw new OJRuntimeException("Bad data type: " + pValue.getClass() + " should be from type " + pIdentifier.getDataType());
+
     additionalInformation.put(pIdentifier, pValue);
   }
 
@@ -149,18 +150,37 @@ public boolean isDetail()
     return hasAnnotation(Detail.class);
   }
 
+  @Override
+  public boolean equals(Object pOther)
+  {
+    if (this == pOther)
+      return true;
+
+    if (!(pOther instanceof AbstractField))
+      return false;
+
+    final AbstractField<?> that = (AbstractField<?>) pOther;
+    return Objects.equals(name, that.name);
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(name);
+  }
+
   @Override
   public String toString()
   {
-    return getClass().getSimpleName() + "{" +
-        "dataType=" + dataType +
-        ", name='" + name + '\'' +
-        ", isPrivate=" + isPrivate +
-        ", isOptional=" + isOptional +
-        ", isFinal=" + isValueFinal() +
-        ", neverNull=" + mustNeverBeNull() +
-        ", annotations=" + annotations +
-        ", additionalInformation=" + additionalInformation +
+    return getClass().getSimpleName() + "{" + //
+        "dataType=" + dataType + //
+        ", name='" + name + '\'' + //
+        ", isPrivate=" + isPrivate + //
+        ", isOptional=" + isOptional + //
+        ", isFinal=" + isValueFinal() + //
+        ", neverNull=" + mustNeverBeNull() + //
+        ", annotations=" + annotations + //
+        ", additionalInformation=" + additionalInformation + //
         '}';
   }
 
@@ -172,7 +192,8 @@ public String toString()
    * @param pFromConverter the converter that converts from the field's data type to the source's data type
    * @param <SOURCE>       the generic source data type
    */
-  protected <SOURCE> void registerConverter(Class<SOURCE> pSourceType, Function<SOURCE, VALUE> pToConverter, Function<VALUE, SOURCE> pFromConverter)
+  protected <SOURCE> void registerConverter(Class<SOURCE> pSourceType, Function<SOURCE, VALUE> pToConverter,
+                                            Function<VALUE, SOURCE> pFromConverter)
   {
     toConverters.put(pSourceType, pToConverter);
     fromConverters.put(pSourceType, pFromConverter);
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/OJPersistenceException.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/OJPersistenceException.java
index da189df..3a4bcbc 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/OJPersistenceException.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/OJPersistenceException.java
@@ -37,6 +37,7 @@ public OJPersistenceException(String pDetailMessage, Throwable pCause)
    */
   public OJPersistenceException(Class<? extends IBean> pNonPersistentBean)
   {
-    super("The bean type '" + pNonPersistentBean.getName() + "' is not a persistent bean type! Should be annotated with @Persist!");
+    super("The bean type '" + pNonPersistentBean
+        .getName() + "' is not a persistent bean type! " + "Should be annotated with @Persist or @PersistAsBaseType!");
   }
 }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/Persist.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/Persist.java
index ed004e6..bd0009c 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/Persist.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/Persist.java
@@ -3,8 +3,7 @@
 import java.lang.annotation.*;
 
 /**
- * Persistence annotation of the persistence framework.
- * A bean annotated by this type will be persisted according to a specific {@link EPersistenceMode}.
+ * A bean annotated by this annotation will be persisted according to a specific {@link EPersistenceMode}.
  * Per default, all beans of the annotated bean type will be stored in a persistent bean container.
  *
  * @author Simon Danner, 10.02.2018
@@ -15,7 +14,7 @@
 public @interface Persist
 {
   /**
-   * The container id of the element, in which the bean/beans are stored.
+   * The id of the container in that the bean/beans are stored.
    *
    * @return the container id
    */
@@ -23,9 +22,9 @@
 
   /**
    * The mode in which the beans should be persisted.
-   * Default: they will be stored in containers.
+   * Default: they will be stored in a container.
    *
-   * @return the persistence mode
+   * @return the persistence mode to use
    */
   EPersistenceMode mode() default EPersistenceMode.CONTAINER;
 }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/PersistAsBaseType.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/PersistAsBaseType.java
new file mode 100644
index 0000000..43f0bfa
--- /dev/null
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/PersistAsBaseType.java
@@ -0,0 +1,32 @@
+package de.adito.ojcms.persistence;
+
+import de.adito.ojcms.beans.IBean;
+
+import java.lang.annotation.*;
+
+/**
+ * A persistent bean container for beans annotated by this annotation will be created as base type container for multiple sub types.
+ * The base bean type itself can also be used if it is not abstract.
+ *
+ * @author Simon Danner, 10.02.2018
+ */
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PersistAsBaseType
+{
+  /**
+   * The container id of the element, in which the bean/beans are stored.
+   *
+   * @return the container id
+   */
+  String containerId();
+
+  /**
+   * All sub types the base type container is for. The base type itself can be included if it is not abstract.
+   * At least two types must be provided. The given types must be assignable from the base bean type.
+   *
+   * @return an array of bean sub types the base container should be for
+   */
+  Class<? extends IBean>[] forSubTypes();
+}
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/AbstractBeanContent.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/AbstractBeanContent.java
index 53ad525..4d970d5 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/AbstractBeanContent.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/AbstractBeanContent.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.persistence.datasource;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.api.ITransaction;
 import org.jetbrains.annotations.Nullable;
@@ -11,9 +12,10 @@
  *
  * @author Simon Danner, 01.01.2020
  */
-abstract class AbstractBeanContent<KEY>
+abstract class AbstractBeanContent<KEY, BEAN extends IBean>
 {
   private final KEY beanKey;
+  private final Class<BEAN> beanType;
   private final Map<IField<?>, Object> content;
   private final ITransaction transaction;
 
@@ -24,13 +26,22 @@ abstract class AbstractBeanContent<KEY>
    * @param pTransaction the transaction this bean data is associated with
    * @param pContent     given initial content mapped by bean fields
    */
-  AbstractBeanContent(KEY pBeanKey, ITransaction pTransaction, Map<IField<?>, Object> pContent)
+  AbstractBeanContent(KEY pBeanKey, Class<BEAN> pBeanType, ITransaction pTransaction, Map<IField<?>, Object> pContent)
   {
     beanKey = Objects.requireNonNull(pBeanKey);
+    beanType = Objects.requireNonNull(pBeanType);
     transaction = Objects.requireNonNull(pTransaction);
     content = new HashMap<>(pContent);
   }
 
+  /**
+   * The bean type the content is for.
+   */
+  Class<BEAN> getBeanType()
+  {
+    return beanType;
+  }
+
   /**
    * Resolves the value for a bean field.
    *
@@ -65,9 +76,9 @@ <VALUE> void setValue(IField<VALUE> pField, @Nullable VALUE pValue)
    * Registers a bean value change at the associated transaction.
    *
    * @param pTransaction  the current transaction
-   * @param pBeanKey      the bean key associated with this content
+   * @param pKey          the bean key associated with this content
    * @param pChangedField the changed bean field
    * @param pValue        the new value
    */
-  abstract <VALUE> void registerValueChangeAtTransaction(ITransaction pTransaction, KEY pBeanKey, IField<VALUE> pChangedField, VALUE pValue);
+  abstract <VALUE> void registerValueChangeAtTransaction(ITransaction pTransaction, KEY pKey, IField<VALUE> pChangedField, VALUE pValue);
 }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanContentForContainer.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanContentForContainer.java
index 926991d..a4373ed 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanContentForContainer.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanContentForContainer.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.persistence.datasource;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.api.*;
 
@@ -8,33 +9,64 @@
 /**
  * Manages the content of a persistent bean within a container for an active {@link ITransaction}.
  *
+ * @param <BEAN> the type of the bean in the container the content is for
  * @author Simon Danner, 01.03.2020
  */
-class BeanContentForContainer extends AbstractBeanContent<CurrentIndexKey>
+class BeanContentForContainer<BEAN extends IBean> extends AbstractBeanContent<CurrentIndexKey, BEAN>
 {
   /**
    * Initializes the bean content by requesting the initial content by the given key.
+   * The bean type this content is for will be requested from the transaction as well.
    *
+   * @param pKey         the key to identify the bean content in the container by index
    * @param pTransaction the transaction this bean data is associated with
    */
   BeanContentForContainer(CurrentIndexKey pKey, ITransaction pTransaction)
   {
-    super(pKey, pTransaction, pTransaction.requestBeanDataByIndex(pKey).getData());
+    super(pKey, pTransaction.requestBeanTypeWithinContainer(pKey), pTransaction, pTransaction.requestBeanDataByIndex(pKey).getData());
+  }
+
+  /**
+   * Initializes the bean content by requesting the initial content by the given key.
+   *
+   * @param pKey         the key to identify the bean content in the container by index
+   * @param pBeanType    the type of the bean the content is for
+   * @param pTransaction the transaction this bean data is associated with
+   */
+  BeanContentForContainer(CurrentIndexKey pKey, Class<BEAN> pBeanType, ITransaction pTransaction)
+  {
+    super(pKey, pBeanType, pTransaction, pTransaction.requestBeanDataByIndex(pKey).getData());
   }
 
   /**
    * Initializes the bean content with given bean data.
+   * The bean type this content is for will be requested from the transaction.
    *
+   * @param pKey         the key to identify the bean content in the container by index
    * @param pTransaction the transaction this bean data is associated with
    * @param pContent     given initial content mapped by bean fields
    */
   BeanContentForContainer(CurrentIndexKey pKey, ITransaction pTransaction, Map<IField<?>, Object> pContent)
   {
-    super(pKey, pTransaction, pContent);
+    super(pKey, pTransaction.requestBeanTypeWithinContainer(pKey), pTransaction, pContent);
+  }
+
+  /**
+   * Initializes the bean content with given bean data.
+   *
+   * @param pKey         the key to identify the bean content in the container by index
+   * @param pBeanType    the type of the bean the content is for
+   * @param pTransaction the transaction this bean data is associated with
+   * @param pContent     given initial content mapped by bean fields
+   */
+  BeanContentForContainer(CurrentIndexKey pKey, Class<BEAN> pBeanType, ITransaction pTransaction, Map<IField<?>, Object> pContent)
+  {
+    super(pKey, pBeanType, pTransaction, pContent);
   }
 
   @Override
-  <VALUE> void registerValueChangeAtTransaction(ITransaction pTransaction, CurrentIndexKey pKey, IField<VALUE> pChangedField, VALUE pNewValue)
+  <VALUE> void registerValueChangeAtTransaction(ITransaction pTransaction, CurrentIndexKey pKey, IField<VALUE> pChangedField,
+                                                VALUE pNewValue)
   {
     pTransaction.registerContainerBeanValueChange(pKey, pChangedField, pNewValue);
   }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanPersistenceUtil.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanPersistenceUtil.java
index 3dfa5fb..cdf3cae 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanPersistenceUtil.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanPersistenceUtil.java
@@ -6,6 +6,8 @@
 
 import java.lang.reflect.*;
 
+import static de.adito.ojcms.persistence.datasource.BeanProducerExtension.BASE_CONTAINER_TYPES;
+
 /**
  * Utility class to create {@link IBean} instances with persistent data sources.
  *
@@ -19,8 +21,8 @@ private BeanPersistenceUtil()
 
   /**
    * Instantiates a new bean for a given bean type and configures a persistent {@link IBeanDataSource} for it.
-   * The bean type has to annotated with {@link Persist}, otherwise a runtime exception will be thrown.
-   * Also the bean type has to define a default constructor.
+   * The bean type has to annotated with {@link Persist} or be a sub type of bean annotated by {@link PersistAsBaseType}, otherwise a
+   * runtime exception will be thrown. The bean type has to define a default constructor.
    *
    * @param pBeanType   the bean type to instantiate
    * @param pDataSource the persistent data source to use for the bean instance
@@ -32,7 +34,7 @@ static <BEAN extends IBean> BEAN newPersistentBeanInstance(Class<BEAN> pBeanType
   {
     try
     {
-      if (!pBeanType.isAnnotationPresent(Persist.class))
+      if (!pBeanType.isAnnotationPresent(Persist.class) && !_isSubTypeOfBaseContainer(pBeanType))
         throw new OJPersistenceException(pBeanType);
 
       final Constructor<BEAN> defaultConstructor = pBeanType.getDeclaredConstructor();
@@ -45,8 +47,21 @@ static <BEAN extends IBean> BEAN newPersistentBeanInstance(Class<BEAN> pBeanType
     }
     catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException pE)
     {
-      throw new OJPersistenceException("The persistent bean type '" + pBeanType.getName() + "' must define a default constructor" +
-                                           " (can be private)!", pE);
+      throw new OJPersistenceException(
+          "The persistent bean type '" + pBeanType.getName() + "' must define a default constructor" + " (can be private)!", pE);
     }
   }
+
+  /**
+   * Determines if some bean type is a sub type of a registered base bean type for a base container.
+   *
+   * @param pPotentialSubType the sub type to check
+   * @return <tt>true</tt> if the bean type is a registered sub type of a base container
+   */
+  private static boolean _isSubTypeOfBaseContainer(Class<? extends IBean> pPotentialSubType)
+  {
+    return BASE_CONTAINER_TYPES.entrySet().stream() //
+        .filter(pEntry -> pEntry.getKey().isAssignableFrom(pPotentialSubType)) //
+        .anyMatch(pEntry -> pEntry.getValue().getSubTypes().contains(pPotentialSubType));
+  }
 }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanProducerExtension.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanProducerExtension.java
index 65be37c..dc541c4 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanProducerExtension.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/BeanProducerExtension.java
@@ -6,12 +6,15 @@
 import de.adito.ojcms.persistence.*;
 import de.adito.ojcms.transactions.annotations.TransactionalScoped;
 import de.adito.ojcms.transactions.api.*;
+import de.adito.ojcms.utils.StringUtility;
 import org.jboss.weld.util.reflection.ParameterizedTypeImpl;
+import org.jetbrains.annotations.Nullable;
 
 import javax.enterprise.context.Dependent;
 import javax.enterprise.event.Observes;
 import javax.enterprise.inject.Instance;
 import javax.enterprise.inject.spi.*;
+import java.lang.reflect.Modifier;
 import java.util.*;
 
 /**
@@ -23,31 +26,26 @@
 class BeanProducerExtension implements Extension
 {
   static final Map<Class<? extends IBean>, String> CONTAINER_BEAN_TYPES = new HashMap<>();
+  static final Map<Class<? extends IBean>, BaseContainerRegistration> BASE_CONTAINER_TYPES = new HashMap<>();
   static final Map<Class<? extends IBean>, String> SINGLE_BEAN_TYPES = new HashMap<>();
 
   /**
    * Scans every {@link AnnotatedType} for persistent bean types.
-   * If the bean type has a {@link Persist} annotation, the type will be registered to create producers later on.
+   * If the bean type has a {@link Persist} or {@link PersistAsBaseType} annotation, the types will be registered to create producers
+   * later on.
    *
    * @param pProcessedBean a processed bean type
    */
   void findPersistentBeans(@Observes ProcessAnnotatedType<? extends IBean> pProcessedBean)
   {
-    final Persist persistenceAnnotation = pProcessedBean.getAnnotatedType().getAnnotation(Persist.class);
-
-    if (persistenceAnnotation == null)
-      return;
-
+    final AnnotatedType<? extends IBean> type = pProcessedBean.getAnnotatedType();
     //noinspection unchecked
-    final Class<? extends IBean> beanType = (Class<? extends IBean>) pProcessedBean.getAnnotatedType().getBaseType();
+    final Class<? extends IBean> beanType = (Class<? extends IBean>) type.getBaseType();
 
-    if (persistenceAnnotation.mode() == EPersistenceMode.CONTAINER)
-      CONTAINER_BEAN_TYPES.put(beanType, persistenceAnnotation.containerId());
-    else
-    {
-      SINGLE_BEAN_TYPES.put(beanType, persistenceAnnotation.containerId());
-      pProcessedBean.veto();
-    }
+    if (type.isAnnotationPresent(Persist.class))
+      _registerPersistentBeanType(type.getAnnotation(Persist.class), beanType, pProcessedBean);
+    else if (type.isAnnotationPresent(PersistAsBaseType.class))
+      _registerPersistentBaseContainer(type.getAnnotation(PersistAsBaseType.class), beanType);
   }
 
   /**
@@ -58,9 +56,66 @@ void findPersistentBeans(@Observes ProcessAnnotatedType<? extends IBean> pProces
   void afterBeanDiscovery(@Observes AfterBeanDiscovery pAfterBeanDiscovery)
   {
     CONTAINER_BEAN_TYPES.forEach((pBeanType, pContainerId) -> _addContainerCdiBeans(pAfterBeanDiscovery, pBeanType, pContainerId));
+    BASE_CONTAINER_TYPES.forEach((pBaseType, pRegistration) -> _addBaseContainerCdiBeans(pAfterBeanDiscovery, pBaseType, pRegistration));
     SINGLE_BEAN_TYPES.forEach((pBeanType, pBeanId) -> _addSingleBeanCdiBeans(pAfterBeanDiscovery, pBeanType, pBeanId));
   }
 
+  /**
+   * Registers a persistent bean annotated by {@link Persist}.
+   * If the bean should be persisted in {@link EPersistenceMode#SINGLE} the processed bean will be vetoed.
+   * The producer should be used instead.
+   *
+   * @param pAnnotation    the persistence annotation instance to retrieve configuration from
+   * @param pBeanType      the annotated bean type
+   * @param pProcessedBean the processed CDI bean
+   */
+  private static void _registerPersistentBeanType(Persist pAnnotation, Class<? extends IBean> pBeanType, ProcessAnnotatedType<?
+      extends IBean> pProcessedBean)
+  {
+    if (Modifier.isAbstract(pBeanType.getModifiers()))
+      throw new OJPersistenceException("Abstract bean type " + pBeanType.getName() + " cannot be persisted!");
+
+    if (pAnnotation.mode() == EPersistenceMode.CONTAINER)
+      CONTAINER_BEAN_TYPES.put(pBeanType, pAnnotation.containerId());
+    else
+    {
+      SINGLE_BEAN_TYPES.put(pBeanType, pAnnotation.containerId());
+      pProcessedBean.veto();
+    }
+  }
+
+  /**
+   * Registers a persistent base bean type annotated by {@link PersistAsBaseType}.
+   * A base container will be registered for all {@link PersistAsBaseType#forSubTypes()}.
+   * Checks several conditions before registering the bean type.
+   *
+   * @param pAnnotation the persistence annotation instance to retrieve configuration from
+   * @param pBeanType   the annotated base bean type
+   */
+  private static void _registerPersistentBaseContainer(PersistAsBaseType pAnnotation, Class<? extends IBean> pBeanType)
+  {
+    final Set<Class<? extends IBean>> subTypes = new HashSet<>();
+
+    if (pAnnotation.forSubTypes().length < 2)
+      throw new OJPersistenceException("At least two sub types must be given to create a persistent container for " + pBeanType.getName());
+
+    for (Class<? extends IBean> subType : pAnnotation.forSubTypes())
+    {
+      if (Modifier.isAbstract(subType.getModifiers()))
+        throw new OJPersistenceException(
+            "Sub bean type " + subType.getName() + " is abstract! " + "Cannot be used for base container " + pBeanType.getName());
+
+      if (!pBeanType.isAssignableFrom(subType))
+        throw new OJPersistenceException("Sub bean type " + subType.getName() + " is not assignable from " + pBeanType
+            .getName() + "!" + "Cannot be used for base container!");
+
+      subTypes.add(subType);
+    }
+
+    final BaseContainerRegistration registration = new BaseContainerRegistration(pAnnotation.containerId(), subTypes);
+    BASE_CONTAINER_TYPES.put(pBeanType, registration);
+  }
+
   /**
    * Creates producer beans for a persistent bean container.
    * This includes the {@link IBeanContainer} itself and a {@link TransactionalScoped} {@link ContainerContent}
@@ -73,19 +128,25 @@ void afterBeanDiscovery(@Observes AfterBeanDiscovery pAfterBeanDiscovery)
   private static void _addContainerCdiBeans(AfterBeanDiscovery pAfterBeanDiscovery, Class<? extends IBean> pBeanType, String pContainerId)
   {
     final ContainerQualifier literal = ContainerQualifier.Literal.forContainerId(pContainerId);
+    _registerContainerCdiBean(pAfterBeanDiscovery, pBeanType, literal);
+    _registerContainerContentCdiBean(pAfterBeanDiscovery, pContainerId, pBeanType, literal);
+  }
 
-    //noinspection unchecked
-    pAfterBeanDiscovery.addBean()
-        .scope(Dependent.class)
-        .types(IBeanContainer.class, new ParameterizedTypeImpl(IBeanContainer.class, pBeanType))
-        .produceWith(pEnvironment -> _createBeanContainer(pEnvironment, (Class) pBeanType, literal));
-
-    //noinspection unchecked
-    pAfterBeanDiscovery.addBean()
-        .scope(TransactionalScoped.class)
-        .qualifiers(literal)
-        .types(ContainerContent.class)
-        .produceWith(pEnvironment -> _createContainerContent(pEnvironment, pContainerId, (Class) pBeanType));
+  /**
+   * Creates producer beans for a persistent base bean container.
+   * This includes the base {@link IBeanContainer} itself and a {@link TransactionalScoped} {@link ContainerContent}
+   * managing the content per transaction.
+   *
+   * @param pAfterBeanDiscovery allows the addition of custom CDI beans
+   * @param pBeanBaseType       the base type bean of the persistent container
+   * @param pRegistration       information about the registered base bean container
+   */
+  private static void _addBaseContainerCdiBeans(AfterBeanDiscovery pAfterBeanDiscovery, Class<? extends IBean> pBeanBaseType,
+                                                BaseContainerRegistration pRegistration)
+  {
+    final ContainerQualifier literal = ContainerQualifier.Literal.forContainerId(pRegistration.getContainerId());
+    _registerContainerCdiBean(pAfterBeanDiscovery, pBeanBaseType, literal);
+    _registerContainerContentCdiBean(pAfterBeanDiscovery, pRegistration.getContainerId(), null, literal);
   }
 
   /**
@@ -102,16 +163,52 @@ private static void _addSingleBeanCdiBeans(AfterBeanDiscovery pAfterBeanDiscover
     final ContainerQualifier literal = ContainerQualifier.Literal.forContainerId(pBeanId);
 
     //noinspection unchecked
-    pAfterBeanDiscovery.addBean()
-        .scope(Dependent.class)
-        .types(pBeanType)
+    pAfterBeanDiscovery.addBean() //
+        .scope(Dependent.class) //
+        .types(pBeanType) //
         .produceWith(pEnvironment -> _createSingleBean(pEnvironment, (Class) pBeanType, literal));
 
-    pAfterBeanDiscovery.addBean()
-        .scope(TransactionalScoped.class)
-        .qualifiers(literal)
-        .types(SingleBeanContent.class)
-        .produceWith(pEnvironment -> _createSingleBeanContent(pEnvironment, pBeanId));
+    pAfterBeanDiscovery.addBean() //
+        .scope(TransactionalScoped.class) //
+        .qualifiers(literal) //
+        .types(SingleBeanContent.class) //
+        .produceWith(pEnvironment -> _createSingleBeanContent(pEnvironment, pBeanId, pBeanType));
+  }
+
+  /**
+   * Registers the CDI producer for a persistent bean container.
+   *
+   * @param pAfterBeanDiscovery allows the addition of custom CDI beans
+   * @param pBeanType           the type of the beans in the persistent container
+   * @param pLiteral            a CDI literal to identify the container content
+   */
+  private static void _registerContainerCdiBean(AfterBeanDiscovery pAfterBeanDiscovery, Class<? extends IBean> pBeanType,
+                                                ContainerQualifier pLiteral)
+  {
+    //noinspection unchecked
+    pAfterBeanDiscovery.addBean() //
+        .scope(Dependent.class) //
+        .types(IBeanContainer.class, new ParameterizedTypeImpl(IBeanContainer.class, pBeanType)) //
+        .produceWith(pEnvironment -> _createBeanContainer(pEnvironment, (Class) pBeanType, pLiteral));
+  }
+
+  /**
+   * Registers the CDI producer for a {@link ContainerContent}.
+   *
+   * @param pAfterBeanDiscovery allows the addition of custom CDI beans
+   * @param pContainerId        the id of the container
+   * @param pBeanType           the type of the beans in the persistent container
+   * @param pLiteral            a CDI literal to identify the container content
+   */
+  private static void _registerContainerContentCdiBean(AfterBeanDiscovery pAfterBeanDiscovery, String pContainerId, //
+                                                       @Nullable Class<? extends IBean> pBeanType, ContainerQualifier pLiteral)
+  {
+    //noinspection unchecked
+    pAfterBeanDiscovery.addBean() //
+        .scope(TransactionalScoped.class) //
+        .qualifiers(pLiteral) //
+        .types(ContainerContent.class) //
+        .produceWith(pEnvironment -> _createContainerContent(pEnvironment, pContainerId, (Class) pBeanType));
   }
 
   /**
@@ -153,7 +250,8 @@ private static <BEAN extends IBean> ContainerContent<BEAN> _createContainerConte
    * @param pLiteral     a qualifier annotation literal to identify the single persistent bean
    * @return the created single bean instance
    */
-  private static <BEAN extends IBean> BEAN _createSingleBean(Instance<Object> pEnvironment, Class<BEAN> pBeanType, ContainerQualifier pLiteral)
+  private static <BEAN extends IBean> BEAN _createSingleBean(Instance<Object> pEnvironment, Class<BEAN> pBeanType,
+                                                             ContainerQualifier pLiteral)
   {
     final SingleBeanContent content = pEnvironment.select(SingleBeanContent.class, pLiteral).get();
     final PersistentBeanDatasource datasource = new PersistentBeanDatasource(content);
@@ -165,11 +263,51 @@ private static <BEAN extends IBean> BEAN _createSingleBean(Instance<Object> pEnv
    *
    * @param pEnvironment a CDI instance to create managed CDI beans
    * @param pBeanId      the persistence id of the single bean
+   * @param pBeanType    the type of the single bean to create the content for
    * @return the created instance managing the bean's content
    */
-  private static SingleBeanContent _createSingleBeanContent(Instance<Object> pEnvironment, String pBeanId)
+  private static SingleBeanContent<?> _createSingleBeanContent(Instance<Object> pEnvironment, String pBeanId,
+                                                               Class<? extends IBean> pBeanType)
   {
     final ITransaction transaction = pEnvironment.select(ITransaction.class).get();
-    return new SingleBeanContent(new SingleBeanKey(pBeanId), transaction);
+    return new SingleBeanContent<>(new SingleBeanKey(pBeanId), pBeanType, transaction);
+  }
+
+  /**
+   * Defines a base container registration from {@link PersistAsBaseType}.
+   * Holds the container id and a set of sub types the base container should be created for.
+   */
+  static class BaseContainerRegistration
+  {
+    private final String containerId;
+    private final Set<Class<? extends IBean>> subTypes;
+
+    /**
+     * Creates a new base container registration.
+     *
+     * @param pContainerId the id of the persistent base container
+     * @param pSubTypes    all sub types the base container is for
+     */
+    BaseContainerRegistration(String pContainerId, Set<Class<? extends IBean>> pSubTypes)
+    {
+      containerId = StringUtility.requireNotEmpty(pContainerId, "container id");
+      subTypes = new HashSet<>(pSubTypes);
+    }
+
+    /**
+     * The id of the persistent base container
+     */
+    String getContainerId()
+    {
+      return containerId;
+    }
+
+    /**
+     * All sub types the base container is for
+     */
+    Set<Class<? extends IBean>> getSubTypes()
+    {
+      return subTypes;
+    }
   }
 }
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/ContainerContent.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/ContainerContent.java
index d6ccd25..2f8195d 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/ContainerContent.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/ContainerContent.java
@@ -6,6 +6,7 @@
 import de.adito.ojcms.transactions.api.*;
 import de.adito.ojcms.utils.StringUtility;
 import de.adito.ojcms.utils.collections.*;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 import java.util.function.Supplier;
@@ -30,13 +31,13 @@ class ContainerContent<BEAN extends IBean>
    * Initializes the container content.
    *
    * @param pContainerId the id of the persistent container the content belongs to
-   * @param pBeanType    the bean type of the container
+   * @param pBeanType    the bean type of the container if available (might not be if the content is for a base container)
    * @param pTransaction the transaction the content is associated with
    */
-  ContainerContent(String pContainerId, Class<BEAN> pBeanType, ITransaction pTransaction)
+  ContainerContent(String pContainerId, @Nullable Class<BEAN> pBeanType, ITransaction pTransaction)
   {
     containerId = StringUtility.requireNotEmpty(pContainerId, "container id");
-    beanType = Objects.requireNonNull(pBeanType);
+    beanType = pBeanType;
     transaction = Objects.requireNonNull(pTransaction);
   }
 
@@ -90,8 +91,15 @@ BEAN removeBean(int pIndex)
   {
     _checkIndex(pIndex);
 
-    final BEAN removedBean = content.removeAtIndex(pIndex)
-        .orElseGet(() -> newPersistentBeanInstance(beanType, new PersistentBeanDatasource(_beanContentForIndex(pIndex))))
+    final BEAN removedBean = content.removeAtIndex(pIndex) //
+        .orElseGet(() ->
+        {
+          //Request bean data if not present yet
+          final BeanContentForContainer beanContent = _beanContentForIndex(pIndex);
+          //noinspection unchecked
+          final Class<BEAN> beanType = beanContent.getBeanType();
+          return newPersistentBeanInstance(beanType, new PersistentBeanDatasource(beanContent));
+        }) //
         .useDefaultEncapsulatedDataSource();
 
     transaction.registerBeanRemoval(_indexKey(pIndex));
@@ -111,7 +119,7 @@ boolean removeBean(BEAN pBean)
     if (index == -1)
       return false;
 
-    content.removeElement(pBean);
+    content.removeAtIndex(index);
     pBean.useDefaultEncapsulatedDataSource();
     transaction.registerBeanRemoval(_indexKey(index));
     return true;
@@ -125,9 +133,9 @@ boolean removeBean(BEAN pBean)
    */
   void addBean(BEAN pBean, int pIndex)
   {
-    pBean.setEncapsulatedDataSource(new PersistentBeanDatasource(_beanContentForIndexAndContent(pIndex, pBean.toMap())));
+    pBean.setEncapsulatedDataSource(new PersistentBeanDatasource(_beanContentForIndexAndContent(pIndex, pBean.getClass(), pBean.toMap())));
     content.addAtIndex(pBean, pIndex);
-    transaction.registerBeanAddition(_indexKey(pIndex), pBean.toMap());
+    transaction.registerBeanAddition(new BeanAddition(pIndex, pBean.toMap(), pBean.getClass(), containerId));
   }
 
   /**
@@ -139,10 +147,12 @@ void requiresFullLoad()
     if (_isFullyLoaded())
       return;
 
-    transaction.requestFullContainerLoad(containerId).entrySet().stream()
-        .filter(pEntry -> !content.containsIndex(pEntry.getKey()))
-        .forEach(pEntry -> _getOrCreateBean(pEntry.getKey(), () ->
-            _beanContentForIndexAndContent(pEntry.getKey(), pEntry.getValue().getData())));
+    transaction.requestFullContainerLoad(containerId) //
+        .entrySet().stream() //
+        .filter(pEntry -> !content.containsIndex(pEntry.getKey())) //
+        .forEach(pEntry -> _getOrCreateBean(pEntry.getKey(), () -> beanType == null ? //
+            _beanContentForIndexAndContent(pEntry.getKey(), pEntry.getValue().getData()) : //
+            _beanContentForIndexAndContent(pEntry.getKey(), beanType, pEntry.getValue().getData())));
   }
 
   /**
@@ -153,8 +163,8 @@ void requiresFullLoad()
    */
   private OptionalInt _loadIndexOfBean(BEAN pBean)
   {
-    final Map<IField<?>, Object> identifiers = pBean.getIdentifiers().stream()
-        .collect(Collectors.toMap(FieldValueTuple::getField, FieldValueTuple::getValue));
+    final Map<IField<?>, Object> identifiers = pBean.getIdentifiers().stream().collect(
+        Collectors.toMap(FieldValueTuple::getField, FieldValueTuple::getValue));
 
     final Optional<PersistentBeanData> beanData = transaction.requestBeanDataByIdentifierTuples(containerId, identifiers);
 
@@ -163,7 +173,7 @@ private OptionalInt _loadIndexOfBean(BEAN pBean)
 
     final int index = beanData.get().getIndex();
     //Add bean to the content map if we requested the data anyway
-    _getOrCreateBean(index, () -> _beanContentForIndexAndContent(index, beanData.get().getData()));
+    _getOrCreateBean(index, () -> _beanContentForIndexAndContent(index, pBean.getClass(), beanData.get().getData()));
 
     return OptionalInt.of(index);
   }
@@ -178,7 +188,12 @@ private OptionalInt _loadIndexOfBean(BEAN pBean)
   private BEAN _getOrCreateBean(int pIndex, Supplier<AbstractBeanContent> pBeanContentCreator)
   {
     return content.computeIfAbsent(pIndex, index ->
-        newPersistentBeanInstance(beanType, new PersistentBeanDatasource(pBeanContentCreator.get())));
+    {
+      final AbstractBeanContent beanContent = pBeanContentCreator.get();
+      //noinspection unchecked
+      final Class<BEAN> beanType = beanContent.getBeanType();
+      return newPersistentBeanInstance(beanType, new PersistentBeanDatasource(pBeanContentCreator.get()));
+    });
   }
 
   /**
@@ -214,11 +229,15 @@ private boolean _isFullyLoaded()
    */
   private BeanContentForContainer _beanContentForIndex(int pIndex)
   {
-    return new BeanContentForContainer(_indexKey(pIndex), transaction);
+    final CurrentIndexKey indexKey = _indexKey(pIndex);
+    return Optional.ofNullable(beanType) //
+        .map(pBeanType -> new BeanContentForContainer<>(indexKey, pBeanType, transaction)) //
+        .orElseGet(() -> new BeanContentForContainer<>(indexKey, transaction));
   }
 
   /**
    * Creates an instance of {@link BeanContentForContainer} that is based on a {@link CurrentIndexKey} with a given content.
+   * This variant will request the bean type the content is for from the {@link ITransaction}
    *
    * @param pIndex   the index the bean to create the instance for is located within the bean container
    * @param pContent the preset content for the instance to create
@@ -226,7 +245,21 @@ private BeanContentForContainer _beanContentForIndex(int pIndex)
    */
   private BeanContentForContainer _beanContentForIndexAndContent(int pIndex, Map<IField<?>, Object> pContent)
   {
-    return new BeanContentForContainer(_indexKey(pIndex), transaction, pContent);
+    return new BeanContentForContainer<>(_indexKey(pIndex), transaction, pContent);
+  }
+
+  /**
+   * Creates an instance of {@link BeanContentForContainer} that is based on a {@link CurrentIndexKey} with a given content.
+   *
+   * @param pIndex    the index the bean to create the instance for is located within the bean container
+   * @param pBeanType the type of the bean the content is for
+   * @param pContent  the preset content for the instance to create
+   * @return the created bean content by index
+   */
+  private BeanContentForContainer _beanContentForIndexAndContent(int pIndex, Class<? extends IBean> pBeanType,
+                                                                 Map<IField<?>, Object> pContent)
+  {
+    return new BeanContentForContainer<>(_indexKey(pIndex), pBeanType, transaction, pContent);
   }
 
   /**
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/SingleBeanContent.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/SingleBeanContent.java
index c062b5f..a6f4f59 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/SingleBeanContent.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/SingleBeanContent.java
@@ -1,14 +1,16 @@
 package de.adito.ojcms.persistence.datasource;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.api.*;
 
 /**
  * Manages the content of a persistent single bean for an active {@link ITransaction}.
  *
+ * @param <BEAN> the type of the single bean the content is for
  * @author Simon Danner, 01.03.2020
  */
-class SingleBeanContent extends AbstractBeanContent<SingleBeanKey>
+class SingleBeanContent<BEAN extends IBean> extends AbstractBeanContent<SingleBeanKey, BEAN>
 {
   /**
    * Initializes the bean content with given bean data.
@@ -16,9 +18,9 @@ class SingleBeanContent extends AbstractBeanContent<SingleBeanKey>
    * @param pBeanKey     the bean key that identifies these data
    * @param pTransaction the transaction this bean data is associated with
    */
-  SingleBeanContent(SingleBeanKey pBeanKey, ITransaction pTransaction)
+  SingleBeanContent(SingleBeanKey pBeanKey, Class<BEAN> pBeanType, ITransaction pTransaction)
   {
-    super(pBeanKey, pTransaction, pTransaction.requestSingleBeanData(pBeanKey).getData());
+    super(pBeanKey, pBeanType, pTransaction, pTransaction.requestSingleBeanData(pBeanKey).getData());
   }
 
   @Override
diff --git a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/StartupBeanRegistration.java b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/StartupBeanRegistration.java
index 360298c..7cd5c68 100644
--- a/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/StartupBeanRegistration.java
+++ b/ojcms-persistence/src/main/java/de/adito/ojcms/persistence/datasource/StartupBeanRegistration.java
@@ -23,6 +23,8 @@ class StartupBeanRegistration implements IStartupCallback
   public void onCdiStartup()
   {
     CONTAINER_BEAN_TYPES.forEach((pBeanType, pContainerId) -> storage.registerPersistentContainerBean(pBeanType, pContainerId));
+    BASE_CONTAINER_TYPES.forEach((pBaseType, pRegistration) -> storage
+        .registerPersistentBaseTypeContainer(pRegistration.getContainerId(), pRegistration.getSubTypes()));
     SINGLE_BEAN_TYPES.forEach((pBeanType, pBeanId) -> storage.registerPersistentSingleBean(pBeanType, pBeanId));
   }
 
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanLoaderForTest.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanLoaderForTest.java
index 9e2d9a2..b79a6b3 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanLoaderForTest.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanLoaderForTest.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.persistence;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.api.*;
 import de.adito.ojcms.transactions.exceptions.BeanDataNotFoundException;
@@ -24,6 +25,8 @@ class BeanLoaderForTest implements IBeanDataLoader
 {
   @Inject
   private BeanTestData data;
+  @Inject
+  private RegisteredBeansForTest registeredBeans;
 
   @Override
   public int loadContainerSize(String pContainerId)
@@ -34,14 +37,26 @@ public int loadContainerSize(String pContainerId)
   @Override
   public PersistentBeanData loadContainerBeanDataByIndex(InitialIndexKey pKey)
   {
-    return _findInContainer(pKey.getContainerId(), pData -> pData.getIndex() == pKey.getIndex())
+    return _findByIndex(pKey).orElseThrow(() -> new BeanDataNotFoundException(pKey));
+  }
+
+  @Override
+  public <BEAN extends IBean> Class<BEAN> loadBeanTypeWithinContainer(InitialIndexKey pKey)
+  {
+    if (!registeredBeans.getBaseContainerIds().contains(pKey.getContainerId()))
+      throw new IllegalArgumentException("The container with id " + pKey.getContainerId() + " is not a base container!");
+
+    //noinspection unchecked
+    return (Class<BEAN>) _findByIndex(pKey) //
+        .map(BeanAddition::getBeanType) //
         .orElseThrow(() -> new BeanDataNotFoundException(pKey));
   }
 
   @Override
   public Optional<PersistentBeanData> loadContainerBeanDataByIdentifiers(String pContainerId, Map<IField<?>, Object> pIdentifiers)
   {
-    return _findInContainer(pContainerId, pData -> pData.getData().entrySet().containsAll(pIdentifiers.entrySet()));
+    return _findInContainer(pContainerId, pData -> pData.getData().entrySet().containsAll(pIdentifiers.entrySet())) //
+        .map(pData -> pData);
   }
 
   @Override
@@ -53,10 +68,21 @@ public PersistentBeanData loadSingleBeanData(SingleBeanKey pKey)
   @Override
   public Map<Integer, PersistentBeanData> fullContainerLoad(String pContainerId)
   {
-    return data.getContentForContainer(pContainerId).stream()
+    return data.getContentForContainer(pContainerId).stream() //
         .collect(Collectors.toMap(PersistentBeanData::getIndex, identity()));
   }
 
+  /**
+   * Tries to resolve some {@link PersistentBeanData} from a specific container by index.
+   *
+   * @param pIndexKey the index based key to identify the bean data
+   * @return the optionally resolved persistent data applying to the predicate
+   */
+  private Optional<BeanAddition> _findByIndex(InitialIndexKey pIndexKey)
+  {
+    return _findInContainer(pIndexKey.getContainerId(), pData -> pData.getIndex() == pIndexKey.getIndex());
+  }
+
   /**
    * Tries to resolve some {@link PersistentBeanData} in a specific container based on a given predicate.
    *
@@ -64,10 +90,10 @@ public Map<Integer, PersistentBeanData> fullContainerLoad(String pContainerId)
    * @param pPredicate   the predicate to find the requested persistent bean data
    * @return the optionally resolved persistent data applying to the predicate
    */
-  private Optional<PersistentBeanData> _findInContainer(String pContainerId, Predicate<PersistentBeanData> pPredicate)
+  private Optional<BeanAddition> _findInContainer(String pContainerId, Predicate<BeanAddition> pPredicate)
   {
-    return data.getContentForContainer(pContainerId).stream()
-        .filter(pPredicate)
+    return data.getContentForContainer(pContainerId).stream() //
+        .filter(pPredicate) //
         .findAny();
   }
 }
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanStorageForTest.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanStorageForTest.java
index e9a08cb..6010e30 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanStorageForTest.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanStorageForTest.java
@@ -19,7 +19,7 @@
 class BeanStorageForTest implements IBeanDataStorage
 {
   @Inject
-  private RegisteredBeans registeredBeans;
+  private RegisteredBeansForTest registeredBeans;
   @Inject
   private BeanTestData data;
 
@@ -29,6 +29,12 @@ public void registerPersistentContainerBean(Class<? extends IBean> pBeanType, St
     registeredBeans.registerContainerType(pContainerId);
   }
 
+  @Override
+  public void registerPersistentBaseTypeContainer(String pContainerId, Set<Class<? extends IBean>> pSubTypes)
+  {
+    registeredBeans.registerBaseContainerType(pContainerId);
+  }
+
   @Override
   public void registerPersistentSingleBean(Class<? extends IBean> pBeanType, String pBeanId)
   {
@@ -48,9 +54,9 @@ public void processChangesForSingleBean(SingleBeanKey pKey, Map<IField<?>, Objec
   }
 
   @Override
-  public void processAdditionsForContainer(String pContainerId, Set<PersistentBeanData> pNewData)
+  public void processAdditionsForContainer(String pContainerId, Set<BeanAddition> pBeanAdditions)
   {
-    data.addToContainer(pContainerId, pNewData);
+    data.addToContainer(pContainerId, pBeanAdditions);
   }
 
   @Override
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanTestData.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanTestData.java
index d7ca53f..1bbdbb2 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanTestData.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/BeanTestData.java
@@ -20,13 +20,13 @@
 @TestMethodScoped
 class BeanTestData
 {
-  private final Map<String, List<PersistentBeanData>> containers;
+  private final Map<String, List<BeanAddition>> containers;
   private final Map<String, PersistentBeanData> singleBeans;
 
   @Inject
-  BeanTestData(RegisteredBeans registeredBeans)
+  BeanTestData(RegisteredBeansForTest registeredBeans)
   {
-    containers = registeredBeans.getContainerIds().stream()
+    containers = registeredBeans.getContainerIds().stream() //
         .collect(Collectors.toMap(Function.identity(), pId -> new ArrayList<>()));
     singleBeans = registeredBeans.getSingleBeanInitialStates();
   }
@@ -37,7 +37,7 @@ class BeanTestData
    * @param pContainerId the id of the persistent container
    * @return a list of {@link PersistentBeanData}
    */
-  List<PersistentBeanData> getContentForContainer(String pContainerId)
+  List<BeanAddition> getContentForContainer(String pContainerId)
   {
     if (!containers.containsKey(pContainerId))
       throw new IllegalArgumentException("Persistent container with id " + pContainerId + " does not exist!");
@@ -60,17 +60,17 @@ PersistentBeanData getContentForSingleBean(String pBeanId)
   }
 
   /**
-   * Adds new {@link PersistentBeanData} to a persistent bean container.
+   * Adds new {@link BeanAddition} to a persistent bean container.
    *
-   * @param pContainerId the id of the persistent container
-   * @param pNewBeanData a set of the new bean data to add to the container
+   * @param pContainerId   the id of the persistent container
+   * @param pBeanAdditions data describing the additions to the container
    */
-  void addToContainer(String pContainerId, Set<PersistentBeanData> pNewBeanData)
+  void addToContainer(String pContainerId, Set<BeanAddition> pBeanAdditions)
   {
     if (!containers.containsKey(pContainerId))
       throw new IllegalArgumentException("Persistent container with id " + pContainerId + " does not exist!");
 
-    containers.get(pContainerId).addAll(pNewBeanData);
+    containers.get(pContainerId).addAll(pBeanAdditions);
   }
 
   /**
@@ -81,11 +81,11 @@ void addToContainer(String pContainerId, Set<PersistentBeanData> pNewBeanData)
   void removeFromContainer(Map<String, Set<InitialIndexKey>> pKeysToRemoveByContainer)
   {
     pKeysToRemoveByContainer.forEach((pContainerId, pKeysToRemove) ->
-                                     {
-                                       final List<PersistentBeanData> content = getContentForContainer(pContainerId);
-                                       final Set<Integer> indexes = pKeysToRemove.stream().map(InitialIndexKey::getIndex).collect(toSet());
-                                       content.removeIf(pData -> indexes.contains(pData.getIndex()));
-                                     });
+    {
+      final List<BeanAddition> content = getContentForContainer(pContainerId);
+      final Set<Integer> indexes = pKeysToRemove.stream().map(InitialIndexKey::getIndex).collect(toSet());
+      content.removeIf(pData -> indexes.contains(pData.getIndex()));
+    });
   }
 
   /**
@@ -97,9 +97,9 @@ void removeFromContainer(Map<String, Set<InitialIndexKey>> pKeysToRemoveByContai
   void processChangeForContainerBean(InitialIndexKey pKey, Map<IField<?>, Object> pChangedData)
   {
     final int index = pKey.getIndex();
-    final List<PersistentBeanData> containerContent = getContentForContainer(pKey.getContainerId());
+    final List<BeanAddition> containerContent = getContentForContainer(pKey.getContainerId());
     final PersistentBeanData newData = containerContent.get(index).integrateChanges(pChangedData);
-    containerContent.set(index, newData);
+    containerContent.set(index, (BeanAddition) newData);
   }
 
   /**
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentBaseContainerTest.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentBaseContainerTest.java
new file mode 100644
index 0000000..1f4c3af
--- /dev/null
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentBaseContainerTest.java
@@ -0,0 +1,136 @@
+package de.adito.ojcms.persistence;
+
+import de.adito.ojcms.beans.*;
+import de.adito.ojcms.beans.annotations.Identifier;
+import de.adito.ojcms.beans.literals.fields.types.*;
+import de.adito.ojcms.cdi.AbstractCdiTest;
+import de.adito.ojcms.transactions.annotations.*;
+import org.junit.jupiter.api.Test;
+
+import javax.inject.Inject;
+import java.time.Instant;
+import java.util.function.Consumer;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for an injectable persistent {@link IBeanContainer} for a base bean type.
+ * The content is based on {@link BeanLoaderForTest} and {@link BeanStorageForTest}.
+ *
+ * @author Simon Danner, 20.03.2020
+ */
+public class PersistentBaseContainerTest extends AbstractCdiTest
+{
+  @SuppressWarnings("CdiInjectionPointsInspection")
+  @Inject
+  private IBeanContainer<SomeBaseBean> baseContainer;
+
+  @Test
+  public void testAddBean()
+  {
+    baseContainer.addBean(new SomeConcreteBean(1, 1L, true, "1"));
+    baseContainer.addBean(new SomeConcreteBean(2, 2L, false, "2"));
+    baseContainer.addBean(new SomeOtherConcreteBean(3, 3L, true, "3"));
+    baseContainer.addBean(new SomeOtherConcreteBean(4, 4L, false, "4"));
+
+    assertEquals(4, baseContainer.size());
+    assertSame(SomeConcreteBean.class, baseContainer.getBean(0).getClass());
+    assertSame(SomeOtherConcreteBean.class, baseContainer.getBean(2).getClass());
+  }
+
+  @Test
+  public void testBaseContainerWithPresetContent()
+  {
+    final TransactionalContainers transactionalContainers = cdiControl.createInjected(TransactionalContainers.class);
+
+    //Add some beans in first transaction
+    transactionalContainers.doInNewTransaction(pContainer ->
+    {
+      pContainer.addBean(new SomeConcreteBean(1, 1L, true, "1"));
+      pContainer.addBean(new SomeConcreteBean(2, 2L, false, "2"));
+      pContainer.addBean(new SomeOtherConcreteBean(3, 3L, true, "3"));
+    });
+
+    //Modify container in second transaction
+    transactionalContainers.doInNewTransaction(pContainer ->
+    {
+      //Remove one bean
+      final SomeBaseBean removedBean = pContainer.removeBean(1);
+      assertEquals(2, removedBean.getValue(SomeBaseBean.FIELD1));
+      assertEquals(1, pContainer.getBean(0).getValue(SomeBaseBean.FIELD1));
+      assertEquals(3, pContainer.getBean(1).getValue(SomeBaseBean.FIELD1));
+    });
+  }
+
+  @PersistAsBaseType(containerId = "SOME_CONTAINER", forSubTypes = {SomeConcreteBean.class, SomeOtherConcreteBean.class})
+  public static abstract class SomeBaseBean extends OJBean
+  {
+    @Identifier
+    public static IntegerField FIELD1 = OJFields.create(SomeBaseBean.class);
+    @Identifier
+    public static LongField FIELD2 = OJFields.create(SomeBaseBean.class);
+    public static BooleanField FIELD3 = OJFields.create(SomeBaseBean.class);
+
+    SomeBaseBean(int pValue1, long pValue2, boolean pValue3)
+    {
+      setValue(FIELD1, pValue1);
+      setValue(FIELD2, pValue2);
+      setValue(FIELD3, pValue3);
+    }
+
+    private SomeBaseBean()
+    {
+    }
+  }
+
+  public static class SomeConcreteBean extends SomeBaseBean
+  {
+    public static TextField FIELD4 = OJFields.create(SomeConcreteBean.class);
+
+    SomeConcreteBean(int pValue1, long pValue2, boolean pValue3, String pValue4)
+    {
+      super(pValue1, pValue2, pValue3);
+      setValue(FIELD4, pValue4);
+    }
+
+    @SuppressWarnings("unused")
+    private SomeConcreteBean()
+    {
+    }
+  }
+
+  public static class SomeOtherConcreteBean extends SomeBaseBean
+  {
+    public static TextField FIELD5 = OJFields.create(SomeOtherConcreteBean.class);
+    public static DateField FIELD6 = OJFields.create(SomeOtherConcreteBean.class);
+
+    SomeOtherConcreteBean(int pValue1, long pValue2, boolean pValue3, String pValue5)
+    {
+      super(pValue1, pValue2, pValue3);
+      setValue(FIELD5, pValue5);
+      setValue(FIELD6, Instant.now());
+    }
+
+    @SuppressWarnings("unused")
+    private SomeOtherConcreteBean()
+    {
+    }
+  }
+
+  /**
+   * Allows to perform an action on a {@link IBeanContainer} within a newly started transaction.
+   */
+  @TransactionalScoped
+  public static class TransactionalContainers
+  {
+    @SuppressWarnings("CdiInjectionPointsInspection")
+    @Inject
+    private IBeanContainer<SomeBaseBean> transactionalContainer;
+
+    @Transactional
+    void doInNewTransaction(Consumer<IBeanContainer<SomeBaseBean>> pContainerBasedAction)
+    {
+      pContainerBasedAction.accept(transactionalContainer);
+    }
+  }
+}
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentContainerTest.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentContainerTest.java
index b3435e2..ca53a9e 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentContainerTest.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentContainerTest.java
@@ -80,33 +80,33 @@ public void testContainerWithPresetContent()
 
     //Add some beans in first transaction
     transactionalContainers.doInNewTransaction(pContainer ->
-                                               {
-                                                 pContainer.addBean(new SomeBean(1));
-                                                 pContainer.addBean(new SomeBean(2));
-                                                 pContainer.addBean(new SomeBean(3));
-                                               });
+    {
+      pContainer.addBean(new SomeBean(1));
+      pContainer.addBean(new SomeBean(2));
+      pContainer.addBean(new SomeBean(3));
+    });
 
     //Modify container in second transaction
     transactionalContainers.doInNewTransaction(pContainer ->
-                                               {
-                                                 //Remove one bean
-                                                 final SomeBean removedBean = pContainer.removeBean(1);
-                                                 assertEquals(2, removedBean.getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(1, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(3, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
-                                                 //Add some more bean at front
-                                                 pContainer.addBean(new SomeBean(99), 0);
-                                                 assertEquals(99, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(1, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(3, pContainer.getBean(2).getValue(SomeBean.NUMBER_FIELD));
-                                                 //Add another bean
-                                                 pContainer.addBean(new SomeBean(100), 1);
-                                                 assertEquals(4, pContainer.size());
-                                                 assertEquals(99, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(100, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(1, pContainer.getBean(2).getValue(SomeBean.NUMBER_FIELD));
-                                                 assertEquals(3, pContainer.getBean(3).getValue(SomeBean.NUMBER_FIELD));
-                                               });
+    {
+      //Remove one bean
+      final SomeBean removedBean = pContainer.removeBean(1);
+      assertEquals(2, removedBean.getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(1, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(3, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
+      //Add some more bean at front
+      pContainer.addBean(new SomeBean(99), 0);
+      assertEquals(99, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(1, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(3, pContainer.getBean(2).getValue(SomeBean.NUMBER_FIELD));
+      //Add another bean
+      pContainer.addBean(new SomeBean(100), 1);
+      assertEquals(4, pContainer.size());
+      assertEquals(99, pContainer.getBean(0).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(100, pContainer.getBean(1).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(1, pContainer.getBean(2).getValue(SomeBean.NUMBER_FIELD));
+      assertEquals(3, pContainer.getBean(3).getValue(SomeBean.NUMBER_FIELD));
+    });
   }
 
   @Persist(containerId = "TEST")
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentSingleBeanTest.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentSingleBeanTest.java
index 5c9ac2d..956ff00 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentSingleBeanTest.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/PersistentSingleBeanTest.java
@@ -28,7 +28,7 @@ public class PersistentSingleBeanTest extends AbstractCdiTest
   public void testFieldAdaptionForbidden()
   {
     assertThrows(UnsupportedOperationException.class,
-                 () -> bean.fieldAdder(ShortField.class, "NEW_FIELD", Collections.emptySet()).addAtIndex(0));
+        () -> bean.fieldAdder(ShortField.class, "NEW_FIELD", Collections.emptySet()).addAtIndex(0));
     assertThrows(UnsupportedOperationException.class, () -> bean.removeField(SomeSingleBean.TEXT_FIELD));
   }
 
diff --git a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeans.java b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeansForTest.java
similarity index 68%
rename from ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeans.java
rename to ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeansForTest.java
index 659a3e6..7da93ee 100644
--- a/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeans.java
+++ b/ojcms-persistence/src/test/java/de/adito/ojcms/persistence/RegisteredBeansForTest.java
@@ -14,21 +14,32 @@
  * @author Simon Danner, 29.02.2020
  */
 @ApplicationScoped
-class RegisteredBeans
+class RegisteredBeansForTest
 {
   private final Set<String> containerIds = new HashSet<>();
+  private final Set<String> baseContainerIds = new HashSet<>();
   private final Map<String, PersistentBeanData> singleBeanInitialStates = new HashMap<>();
 
   /**
    * All registered persistent container ids.
    *
-   * @return a list of bean container ids
+   * @return a set of bean container ids
    */
   Set<String> getContainerIds()
   {
     return new HashSet<>(containerIds);
   }
 
+  /**
+   * All registered base persistent container ids.
+   *
+   * @return a set of base bean container ids
+   */
+  Set<String> getBaseContainerIds()
+  {
+    return new HashSet<>(baseContainerIds);
+  }
+
   /**
    * All initial states of registered single beans.
    *
@@ -49,6 +60,17 @@ void registerContainerType(String pContainerId)
     containerIds.add(pContainerId);
   }
 
+  /**
+   * Registers a base persistent container by id.
+   *
+   * @param pContainerId the container's id
+   */
+  void registerBaseContainerType(String pContainerId)
+  {
+    containerIds.add(pContainerId);
+    baseContainerIds.add(pContainerId);
+  }
+
   /**
    * Registers a persistent single bean by id.
    *
@@ -57,8 +79,8 @@ void registerContainerType(String pContainerId)
    */
   void registerSingleBeanType(String pBeanId, Class<? extends IBean> pBeanType)
   {
-    final Map<IField<?>, Object> initialContent = BeanReflector.reflectBeanFields(pBeanType).stream()
-        .collect(HashMap::new, (pMap, pField) -> pMap.put(pField, pField.getInitialValue()), HashMap::putAll);
+    final Map<IField<?>, Object> initialContent = BeanReflector.reflectBeanFields(pBeanType).stream().collect(HashMap::new,
+        (pMap, pField) -> pMap.put(pField, pField.getInitialValue()), HashMap::putAll);
 
     singleBeanInitialStates.put(pBeanId, new PersistentBeanData(-1, initialContent));
   }
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/cleanup/ObsoleteTableCleanup.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/cleanup/ObsoleteTableCleanup.java
index c57ed31..434d718 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/cleanup/ObsoleteTableCleanup.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/cleanup/ObsoleteTableCleanup.java
@@ -6,7 +6,7 @@
 
 import javax.enterprise.context.ApplicationScoped;
 import javax.inject.Inject;
-import java.util.List;
+import java.util.Set;
 
 /**
  * Removes all obsolete bean container tables.
@@ -23,7 +23,7 @@ class ObsoleteTableCleanup implements IDatabaseCleanup
   @Override
   public void cleanup(OJSQLBuilder pBuilder)
   {
-    final List<String> allTables = pBuilder.getAllTableNames();
+    final Set<String> allTables = pBuilder.getAllTableNames();
     allTables.removeAll(models.getAllContainerTableNames());
     //Drop all remaining/obsolete tables
     allTables.forEach(pBuilder::dropTable);
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModel.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModel.java
new file mode 100644
index 0000000..7f13100
--- /dev/null
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModel.java
@@ -0,0 +1,135 @@
+package de.adito.ojcms.sql.datasource.model;
+
+import de.adito.ojcms.beans.IBean;
+import de.adito.ojcms.beans.literals.fields.IField;
+import de.adito.ojcms.beans.util.BeanReflector;
+import de.adito.ojcms.sql.datasource.model.column.*;
+import de.adito.ojcms.sql.datasource.util.OJSQLException;
+import de.adito.ojcms.sqlbuilder.OJSQLBuilder;
+import de.adito.ojcms.sqlbuilder.definition.*;
+import de.adito.ojcms.sqlbuilder.definition.column.*;
+import de.adito.ojcms.sqlbuilder.result.ResultRow;
+import de.adito.ojcms.transactions.api.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static de.adito.ojcms.sql.datasource.util.DatabaseConstants.BEAN_TYPE_COLUMN_NAME;
+import static java.util.Collections.singleton;
+import static java.util.function.Function.identity;
+
+/**
+ * The persistence model for a database table for a persistent base bean container.
+ * Provides meta information to initialize the database table.
+ * Also handles the requesting of bean data and processing of changes.
+ * Defines special handling for different bean sub types.
+ *
+ * @author Simon Danner, 18.03.2020
+ */
+public class BaseContainerPersistenceModel extends ContainerPersistenceModel
+{
+  private static final IColumnDefinition BEAN_TYPE_COLUMN = IColumnDefinition.of(BEAN_TYPE_COLUMN_NAME, EColumnType.STRING.create());
+  private static final IColumnIdentification<String> BEAN_TYPE_COLUMN_ID = IColumnIdentification.of(BEAN_TYPE_COLUMN_NAME, String.class);
+
+  private final Map<Class<? extends IBean>, Set<BeanColumnIdentification<?>>> columnsBySubType;
+
+  /**
+   * Initializes the persistence model for a persistent base bean container.
+   *
+   * @param pContainerId the id of the persistent container
+   * @param pSubTypes    all supported sub bean types of the container
+   */
+  BaseContainerPersistenceModel(String pContainerId, Set<Class<? extends IBean>> pSubTypes)
+  {
+    super(pContainerId, _resolveAllColumns(pSubTypes), BEAN_TYPE_COLUMN_ID);
+    columnsBySubType = pSubTypes.stream() //
+        .collect(Collectors.toMap(identity(), BaseContainerPersistenceModel::columnIdentificationsFromBeanType));
+  }
+
+  /**
+   * Loads a concrete bean type of a database entry by index.
+   *
+   * @param pKey     the index based key to identify the bean
+   * @param pBuilder a builder to execute SQL statements
+   * @return the type of the bean at the requested index
+   */
+  public <BEAN extends IBean> Class<BEAN> loadBeanType(InitialIndexKey pKey, OJSQLBuilder pBuilder)
+  {
+    //noinspection unchecked
+    return (Class<BEAN>) selectSingleResultByIndex(pKey, singleton(BEAN_TYPE_COLUMN_ID), pBuilder,
+        BaseContainerPersistenceModel::_resolveBeanType);
+  }
+
+  @Override
+  protected List<IColumnDefinition> getColumnsToCreateInitially()
+  {
+    final List<IColumnDefinition> columnsToCreate = super.getColumnsToCreateInitially();
+    columnsToCreate.add(BEAN_TYPE_COLUMN);
+    return columnsToCreate;
+  }
+
+  @Override
+  protected List<IColumnValueTuple<?>> tuplesToInsertForNewBean(BeanAddition pBeanAddition)
+  {
+    final List<IColumnValueTuple<?>> tuplesToInsert = super.tuplesToInsertForNewBean(pBeanAddition);
+    tuplesToInsert.add(IColumnValueTuple.of(BEAN_TYPE_COLUMN_ID, pBeanAddition.getBeanType().getName()));
+    return tuplesToInsert;
+  }
+
+  @Override
+  protected Map<IField<?>, Object> resultRowToBeanContent(ResultRow pResultRow)
+  {
+    final Class<? extends IBean> beanType = _resolveBeanType(pResultRow);
+    if (!columnsBySubType.containsKey(beanType))
+      throw new IllegalStateException("Bean type " + beanType.getName() + " not registered for persistence model!");
+
+    return pResultRow.toMap(columnsBySubType.get(beanType), BeanColumnIdentification::getBeanField);
+  }
+
+  /**
+   * Resolves the bean type from a {@link ResultRow} from the bean type column.
+   *
+   * @param pResultRow the result row to obtain the bean type from
+   * @return the resolved bean type
+   */
+  private static Class<? extends IBean> _resolveBeanType(ResultRow pResultRow)
+  {
+    try
+    {
+      //noinspection unchecked
+      return (Class<? extends IBean>) Class.forName(pResultRow.get(BEAN_TYPE_COLUMN_ID));
+    }
+    catch (ClassNotFoundException pE)
+    {
+      throw new OJSQLException("Unable to resolve bean type!", pE);
+    }
+  }
+
+  /**
+   * Creates all {@link BeanColumnIdentification} definitions for a concrete bean type.
+   *
+   * @param pBeanType the bean type to resolve identifications for
+   * @return the resolved bean based column identifications
+   */
+  private static Set<BeanColumnIdentification<?>> columnIdentificationsFromBeanType(Class<? extends IBean> pBeanType)
+  {
+    return BeanReflector.reflectBeanFields(pBeanType).stream() //
+        .map(BeanColumnIdentification::new) //
+        .collect(Collectors.toSet());
+  }
+
+  /**
+   * Resolves all distinct {@link BeanColumnDefinition} for the supported sub types of the base container.
+   *
+   * @param pSubTypes all supported sub bean types
+   * @return a set of distinct bean column definitions over all sub types
+   */
+  private static Set<BeanColumnDefinition<?>> _resolveAllColumns(Set<Class<? extends IBean>> pSubTypes)
+  {
+    return pSubTypes.stream() //
+        .flatMap(pSubType -> BeanReflector.reflectBeanFields(pSubType).stream()) //
+        .distinct() //
+        .map(BeanColumnDefinition::new) //
+        .collect(Collectors.toSet());
+  }
+}
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModel.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModel.java
index 75af7bd..7c98e41 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModel.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModel.java
@@ -17,7 +17,7 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import static de.adito.ojcms.sql.datasource.util.DatabaseConstants.INDEX_COLUMN_NAME;
+import static de.adito.ojcms.sql.datasource.util.DatabaseConstants.*;
 import static de.adito.ojcms.sqlbuilder.definition.ENumericOperation.*;
 import static de.adito.ojcms.sqlbuilder.definition.INumericValueAdaption.of;
 import static de.adito.ojcms.sqlbuilder.definition.condition.IWhereCondition.greaterThan;
@@ -27,6 +27,7 @@
 import static de.adito.ojcms.sqlbuilder.definition.condition.IWhereOperator.greaterThan;
 import static de.adito.ojcms.sqlbuilder.definition.condition.IWhereOperator.lessThan;
 import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.toSet;
 
 /**
  * The persistence model for a database table for a persistent bean container.
@@ -38,41 +39,78 @@
 public class ContainerPersistenceModel implements IPersistenceModel
 {
   private static final IColumnDefinition INDEX_COLUMN_DEFINITION = IColumnDefinition.of(INDEX_COLUMN_NAME, EColumnType.INT.create());
-  private static final IColumnIdentification<Integer> INDEX_COLUMN = IColumnIdentification.of(INDEX_COLUMN_NAME, Integer.class);
+  protected static final IColumnIdentification<Integer> INDEX_COLUMN = IColumnIdentification.of(INDEX_COLUMN_NAME, Integer.class);
 
-  private final String containerId;
-  private final BeanColumnDefinition[] columnDefinitions;
-  private final BeanColumnIdentification<?>[] beanColumns;
-  private final List<IColumnIdentification<?>> columnsToSelect;
+  protected final String containerId;
+  private final Set<IColumnDefinition> columnDefinitions;
+  private final Set<BeanColumnIdentification<?>> beanColumnIdentifications;
+  private final Set<IColumnIdentification<?>> columnsToSelect;
 
   /**
    * Initializes the persistence model for a persistent bean container.
    *
    * @param pContainerId the container id of the persistent container
-   * @param pBeanType    the type of beans within the bean container
+   * @param pBeanType    the types of the beans in the container
    */
   ContainerPersistenceModel(String pContainerId, Class<? extends IBean> pBeanType)
+  {
+    this(pContainerId, BeanColumnDefinition.ofFields(BeanReflector.reflectBeanFields(pBeanType)));
+  }
+
+  /**
+   * Initializes the persistence model for a persistent bean container.
+   *
+   * @param pContainerId      the container id of the persistent container
+   * @param pColumns          the bean based column definitions for this container model
+   * @param pAdditionsColumns optional additional columns to select
+   */
+  ContainerPersistenceModel(String pContainerId, Set<BeanColumnDefinition<?>> pColumns, IColumnIdentification<?>... pAdditionsColumns)
   {
     containerId = StringUtility.requireNotEmpty(pContainerId, "container id");
-    final List<IField<?>> beanFields = BeanReflector.reflectBeanFields(pBeanType);
-    columnDefinitions = BeanColumnDefinition.ofFields(beanFields);
-    beanColumns = BeanColumnIdentification.ofMultiple(beanFields);
-    columnsToSelect = new ArrayList<>();
+    columnDefinitions = new HashSet<>(pColumns);
+    beanColumnIdentifications = pColumns.stream().map(BeanColumnDefinition::toColumnIdentification).collect(toSet());
+
+    columnsToSelect = new HashSet<>();
     columnsToSelect.add(INDEX_COLUMN);
-    columnsToSelect.addAll(Arrays.asList(beanColumns));
+    columnsToSelect.addAll(beanColumnIdentifications);
+    columnsToSelect.addAll(Arrays.asList(pAdditionsColumns));
   }
 
   @Override
   public void initModelInDatabase(OJSQLBuilder pBuilder)
   {
-    final List<IColumnDefinition> columnsToCreate = new ArrayList<>();
-    columnsToCreate.add(INDEX_COLUMN_DEFINITION);
-    columnsToCreate.addAll(Arrays.asList(columnDefinitions));
+    if (!pBuilder.hasTable(containerId))
+      pBuilder.doCreate(pCreate -> pCreate //
+          .tableName(containerId) //
+          .withIdColumn() //
+          .columns(getColumnsToCreateInitially()) //
+          .create());
+    else
+    {
+      final Set<String> existingColumnNames = pBuilder.getAllColumnNames(containerId);
+
+      final Set<IColumnDefinition> columnsToAdd = columnDefinitions.stream() //
+          .filter(pColumn -> !existingColumnNames.contains(pColumn.getColumnName())) //
+          .collect(toSet());
 
-    pBuilder.ifTableNotExistingCreate(containerId, pCreate -> pCreate
-        .withIdColumn()
-        .columns(columnsToCreate)
-        .create());
+      //After the removal the remaining columns must be dropped
+      existingColumnNames.remove(ID_COLUMN);
+      existingColumnNames.remove(INDEX_COLUMN_NAME);
+      existingColumnNames.remove(BEAN_TYPE_COLUMN_NAME);
+      existingColumnNames.removeAll(columnDefinitions.stream() //
+          .map(IColumnDefinition::getColumnName) //
+          .collect(toSet()));
+
+      if (existingColumnNames.isEmpty() && columnsToAdd.isEmpty())
+        return;
+
+      //Add new columns and drop obsolete columns
+      pBuilder.doAlterTable(pAlter -> pAlter //
+          .table(containerId) //
+          .columnsToAdd(columnsToAdd) //
+          .columnsToDrop(existingColumnNames) //
+          .alter());
+    }
   }
 
   /**
@@ -95,14 +133,7 @@ public int loadSize(OJSQLBuilder pBuilder)
    */
   public PersistentBeanData loadDataByIndex(InitialIndexKey pKey, OJSQLBuilder pBuilder)
   {
-    return pBuilder.doSelect(pSelect -> pSelect
-        .select(beanColumns)
-        .from(containerId)
-        .where(isEqual(INDEX_COLUMN, pKey.getIndex()))
-        .firstResult()
-        .map(pRow -> pRow.toMap(beanColumns, (Function<BeanColumnIdentification<?>, IField<?>>) BeanColumnIdentification::getBeanField))
-        .map(pBeanContent -> new PersistentBeanData(pKey.getIndex(), pBeanContent)))
-        .orElseThrow(() -> new BeanDataNotFoundException(pKey));
+    return selectSingleResultByIndex(pKey, columnsToSelect, pBuilder, this::_toBeanData);
   }
 
   /**
@@ -114,12 +145,11 @@ public PersistentBeanData loadDataByIndex(InitialIndexKey pKey, OJSQLBuilder pBu
    */
   public Optional<PersistentBeanData> loadDataByIdentifiers(Map<IField<?>, Object> pIdentifiers, OJSQLBuilder pBuilder)
   {
-    return pBuilder.doSelect(pSelect -> pSelect
-        .select(columnsToSelect)
-        .withId()
-        .from(containerId)
-        .where(BeanWhereCondition.conditionsOfMap(pIdentifiers))
-        .firstResult()
+    return pBuilder.doSelect(pSelect -> pSelect //
+        .select(columnsToSelect) //
+        .from(containerId) //
+        .where(BeanWhereCondition.conditionsOfMap(pIdentifiers)) //
+        .firstResult() //
         .map(this::_toBeanData));
   }
 
@@ -132,13 +162,12 @@ public Optional<PersistentBeanData> loadDataByIdentifiers(Map<IField<?>, Object>
    */
   public Map<Integer, PersistentBeanData> loadFullData(OJSQLBuilder pBuilder)
   {
-    return pBuilder.doSelect(pSelect -> pSelect
-        .select(columnsToSelect)
-        .withId()
-        .from(containerId)
-        .fullResult()
-        .stream()
-        .map(this::_toBeanData)
+    return pBuilder.doSelect(pSelect -> pSelect //
+        .select(columnsToSelect)//
+        .from(containerId) //
+        .fullResult() //
+        .stream() //
+        .map(this::_toBeanData) //
         .collect(Collectors.toMap(PersistentBeanData::getIndex, identity())));
   }
 
@@ -151,33 +180,33 @@ public Map<Integer, PersistentBeanData> loadFullData(OJSQLBuilder pBuilder)
    */
   public void processValueChanges(int pIndex, Map<IField<?>, Object> pChangedValues, OJSQLBuilder pBuilder)
   {
-    pBuilder.doUpdate(pUpdate -> pUpdate
-        .table(containerId)
-        .set(BeanColumnValueTuple.ofMap(pChangedValues))
-        .where(isEqual(INDEX_COLUMN, pIndex))
+    pBuilder.doUpdate(pUpdate -> pUpdate //
+        .table(containerId) //
+        .set(BeanColumnValueTuple.ofMap(pChangedValues)) //
+        .where(isEqual(INDEX_COLUMN, pIndex)) //
         .update());
   }
 
   /**
    * Processes bean additions for the persistent bean container.
    *
-   * @param pNewBeans the data of newly added beans
-   * @param pBuilder  a builder to execute SQL statements
+   * @param pBeanAdditions data of all added beans
+   * @param pBuilder       a builder to execute SQL statements
    */
-  public void processAdditions(Set<PersistentBeanData> pNewBeans, OJSQLBuilder pBuilder)
+  public void processAdditions(Set<BeanAddition> pBeanAdditions, OJSQLBuilder pBuilder)
   {
-    for (PersistentBeanData newBean : pNewBeans)
+    for (BeanAddition addition : pBeanAdditions)
     {
       //Increase index of every row above the inserted index
-      pBuilder.doUpdate(pUpdate -> pUpdate
-          .table(containerId)
-          .adaptNumericValue(of(INDEX_COLUMN, ADD, 1))
-          .where(greaterThanOrEqual(INDEX_COLUMN, newBean.getIndex()))
+      pBuilder.doUpdate(pUpdate -> pUpdate //
+          .table(containerId) //
+          .adaptNumericValue(of(INDEX_COLUMN, ADD, 1)) //
+          .where(greaterThanOrEqual(INDEX_COLUMN, addition.getIndex())) //
           .update());
 
-      pBuilder.doInsert(pInsert -> pInsert
-          .into(containerId)
-          .values(_tuplesToInsertForNewBean(newBean))
+      pBuilder.doInsert(pInsert -> pInsert //
+          .into(containerId) //
+          .values(tuplesToInsertForNewBean(addition)) //
           .insert());
     }
   }
@@ -190,14 +219,14 @@ public void processAdditions(Set<PersistentBeanData> pNewBeans, OJSQLBuilder pBu
    */
   public void processRemovals(Set<InitialIndexKey> pKeysToRemove, OJSQLBuilder pBuilder)
   {
-    final List<Integer> indexesToDelete = pKeysToRemove.stream()
-        .map(InitialIndexKey::getIndex)
-        .sorted()
+    final List<Integer> indexesToDelete = pKeysToRemove.stream() //
+        .map(InitialIndexKey::getIndex) //
+        .sorted() //
         .collect(Collectors.toList());
 
-    pBuilder.doDelete(pDelete -> pDelete
-        .from(containerId)
-        .where(IWhereCondition.in(INDEX_COLUMN, indexesToDelete))
+    pBuilder.doDelete(pDelete -> pDelete //
+        .from(containerId) //
+        .where(IWhereCondition.in(INDEX_COLUMN, indexesToDelete)) //
         .delete());
 
     //Update all indexes between the deleted indexes
@@ -207,46 +236,92 @@ public void processRemovals(Set<InitialIndexKey> pKeysToRemove, OJSQLBuilder pBu
       final int nextIndexToDelete = indexesToDelete.get(i + 1);
       final int offset = i + 1;
 
-      pBuilder.doUpdate(pUpdate -> pUpdate
-          .table(containerId)
-          .adaptNumericValue(of(INDEX_COLUMN, SUBTRACT, offset))
-          .whereId(create(greaterThan(), indexToDelete).and(lessThan(), nextIndexToDelete))
+      pBuilder.doUpdate(pUpdate -> pUpdate //
+          .table(containerId) //
+          .adaptNumericValue(of(INDEX_COLUMN, SUBTRACT, offset)) //
+          .whereId(create(greaterThan(), indexToDelete).and(lessThan(), nextIndexToDelete)) //
           .update());
     }
 
     //Update all row indexes after the last index to delete
-    pBuilder.doUpdate(pUpdate -> pUpdate
-        .table(containerId)
-        .adaptNumericValue(of(INDEX_COLUMN, SUBTRACT, indexesToDelete.size()))
-        .where(greaterThan(INDEX_COLUMN, indexesToDelete.get(indexesToDelete.size() - 1)))
+    pBuilder.doUpdate(pUpdate -> pUpdate //
+        .table(containerId) //
+        .adaptNumericValue(of(INDEX_COLUMN, SUBTRACT, indexesToDelete.size())) //
+        .where(greaterThan(INDEX_COLUMN, indexesToDelete.get(indexesToDelete.size() - 1))) //
         .update());
   }
 
   /**
-   * Converts a SQL {@link ResultRow} to {@link PersistentBeanData}.
+   * Selects a generic result from a single row in the database by index.
+   * Throws a {@link BeanDataNotFoundException} if there is not data at the given index.
    *
-   * @param pResultRow the SQL result row to convert
-   * @return the converted persistent bean data
+   * @param pIndexKey        the index based key to determine the row to select
+   * @param pColumnsToSelect the columns to select from the single row
+   * @param pBuilder         a builder to execute SQL statements
+   * @param pResultMapper    a mapper to convert the single {@link ResultRow} to the requested result
+   * @return the generic result for the single row
    */
-  private PersistentBeanData _toBeanData(ResultRow pResultRow)
+  protected <RESULT> RESULT selectSingleResultByIndex(InitialIndexKey pIndexKey, Set<IColumnIdentification<?>> pColumnsToSelect,
+                                                      OJSQLBuilder pBuilder, Function<ResultRow, RESULT> pResultMapper)
   {
-    final Map<IField<?>, Object> beanContent = pResultRow.toMap(beanColumns, BeanColumnIdentification::getBeanField);
-    final int index = pResultRow.get(INDEX_COLUMN);
-    return new PersistentBeanData(index, beanContent);
+    return pBuilder.doSelect(pSelect -> pSelect //
+        .select(pColumnsToSelect) //
+        .from(containerId) //
+        .where(isEqual(INDEX_COLUMN, pIndexKey.getIndex())) //
+        .firstResult() //
+        .map(pResultMapper) //
+        .orElseThrow(() -> new BeanDataNotFoundException(pIndexKey)));
+  }
+
+  /**
+   * Resolves a list of initial {@link IColumnDefinition} for the container SQL table to create.
+   *
+   * @return the list of columns to create for the container model
+   */
+  protected List<IColumnDefinition> getColumnsToCreateInitially()
+  {
+    final List<IColumnDefinition> columnsToCreate = new ArrayList<>();
+    columnsToCreate.add(INDEX_COLUMN_DEFINITION);
+    columnsToCreate.addAll(columnDefinitions);
+    return columnsToCreate;
   }
 
   /**
    * Creates a list of {@link IColumnValueTuple} to perform an insertion based on some {@link PersistentBeanData}.
    * The index value tuple will be included as well.
    *
-   * @param pBeanData the persistent bean data to create column value tuples for
+   * @param pBeanAddition data describing the addition
    * @return a list of column value tuples for an insertion
    */
-  private List<IColumnValueTuple<?>> _tuplesToInsertForNewBean(PersistentBeanData pBeanData)
+  protected List<IColumnValueTuple<?>> tuplesToInsertForNewBean(BeanAddition pBeanAddition)
   {
     final List<IColumnValueTuple<?>> tuplesToInsert = new ArrayList<>();
-    tuplesToInsert.add(IColumnValueTuple.of(INDEX_COLUMN, pBeanData.getIndex()));
-    tuplesToInsert.addAll(BeanColumnValueTuple.ofMap(pBeanData.getData()));
+    tuplesToInsert.add(IColumnValueTuple.of(INDEX_COLUMN, pBeanAddition.getIndex()));
+    tuplesToInsert.addAll(BeanColumnValueTuple.ofMap(pBeanAddition.getData()));
     return tuplesToInsert;
   }
+
+  /**
+   * Resolves bean content (field values tuples) from a {@link ResultRow}.
+   *
+   * @param pResultRow the result row to obtain bean data from
+   * @return the beans's content as field value tuples
+   */
+  protected Map<IField<?>, Object> resultRowToBeanContent(ResultRow pResultRow)
+  {
+    return pResultRow.toMap(beanColumnIdentifications, BeanColumnIdentification::getBeanField);
+  }
+
+  /**
+   * Converts a SQL {@link ResultRow} to {@link PersistentBeanData}.
+   *
+   * @param pResultRow the SQL result row to convert
+   * @return the converted persistent bean data
+   */
+  private PersistentBeanData _toBeanData(ResultRow pResultRow)
+  {
+    final Map<IField<?>, Object> beanContent = resultRowToBeanContent(pResultRow);
+    final int index = pResultRow.get(INDEX_COLUMN);
+    return new PersistentBeanData(index, beanContent);
+  }
 }
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/PersistenceModels.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/PersistenceModels.java
index f3a3e20..7d6bfbb 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/PersistenceModels.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/PersistenceModels.java
@@ -29,6 +29,17 @@ public void registerPersistentContainerBean(Class<? extends IBean> pBeanType, St
     containerModels.putIfAbsent(pContainerId, new ContainerPersistenceModel(pContainerId, pBeanType));
   }
 
+  /**
+   * Registers a persistent base container to create its {@link ContainerPersistenceModel}.
+   *
+   * @param pSubTypes    all supported sub bean types of the container
+   * @param pContainerId the id of the persistent container
+   */
+  public void registerPersistentBaseContainer(Set<Class<? extends IBean>> pSubTypes, String pContainerId)
+  {
+    containerModels.putIfAbsent(pContainerId, new BaseContainerPersistenceModel(pContainerId, pSubTypes));
+  }
+
   /**
    * Registers a persistent single bean type to create its {@link SingleBeanPersistenceModel}.
    *
@@ -54,6 +65,18 @@ public ContainerPersistenceModel getContainerPersistenceModel(String pContainerI
     return containerModels.get(pContainerId);
   }
 
+  /**
+   * Resolves a {@link BaseContainerPersistenceModel} by the id of the persistent container.
+   * Throws a {@link ClassCastException} if the requested model is not for a base container.
+   *
+   * @param pContainerId the id of the persistent container
+   * @return the resolved container persistence model
+   */
+  public BaseContainerPersistenceModel getBaseContainerPersistenceModel(String pContainerId)
+  {
+    return (BaseContainerPersistenceModel) getContainerPersistenceModel(pContainerId);
+  }
+
   /**
    * Resolves a {@link SingleBeanPersistenceModel} by the id of the persistent single bean.
    *
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/column/BeanColumnDefinition.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/column/BeanColumnDefinition.java
index 5b32269..ca6b4d6 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/column/BeanColumnDefinition.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/model/column/BeanColumnDefinition.java
@@ -5,7 +5,8 @@
 import de.adito.ojcms.beans.literals.fields.util.IBeanFieldBased;
 import de.adito.ojcms.sqlbuilder.definition.column.*;
 
-import java.util.Collection;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * A database column definition based on a bean field.
@@ -26,7 +27,7 @@ public class BeanColumnDefinition<VALUE> implements IColumnDefinition, IBeanFiel
   public BeanColumnDefinition(IField<VALUE> pBeanField)
   {
     beanField = pBeanField;
-    columnType = EColumnType.getByDataType(pBeanField.getDataType())
+    columnType = EColumnType.getByDataType(pBeanField.getDataType()) //
         .orElse(EColumnType.STRING.create());
 
     if (beanField.hasAnnotation(Identifier.class))
@@ -57,15 +58,25 @@ public IField<VALUE> getBeanField()
   }
 
   /**
-   * Creates an array of column definitions from a collection of bean fields.
+   * Creates a new {@link BeanColumnIdentification} for this column definition.
+   *
+   * @return the newly created column identification based on the bean field of this column
+   */
+  public BeanColumnIdentification<VALUE> toColumnIdentification()
+  {
+    return new BeanColumnIdentification<>(beanField);
+  }
+
+  /**
+   * Creates a set of column definitions from a collection of bean fields.
    *
    * @param pBeanFields the bean fields to create the array from
-   * @return an array of columns definitions
+   * @return a set of columns definitions
    */
-  public static BeanColumnDefinition<?>[] ofFields(Collection<IField<?>> pBeanFields)
+  public static Set<BeanColumnDefinition<?>> ofFields(Collection<IField<?>> pBeanFields)
   {
-    return pBeanFields.stream()
-        .map(BeanColumnDefinition::new)
-        .toArray(BeanColumnDefinition<?>[]::new);
+    return pBeanFields.stream() //
+        .map(BeanColumnDefinition::new) //
+        .collect(Collectors.toSet());
   }
 }
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataLoader.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataLoader.java
index 45351d0..3634cfa 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataLoader.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataLoader.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.sql.datasource.persistence;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.sql.datasource.model.PersistenceModels;
 import de.adito.ojcms.sqlbuilder.OJSQLBuilder;
@@ -41,6 +42,12 @@ public PersistentBeanData loadContainerBeanDataByIndex(InitialIndexKey pKey)
     return models.getContainerPersistenceModel(pKey.getContainerId()).loadDataByIndex(pKey, builder);
   }
 
+  @Override
+  public <BEAN extends IBean> Class<BEAN> loadBeanTypeWithinContainer(InitialIndexKey pKey)
+  {
+    return models.getBaseContainerPersistenceModel(pKey.getContainerId()).loadBeanType(pKey, builder);
+  }
+
   @Override
   public Optional<PersistentBeanData> loadContainerBeanDataByIdentifiers(String pContainerId, Map<IField<?>, Object> pIdentifiers)
   {
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataStorage.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataStorage.java
index cc3f119..caaff9b 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataStorage.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/persistence/SQLBeanDataStorage.java
@@ -35,6 +35,12 @@ public void registerPersistentContainerBean(Class<? extends IBean> pBeanType, St
     models.registerPersistentContainerBean(pBeanType, pContainerId);
   }
 
+  @Override
+  public void registerPersistentBaseTypeContainer(String pContainerId, Set<Class<? extends IBean>> pSubTypes)
+  {
+    models.registerPersistentBaseContainer(pSubTypes, pContainerId);
+  }
+
   @Override
   public void registerPersistentSingleBean(Class<? extends IBean> pBeanType, String pBeanId)
   {
@@ -54,16 +60,16 @@ public void processChangesForSingleBean(SingleBeanKey pKey, Map<IField<?>, Objec
   }
 
   @Override
-  public void processAdditionsForContainer(String pContainerId, Set<PersistentBeanData> pNewBeans)
+  public void processAdditionsForContainer(String pContainerId, Set<BeanAddition> pBeanAdditions)
   {
-    models.getContainerPersistenceModel(pContainerId).processAdditions(pNewBeans, builder);
+    models.getContainerPersistenceModel(pContainerId).processAdditions(pBeanAdditions, builder);
   }
 
   @Override
   public void processRemovals(Map<String, Set<InitialIndexKey>> pKeysToRemoveByContainer)
   {
-    pKeysToRemoveByContainer.forEach((pContainerId, pRemovedKeys) ->
-                                         models.getContainerPersistenceModel(pContainerId).processRemovals(pRemovedKeys, builder));
+    pKeysToRemoveByContainer //
+        .forEach((pContainerId, pRemovedKeys) -> models.getContainerPersistenceModel(pContainerId).processRemovals(pRemovedKeys, builder));
   }
 
   @Override
diff --git a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/util/DatabaseConstants.java b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/util/DatabaseConstants.java
index 615681c..e82d64a 100644
--- a/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/util/DatabaseConstants.java
+++ b/ojcms-sqldatasource/src/main/java/de/adito/ojcms/sql/datasource/util/DatabaseConstants.java
@@ -16,4 +16,5 @@ private DatabaseConstants()
   public static final String BEAN_TABLE_CONTENT = "beanContent";
   public static final String ID_COLUMN = "ID";
   public static final String INDEX_COLUMN_NAME = "INDEX";
+  public static final String BEAN_TYPE_COLUMN_NAME = "BEAN_TYPE";
 }
diff --git a/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/AbstractDatabaseTest.java b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/AbstractDatabaseTest.java
index 7861795..1d6202a 100644
--- a/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/AbstractDatabaseTest.java
+++ b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/AbstractDatabaseTest.java
@@ -17,6 +17,8 @@
 import javax.inject.Inject;
 import java.util.*;
 
+import static java.util.Collections.singleton;
+
 /**
  * Base class for database tests. This test uses an in-memory database to improve performance.
  * Every actual test class has to provide a {@link IPersistenceModel} type for which a database table will be created.
@@ -70,11 +72,24 @@ public void rollback()
   protected PersistentBeanData addContentToContainer(int pIndex, int pFirstValue, String pSecondValue, boolean pThirdValue)
   {
     final SomeBean bean = new SomeBean(pFirstValue, pSecondValue, pThirdValue);
-    final PersistentBeanData persistentData = new PersistentBeanData(pIndex, bean.toMap());
-    final Set<PersistentBeanData> newData = Collections.singleton(persistentData);
+    final Set<BeanAddition> additions = singleton(new BeanAddition(pIndex, bean.toMap(), SomeBean.class, CONTAINER_ID));
+    storage.processAdditionsForContainer(CONTAINER_ID, additions);
+    return new PersistentBeanData(pIndex, bean.toMap());
+  }
 
-    storage.processAdditionsForContainer(CONTAINER_ID, newData);
-    return persistentData;
+  /**
+   * Adds a sub type of {@link SomeBean} to the persistent base bean container.
+   * Only possible if the model type is assignable from {@link BaseContainerPersistenceModel}.
+   *
+   * @param pIndex    the index to add the bean at
+   * @param pBaseBean the sub type bean instance to add
+   * @return the persistent bean data of the added bean
+   */
+  protected PersistentBeanData addContentToBaseContainer(int pIndex, SomeBean pBaseBean)
+  {
+    final Set<BeanAddition> additions = singleton(new BeanAddition(pIndex, pBaseBean.toMap(), pBaseBean.getClass(), CONTAINER_ID));
+    storage.processAdditionsForContainer(CONTAINER_ID, additions);
+    return new PersistentBeanData(pIndex, pBaseBean.toMap());
   }
 
   /**
@@ -119,6 +134,12 @@ private MODEL _initModel()
     if (modelType == ContainerPersistenceModel.class)
       //noinspection unchecked
       return (MODEL) new ContainerPersistenceModel(CONTAINER_ID, SomeBean.class);
+    else if (modelType == BaseContainerPersistenceModel.class)
+    {
+      final Set<Class<? extends IBean>> subTypes = new HashSet<>(Arrays.asList(SomeOtherBean.class, SomeSpecialBean.class));
+      //noinspection unchecked
+      return (MODEL) new BaseContainerPersistenceModel(CONTAINER_ID, subTypes);
+    }
     else if (modelType == SingleBeanPersistenceModel.class)
     {
       SingleBeanPersistenceModel.createSingleBeanTableIfNecessary(builder);
@@ -148,6 +169,34 @@ private SomeBean(int pValue1, String pValue2, boolean pValue3)
     }
   }
 
+  /**
+   * Some other bean extending {@link SomeBean}.
+   */
+  public static class SomeOtherBean extends SomeBean
+  {
+    public static final IntegerField FIELD4 = OJFields.create(SomeOtherBean.class);
+
+    SomeOtherBean(int pValue1, String pValue2, boolean pValue3, int pValue4)
+    {
+      super(pValue1, pValue2, pValue3);
+      setValue(FIELD4, pValue4);
+    }
+  }
+
+  /**
+   * Some very special bean extending {@link SomeOtherBean}.
+   */
+  public static class SomeSpecialBean extends SomeOtherBean
+  {
+    public static final TextField FIELD5 = OJFields.create(SomeSpecialBean.class);
+
+    SomeSpecialBean(int pValue1, String pValue2, boolean pValue3, int pValue4, String pValue5)
+    {
+      super(pValue1, pValue2, pValue3, pValue4);
+      setValue(FIELD5, pValue5);
+    }
+  }
+
   /**
    * Mocked {@link PersistenceModels} that always returns the model for this test.
    */
diff --git a/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModelTest.java b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModelTest.java
new file mode 100644
index 0000000..e18924d
--- /dev/null
+++ b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/BaseContainerPersistenceModelTest.java
@@ -0,0 +1,81 @@
+package de.adito.ojcms.sql.datasource.model;
+
+import de.adito.ojcms.beans.IBean;
+import de.adito.ojcms.transactions.api.*;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Special tests for persistent base container models.
+ *
+ * @author Simon Danner, 18.03.2020
+ */
+public class BaseContainerPersistenceModelTest extends AbstractDatabaseTest<BaseContainerPersistenceModel>
+{
+  @Test
+  public void testInitModelInDatabase()
+  {
+    final Set<Class<? extends IBean>> subTypes = new HashSet<>(Arrays.asList(SomeOtherBean.class, SomeSpecialBean.class));
+    final BaseContainerPersistenceModel otherModel = new BaseContainerPersistenceModel(CONTAINER_ID + 2, subTypes);
+    otherModel.initModelInDatabase(builder);
+    otherModel.initModelInDatabase(builder); //Try it another time
+
+    assertTrue(builder.hasTable(CONTAINER_ID + 2));
+    assertEquals(8, builder.getColumnCount(CONTAINER_ID + 2)); //Five bean fields + id, index and type column -> 8
+
+    subTypes.remove(SomeSpecialBean.class);
+    final BaseContainerPersistenceModel otherModel2 = new BaseContainerPersistenceModel(CONTAINER_ID + 2, subTypes);
+    otherModel2.initModelInDatabase(builder);
+    assertEquals(7, builder.getColumnCount(CONTAINER_ID + 2)); //Four bean fields + id, index and type column -> 7
+  }
+
+  @Test
+  public void testLoadBeanType()
+  {
+    addContentToBaseContainer(0, new SomeOtherBean(1, "1", true, 2));
+    addContentToBaseContainer(1, new SomeSpecialBean(2, "2", false, 3, "3"));
+
+    final Class<IBean> type1 = model.loadBeanType(new InitialIndexKey(CONTAINER_ID, 0), builder);
+    final Class<IBean> type2 = model.loadBeanType(new InitialIndexKey(CONTAINER_ID, 1), builder);
+    assertSame(SomeOtherBean.class, type1);
+    assertSame(SomeSpecialBean.class, type2);
+  }
+
+  @Test
+  public void testLoadData()
+  {
+    final List<PersistentBeanData> added = _addSomeContent();
+
+    final PersistentBeanData result = model.loadDataByIndex(new InitialIndexKey(CONTAINER_ID, 0), builder);
+    assertEquals(added.get(0), result);
+    final PersistentBeanData result2 = model.loadDataByIdentifiers(createIdentifiers(2, "2"), builder) //
+        .orElseThrow(AssertionError::new);
+    assertEquals(added.get(1), result2);
+    final PersistentBeanData result3 = model.loadDataByIndex(new InitialIndexKey(CONTAINER_ID, 2), builder);
+    assertEquals(added.get(2), result3);
+  }
+
+  @Override
+  protected Class<BaseContainerPersistenceModel> getModelType()
+  {
+    return BaseContainerPersistenceModel.class;
+  }
+
+  /**
+   * Adds some content/beans to the container.
+   *
+   * @return the list of added bean data
+   */
+  private List<PersistentBeanData> _addSomeContent()
+  {
+    final List<PersistentBeanData> content = new ArrayList<>();
+    content.add(addContentToBaseContainer(0, new SomeSpecialBean(1, "1", true, 1, "1")));
+    content.add(addContentToBaseContainer(1, new SomeSpecialBean(2, "2", false, 2, "2")));
+    content.add(addContentToBaseContainer(2, new SomeOtherBean(3, "3", true, 3)));
+
+    return content;
+  }
+}
diff --git a/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModelTest.java b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModelTest.java
index e07b1d2..f6591ec 100644
--- a/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModelTest.java
+++ b/ojcms-sqldatasource/src/test/java/de/adito/ojcms/sql/datasource/model/ContainerPersistenceModelTest.java
@@ -40,7 +40,7 @@ public void testContainerSize()
   }
 
   @Test
-  public void testLoadDataByKey_Container()
+  public void testLoadData()
   {
     final InitialIndexKey indexKeyFirstRow = new InitialIndexKey(CONTAINER_ID, 0);
     assertThrows(BeanDataNotFoundException.class, () -> model.loadDataByIndex(indexKeyFirstRow, builder));
@@ -58,8 +58,7 @@ public void testLoadDataByKey_Container()
 
     final PersistentBeanData result = model.loadDataByIndex(indexKeyFirstRow, builder);
     assertEquals(added.get(0), result);
-    final PersistentBeanData result2 = model.loadDataByIdentifiers(createIdentifiers(2, "2"), builder)
-        .orElseThrow(AssertionError::new);
+    final PersistentBeanData result2 = model.loadDataByIdentifiers(createIdentifiers(2, "2"), builder).orElseThrow(AssertionError::new);
     assertEquals(added.get(1), result2);
   }
 
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/ManagedTransaction.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/ManagedTransaction.java
index c2aa8ee..2bbecb6 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/ManagedTransaction.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/ManagedTransaction.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.transactions;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.annotations.TransactionalScoped;
 import de.adito.ojcms.transactions.api.*;
@@ -30,6 +31,7 @@ class ManagedTransaction implements ITransaction
 
   private final Map<String, Integer> containerSizes = new HashMap<>();
   private final Map<InitialIndexKey, PersistentBeanData> containerBeanData = new HashMap<>();
+  private final Map<InitialIndexKey, Class<? extends IBean>> beanTypesWithinContainer = new HashMap<>();
   private final Map<_RequestByIdentifiers, Optional<InitialIndexKey>> identifierRequestCache = new HashMap<>();
   private final Map<SingleBeanKey, PersistentBeanData> singleBeanData = new HashMap<>();
   private final Map<String, Map<Integer, PersistentBeanData>> fullContainerData = new HashMap<>();
@@ -59,6 +61,22 @@ public PersistentBeanData requestBeanDataByIndex(CurrentIndexKey pKey)
     return transactionalChanges.integrateContainerBeanChanges(initialKey, beanData);
   }
 
+  @Override
+  public <BEAN extends IBean> Class<BEAN> requestBeanTypeWithinContainer(CurrentIndexKey pKey)
+  {
+    final InitialIndexKey initialKey = transactionalChanges.currentToInitialIndexKey(pKey);
+    overallTransactionalChanges.throwIfContainerBeanDirty(initialKey, transactionalChanges);
+
+    if (transactionalChanges.isAdded(pKey))
+      throw new IllegalStateException("Cannot request the type of a bean that has just been added within this transaction!");
+
+    if (transactionalChanges.isRemoved(initialKey))
+      throw new IllegalStateException("Cannot request the type of a bean that has been removed within this transaction!");
+
+    //noinspection unchecked
+    return (Class<BEAN>) beanTypesWithinContainer.computeIfAbsent(initialKey, loader::loadBeanTypeWithinContainer);
+  }
+
   @Override
   public Optional<PersistentBeanData> requestBeanDataByIdentifierTuples(String pContainerId, Map<IField<?>, Object> pIdentifiers)
   {
@@ -94,16 +112,16 @@ public Map<Integer, PersistentBeanData> requestFullContainerLoad(String pContain
     overallTransactionalChanges.throwIfContainerDirtyInSize(pContainerId, transactionalChanges);
     final Map<Integer, PersistentBeanData> fullData = fullContainerData.computeIfAbsent(pContainerId, loader::fullContainerLoad);
     //Integrate changes here as well
-    return fullData.entrySet().stream()
-        .collect(Collectors.toMap(Map.Entry::getKey, pEntry ->
-            transactionalChanges.integrateContainerBeanChanges(new InitialIndexKey(pContainerId, pEntry.getKey()), pEntry.getValue())));
+    return fullData.entrySet().stream() //
+        .collect(Collectors.toMap(Map.Entry::getKey, pEntry -> transactionalChanges
+            .integrateContainerBeanChanges(new InitialIndexKey(pContainerId, pEntry.getKey()), pEntry.getValue())));
   }
 
   @Override
-  public void registerBeanAddition(CurrentIndexKey pKey, Map<IField<?>, Object> pNewData)
+  public void registerBeanAddition(BeanAddition pBeanAddition)
   {
-    overallTransactionalChanges.throwIfContainerDirtyInSize(pKey.getContainerId(), transactionalChanges);
-    transactionalChanges.beanAdded(pKey, pNewData);
+    overallTransactionalChanges.throwIfContainerDirtyInSize(pBeanAddition.getContainerId(), transactionalChanges);
+    transactionalChanges.beanAdded(pBeanAddition);
   }
 
   @Override
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/TransactionalChanges.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/TransactionalChanges.java
index b9f62b8..eec9ef2 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/TransactionalChanges.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/TransactionalChanges.java
@@ -8,8 +8,7 @@
 import javax.annotation.*;
 import javax.inject.Inject;
 import java.util.*;
-
-import static java.util.stream.Collectors.toSet;
+import java.util.stream.Collectors;
 
 /**
  * Manages bean related changes for a single transaction.
@@ -25,7 +24,7 @@ class TransactionalChanges
   private IBeanDataStorage storage;
 
   //Containers
-  private final Map<String, Set<_BeanAddition>> additionsByContainer = new HashMap<>();
+  private final Map<String, Set<_VariableBeanAddition>> additionsByContainer = new HashMap<>();
   private final Map<String, Set<InitialIndexKey>> removalsByContainer = new HashMap<>();
   private final Map<InitialIndexKey, Map<IField<?>, Object>> changedContainerValuesByContainer = new HashMap<>();
   //Single beans
@@ -56,8 +55,8 @@ int getContainerSizeDifference(String pContainerId)
    */
   PersistentBeanData integrateContainerBeanChanges(InitialIndexKey pKey, PersistentBeanData pInitialData)
   {
-    final PersistentBeanData beanData = Optional.ofNullable(changedContainerValuesByContainer.get(pKey))
-        .map(pInitialData::integrateChanges)
+    final PersistentBeanData beanData = Optional.ofNullable(changedContainerValuesByContainer.get(pKey)) //
+        .map(pInitialData::integrateChanges) //
         .orElse(pInitialData);
 
     final int currentIndex = initialToCurrentIndexKey(pKey).getIndex();
@@ -73,8 +72,8 @@ PersistentBeanData integrateContainerBeanChanges(InitialIndexKey pKey, Persisten
    */
   PersistentBeanData integrateSingleBeanChanges(SingleBeanKey pKey, PersistentBeanData pInitialData)
   {
-    return Optional.ofNullable(changedSingleBeanValues.get(pKey))
-        .map(pInitialData::integrateChanges)
+    return Optional.ofNullable(changedSingleBeanValues.get(pKey)) //
+        .map(pInitialData::integrateChanges) //
         .orElse(pInitialData);
   }
 
@@ -121,7 +120,7 @@ InitialIndexKey currentToInitialIndexKey(CurrentIndexKey pCurrentKey)
    */
   boolean isContainerDirtyInSize(String pContainerId)
   {
-    return additionsByContainer.containsKey(pContainerId) && !additionsByContainer.get(pContainerId).isEmpty() ||
+    return additionsByContainer.containsKey(pContainerId) && !additionsByContainer.get(pContainerId).isEmpty() || //
         removalsByContainer.containsKey(pContainerId) && !removalsByContainer.get(pContainerId).isEmpty();
   }
 
@@ -156,8 +155,8 @@ boolean isSingleBeanDirty(SingleBeanKey pKey)
   boolean isAdded(CurrentIndexKey pKey)
   {
     final String containerId = pKey.getContainerId();
-    return additionsByContainer.containsKey(containerId) &&
-        additionsByContainer.get(containerId).contains(new _BeanAddition(pKey.getIndex()));
+    return additionsByContainer.containsKey(containerId) && //
+        additionsByContainer.get(containerId).contains(new _VariableBeanAddition(pKey.getIndex()));
   }
 
   /**
@@ -175,21 +174,19 @@ boolean isRemoved(InitialIndexKey pKey)
   /**
    * Notifies the change manager that a bean has been added to a container.
    *
-   * @param pCurrentKey the current index based key the bean has been added for
-   * @param pBeanData   the data of the added bean
+   * @param pBeanAddition data describing the addition
    */
-  void beanAdded(CurrentIndexKey pCurrentKey, Map<IField<?>, Object> pBeanData)
+  void beanAdded(BeanAddition pBeanAddition)
   {
-    final int index = pCurrentKey.getIndex();
-    final String containerId = pCurrentKey.getContainerId();
-    final PersistentBeanData newBeanData = new PersistentBeanData(index, pBeanData);
-    final _BeanAddition addition = new _BeanAddition(newBeanData.getData(), index);
-    final Set<_BeanAddition> additionsForContainer = additionsByContainer.computeIfAbsent(containerId, pId -> new HashSet<>());
+    final int index = pBeanAddition.getIndex();
+    final String containerId = pBeanAddition.getContainerId();
+    final _VariableBeanAddition addition = new _VariableBeanAddition(pBeanAddition);
+    final Set<_VariableBeanAddition> additionsForContainer = additionsByContainer.computeIfAbsent(containerId, pId -> new HashSet<>());
 
     //Adapt indexes of prior additions for the same and the indexes above
-    additionsForContainer.stream()
-        .filter(pAddition -> pAddition.getIndex() >= index)
-        .forEach(_BeanAddition::incrementIndex);
+    additionsForContainer.stream() //
+        .filter(pAddition -> pAddition.getIndex() >= index) //
+        .forEach(_VariableBeanAddition::incrementIndex);
 
     additionsForContainer.add(addition);
   }
@@ -203,12 +200,11 @@ void beanRemoved(CurrentIndexKey pCurrentKey)
   {
     if (isAdded(pCurrentKey)) //If the bean has been added in the same transaction, just removed the change again
     {
-      final Set<_BeanAddition> additionsOfContainer = additionsByContainer.get(pCurrentKey.getContainerId());
-      additionsOfContainer.remove(new _BeanAddition(pCurrentKey.getIndex()));
+      final Set<_VariableBeanAddition> additionsOfContainer = additionsByContainer.get(pCurrentKey.getContainerId());
+      additionsOfContainer.remove(new _VariableBeanAddition(pCurrentKey.getIndex()));
       //Adapt keys of additions
-      additionsOfContainer.stream()
-          .filter(pAddition -> pAddition.getIndex() > pCurrentKey.getIndex())
-          .forEach(_BeanAddition::decrementIndex);
+      additionsOfContainer.stream().filter(pAddition -> pAddition.getIndex() > pCurrentKey.getIndex()) //
+          .forEach(_VariableBeanAddition::decrementIndex);
     }
     else
     {
@@ -229,20 +225,20 @@ <VALUE> void containerBeanValueHasChanged(CurrentIndexKey pCurrentKey, IField<VA
   {
     if (isAdded(pCurrentKey))
     {
-      final _BeanAddition addition = additionsByContainer.get(pCurrentKey.getContainerId()).stream()
+      final _VariableBeanAddition addition = additionsByContainer.get(pCurrentKey.getContainerId()).stream() //
           .filter(pBeanAddition -> pBeanAddition.getIndex() == pCurrentKey.getIndex()) //
-          .findAny()
+          .findAny() //
           .orElseThrow(AssertionError::new);
 
       //Add changed value to addition data
-      addition.beanData.put(pChangedField, pNewValue);
+      addition.getContent().put(pChangedField, pNewValue);
     }
     else
     {
       final InitialIndexKey changedInitialKey = currentToInitialIndexKey(pCurrentKey);
       if (isRemoved(changedInitialKey))
-        throw new IllegalArgumentException("Cannot register change! Bean data for initial key " + changedInitialKey + " has been removed" +
-                                               " within this transaction!");
+        throw new IllegalArgumentException(
+            "Cannot register change! Bean data for initial key " + changedInitialKey + " has been removed" + " within this transaction!");
 
       changedContainerValuesByContainer.computeIfAbsent(changedInitialKey, pChangeKey -> new HashMap<>()).put(pChangedField, pNewValue);
     }
@@ -268,9 +264,9 @@ void commitChanges()
   {
     //The order is very important here: removals first, then additions and value changes at the end
     storage.processRemovals(removalsByContainer);
-    additionsByContainer.forEach((pContainerId, pData) -> storage.processAdditionsForContainer(pContainerId, pData.stream()
-        .map(_BeanAddition::toPersistentData)
-        .collect(toSet())));
+    additionsByContainer.forEach((pContainerId, pAddition) -> storage.processAdditionsForContainer(pContainerId, pAddition.stream() //
+        .map(_VariableBeanAddition::toBeanAdditionWithNewIndex) //
+        .collect(Collectors.toSet())));
 
     changedContainerValuesByContainer.forEach((pKey, pValues) -> storage.processChangesForContainerBean(pKey, pValues));
     changedSingleBeanValues.forEach((pKey, pValues) -> storage.processChangesForSingleBean(pKey, pValues));
@@ -285,10 +281,9 @@ void commitChanges()
    */
   private int _countAdditionsBeforeIndex(String pContainerId, int pIndex)
   {
-    return !additionsByContainer.containsKey(pContainerId) ? 0 : (int) additionsByContainer.get(pContainerId)
-        .stream()
-        .mapToInt(_BeanAddition::getIndex)
-        .filter(pAddedIndex -> pAddedIndex < pIndex)
+    return !additionsByContainer.containsKey(pContainerId) ? 0 : (int) additionsByContainer.get(pContainerId).stream() //
+        .mapToInt(_VariableBeanAddition::getIndex) //
+        .filter(pAddedIndex -> pAddedIndex < pIndex) //
         .count();
   }
 
@@ -301,10 +296,9 @@ private int _countAdditionsBeforeIndex(String pContainerId, int pIndex)
    */
   private int _countRemovalsBeforeAndAtIndex(String pContainerId, int pIndex)
   {
-    return !removalsByContainer.containsKey(pContainerId) ? 0 : (int) removalsByContainer.get(pContainerId)
-        .stream()
-        .mapToInt(InitialIndexKey::getIndex)
-        .filter(pRemovedIndex -> pRemovedIndex <= pIndex)
+    return !removalsByContainer.containsKey(pContainerId) ? 0 : (int) removalsByContainer.get(pContainerId).stream() //
+        .mapToInt(InitialIndexKey::getIndex) //
+        .filter(pRemovedIndex -> pRemovedIndex <= pIndex) //
         .count();
   }
 
@@ -316,8 +310,8 @@ private int _countRemovalsBeforeAndAtIndex(String pContainerId, int pIndex)
    */
   private int _countIfNotNull(Set<?> pAnySet)
   {
-    return Optional.ofNullable(pAnySet)
-        .map(Set::size)
+    return Optional.ofNullable(pAnySet) //
+        .map(Set::size) //
         .orElse(0);
   }
 
@@ -343,9 +337,10 @@ private void _deregister()
    * Describes the addition of a bean within the transaction.
    * The index of added beans may be adapted within the transaction if beans get added or removed later on.
    */
-  private static class _BeanAddition
+  private static class _VariableBeanAddition
   {
-    private final Map<IField<?>, Object> beanData;
+    private final BeanAddition original;
+    private final Map<IField<?>, Object> content;
     private int index;
 
     /**
@@ -353,31 +348,42 @@ private static class _BeanAddition
      *
      * @param pIndex the index for the bean addition
      */
-    _BeanAddition(int pIndex)
+    _VariableBeanAddition(int pIndex)
     {
-      this(Collections.emptyMap(), pIndex);
+      original = null;
+      content = null;
+      index = pIndex;
     }
 
     /**
-     * Creates a new bean addition for given data and at a given index.
+     * Creates a new bean addition for given type, data and index.
      *
-     * @param pBeanData the data of the added bean
-     * @param pIndex    the index at which the bean has been added
+     * @param pBeanAddition data describing the addition
      */
-    _BeanAddition(Map<IField<?>, Object> pBeanData, int pIndex)
+    _VariableBeanAddition(BeanAddition pBeanAddition)
     {
-      beanData = Objects.requireNonNull(pBeanData, "Bean data is required!");
-      index = pIndex;
+      original = pBeanAddition;
+      content = pBeanAddition.getData();
+      index = pBeanAddition.getIndex();
     }
 
     /**
-     * Converts the addition description to a {@link PersistentBeanData}.
+     * Return either the original {@link BeanAddition} if the index didn't change or creates a copy with the new index.
      *
-     * @return the created persistent bean data instance
+     * @return the bean addition with a potential adapted index
+     */
+    BeanAddition toBeanAdditionWithNewIndex()
+    {
+      return original.getIndex() == index && original.getData().equals(content) ? original : //
+          new BeanAddition(index, content, original.getBeanType(), original.getContainerId());
+    }
+
+    /**
+     * The content of the added bean.
      */
-    PersistentBeanData toPersistentData()
+    Map<IField<?>, Object> getContent()
     {
-      return new PersistentBeanData(index, beanData);
+      return content;
     }
 
     /**
@@ -412,7 +418,7 @@ public boolean equals(Object pOther)
       if (pOther == null || getClass() != pOther.getClass())
         return false;
 
-      final _BeanAddition that = (_BeanAddition) pOther;
+      final _VariableBeanAddition that = (_VariableBeanAddition) pOther;
       return index == that.index;
     }
 
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/BeanAddition.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/BeanAddition.java
new file mode 100644
index 0000000..298b0f9
--- /dev/null
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/BeanAddition.java
@@ -0,0 +1,79 @@
+package de.adito.ojcms.transactions.api;
+
+import de.adito.ojcms.beans.IBean;
+import de.adito.ojcms.beans.literals.fields.IField;
+import de.adito.ojcms.utils.StringUtility;
+
+import java.util.*;
+
+/**
+ * Defines an addition of a bean and its data to a bean container at a certain index.
+ *
+ * @author Simon Danner, 18.03.2020
+ */
+public final class BeanAddition extends PersistentBeanData
+{
+  private final Class<? extends IBean> beanType;
+  private final String containerId;
+
+  /**
+   * Initializes the bean addition data wrapper.
+   *
+   * @param pCurrentIndex index for the bean data or -1 if none
+   * @param pData         map based bean data (value for every field)
+   */
+  public BeanAddition(int pCurrentIndex, Map<IField<?>, Object> pData, Class<? extends IBean> pBeanType, String pContainerId)
+  {
+    super(pCurrentIndex, pData);
+    beanType = Objects.requireNonNull(pBeanType, "The bean type is required!");
+    containerId = StringUtility.requireNotEmpty(pContainerId, "container id");
+  }
+
+  /**
+   * The type of the added bean.
+   */
+  public Class<? extends IBean> getBeanType()
+  {
+    return beanType;
+  }
+
+  /**
+   * The id of the container the bean has been added to.
+   */
+  public String getContainerId()
+  {
+    return containerId;
+  }
+
+  @Override
+  public boolean equals(Object pOther)
+  {
+    if (this == pOther)
+      return true;
+    if (pOther == null || getClass() != pOther.getClass())
+      return false;
+    if (!super.equals(pOther))
+      return false;
+
+    final BeanAddition that = (BeanAddition) pOther;
+    return Objects.equals(beanType, that.beanType) && Objects.equals(containerId, that.containerId);
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return Objects.hash(super.hashCode(), beanType, containerId);
+  }
+
+  @Override
+  public String toString()
+  {
+    return getClass().getSimpleName() + "{" + //
+        "index=" + getIndex() + //
+        ", data=" + getData() + //
+        ", beanType=" + beanType.getName() + //
+        ", containerId=" + containerId + //
+        '}';
+
+  }
+}
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/ITransaction.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/ITransaction.java
index 4ba8648..261ff76 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/ITransaction.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/ITransaction.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.transactions.api;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.annotations.Transactional;
 
@@ -33,6 +34,15 @@ public interface ITransaction
    */
   PersistentBeanData requestBeanDataByIndex(CurrentIndexKey pKey);
 
+  /**
+   * Requests the type of a bean within a persistent container at a specific index.
+   * This may be necessary if the type of the container is a bean base type and the actual types are persisted in the storage system.
+   *
+   * @param pKey the index based key to identify the bean to resolve the type for
+   * @return the requested bean type
+   */
+  <BEAN extends IBean> Class<BEAN> requestBeanTypeWithinContainer(CurrentIndexKey pKey);
+
   /**
    * Requests persistent data of a bean within a container by identifying field value tuples.
    * This result may be empty if there's no bean for the given identifiers.
@@ -63,10 +73,9 @@ public interface ITransaction
   /**
    * Registers the addition of a bean to a container within this transaction.
    *
-   * @param pIndexKey the index key the bean has been added for
-   * @param pNewData  the data of the added bean
+   * @param pBeanAddition data describing the addition
    */
-  void registerBeanAddition(CurrentIndexKey pIndexKey, Map<IField<?>, Object> pNewData);
+  void registerBeanAddition(BeanAddition pBeanAddition);
 
   /**
    * Registers the removal of a bean from a container within this transaction.
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/PersistentBeanData.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/PersistentBeanData.java
index 175230b..fd8afee 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/PersistentBeanData.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/api/PersistentBeanData.java
@@ -9,7 +9,7 @@
  *
  * @author Simon Danner, 27.12.2019
  */
-public final class PersistentBeanData
+public class PersistentBeanData
 {
   private final int index;
   private final Map<IField<?>, Object> data;
@@ -84,9 +84,9 @@ public int hashCode()
   @Override
   public String toString()
   {
-    return getClass().getSimpleName() + "{" +
-        "index=" + index +
-        ", data=" + data +
+    return getClass().getSimpleName() + "{" + //
+        "index=" + index + //
+        ", data=" + data + //
         '}';
   }
 }
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataLoader.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataLoader.java
index ea42637..044c120 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataLoader.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataLoader.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.transactions.spi;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.transactions.api.*;
 
@@ -28,6 +29,15 @@ public interface IBeanDataLoader
    */
   PersistentBeanData loadContainerBeanDataByIndex(InitialIndexKey pKey);
 
+  /**
+   * Loads the type of a bean within a container at a specific index.
+   * This may be necessary if the type of the container is a bean base type and the actual types are persisted in the storage system.
+   *
+   * @param pKey the index based key to identify the bean to load the type for
+   * @return the requested bean type
+   */
+  <BEAN extends IBean> Class<BEAN> loadBeanTypeWithinContainer(InitialIndexKey pKey);
+
   /**
    * Loads persistent data for a bean within a container by identifying field values tuples.
    * This result may be empty if there's no bean for the given identifiers.
diff --git a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataStorage.java b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataStorage.java
index 5193b32..4429808 100644
--- a/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataStorage.java
+++ b/ojcms-transactions/src/main/java/de/adito/ojcms/transactions/spi/IBeanDataStorage.java
@@ -21,6 +21,14 @@ public interface IBeanDataStorage
    */
   void registerPersistentContainerBean(Class<? extends IBean> pBeanType, String pContainerId);
 
+  /**
+   * Registers a persistent container for bean base types. This may be used by the storage system to initialize required structures.
+   *
+   * @param pContainerId the id of the persistent container
+   * @param pSubTypes    the supported sub types that can be added to the base container
+   */
+  void registerPersistentBaseTypeContainer(String pContainerId, Set<Class<? extends IBean>> pSubTypes);
+
   /**
    * Registers a persistent single bean type. This may be used by the storage system to initialize required structures.
    *
@@ -48,10 +56,10 @@ public interface IBeanDataStorage
   /**
    * Processes all bean additions to a persistent container.
    *
-   * @param pContainerId the id of the container
-   * @param pNewData     a set of all added bean data
+   * @param pContainerId   the id of the container
+   * @param pBeanAdditions data of all added beans for the container
    */
-  void processAdditionsForContainer(String pContainerId, Set<PersistentBeanData> pNewData);
+  void processAdditionsForContainer(String pContainerId, Set<BeanAddition> pBeanAdditions);
 
   /**
    * Processes all bean removals from a persistent container.
diff --git a/ojcms-transactions/src/test/java/de/adito/ojcms/transactions/BeanTransactionTest.java b/ojcms-transactions/src/test/java/de/adito/ojcms/transactions/BeanTransactionTest.java
index cb63bb0..4e9f1f3 100644
--- a/ojcms-transactions/src/test/java/de/adito/ojcms/transactions/BeanTransactionTest.java
+++ b/ojcms-transactions/src/test/java/de/adito/ojcms/transactions/BeanTransactionTest.java
@@ -1,5 +1,6 @@
 package de.adito.ojcms.transactions;
 
+import de.adito.ojcms.beans.IBean;
 import de.adito.ojcms.beans.literals.fields.IField;
 import de.adito.ojcms.cdi.*;
 import de.adito.ojcms.transactions.annotations.TransactionalScoped;
@@ -70,7 +71,7 @@ public void testContainerBeanDataRequestByIndex()
   @Test
   public void testContainerBeanDataRequestByIdentifiers()
   {
-    final PersistentBeanData beanData = transaction.requestBeanDataByIdentifierTuples(CONTAINER_ID, Collections.emptyMap())
+    final PersistentBeanData beanData = transaction.requestBeanDataByIdentifierTuples(CONTAINER_ID, Collections.emptyMap()) //
         .orElseThrow(AssertionError::new);
     _checkBeanData(beanData);
   }
@@ -82,11 +83,34 @@ public void testSingleBeanDataRequest()
     _checkBeanData(beanData);
   }
 
+  @Test
+  public void testRequestBeanTypeWithinContainer_Added_Fails()
+  {
+    final CurrentIndexKey key = new CurrentIndexKey(CONTAINER_ID, 0);
+    _registerBeanAddition(0);
+    assertThrows(IllegalStateException.class, () -> transaction.requestBeanTypeWithinContainer(key));
+  }
+
+  @Test
+  public void testRequestBeanTypeWithinContainer_Removed_Fails()
+  {
+    transaction.registerBeanRemoval(new CurrentIndexKey(CONTAINER_ID, 4));
+    transaction.registerBeanRemoval(new CurrentIndexKey(CONTAINER_ID, 1));
+    assertThrows(IllegalStateException.class, () -> transaction.requestBeanTypeWithinContainer(new CurrentIndexKey(CONTAINER_ID, 3)));
+  }
+
+  @Test
+  public void testRequestBeanTypeWithinContainer()
+  {
+    final CurrentIndexKey key = new CurrentIndexKey(CONTAINER_ID, 0);
+    assertEquals(IBean.class, transaction.requestBeanTypeWithinContainer(key));
+  }
+
   @Test
   public void testRequestContainerSizeAfterChangeInSameTransaction()
   {
-    transaction.registerBeanAddition(new CurrentIndexKey(CONTAINER_ID, 1), Collections.emptyMap());
-    transaction.registerBeanAddition(new CurrentIndexKey(CONTAINER_ID, 2), Collections.emptyMap());
+    _registerBeanAddition(1);
+    _registerBeanAddition(2);
     transaction.registerBeanRemoval(new CurrentIndexKey(CONTAINER_ID, 0));
 
     final int size = transaction.requestContainerSize(CONTAINER_ID);
@@ -125,7 +149,7 @@ public void testRollback()
   @Test
   public void testAvoidConcurrentModificationMultipleTransactions()
   {
-    transaction.registerBeanAddition(new CurrentIndexKey(CONTAINER_ID, 1), Collections.emptyMap());
+    _registerBeanAddition(1);
     cdiControl.startContext(TransactionalScoped.class);
     assertThrows(ConcurrentTransactionException.class, () -> transaction.requestContainerSize(CONTAINER_ID));
   }
@@ -148,12 +172,17 @@ private void _checkBeanData(PersistentBeanData pResult)
 
   private void _registerChanges()
   {
-    transaction.registerBeanAddition(new CurrentIndexKey(CONTAINER_ID, 1), Collections.emptyMap());
+    _registerBeanAddition(1);
     transaction.registerBeanRemoval(new CurrentIndexKey(CONTAINER_ID, 1));
     transaction.registerContainerBeanValueChange(new CurrentIndexKey(CONTAINER_ID, 0), BEAN_FIELD, 6);
     transaction.registerSingleBeanValueChange(SINGLE_BEAN_KEY, BEAN_FIELD, 7);
   }
 
+  private void _registerBeanAddition(int pIndex)
+  {
+    transaction.registerBeanAddition(new BeanAddition(pIndex, Collections.emptyMap(), IBean.class, CONTAINER_ID));
+  }
+
   @Alternative
   @Priority(100)
   static class MockedBeanLoader implements IBeanDataLoader
@@ -172,6 +201,13 @@ public PersistentBeanData loadContainerBeanDataByIndex(InitialIndexKey pKey)
       return new PersistentBeanData(0, BEAN_DATA);
     }
 
+    @Override
+    public <BEAN extends IBean> Class<BEAN> loadBeanTypeWithinContainer(InitialIndexKey pKey)
+    {
+      //noinspection unchecked
+      return (Class<BEAN>) IBean.class;
+    }
+
     @Override
     public Optional<PersistentBeanData> loadContainerBeanDataByIdentifiers(String pContainerId, Map<IField<?>, Object> pIdentifiers)
     {