diff --git a/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedDescriptorWrapper.java b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedDescriptorWrapper.java
new file mode 100644
index 0000000..744095f
--- /dev/null
+++ b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedDescriptorWrapper.java
@@ -0,0 +1,167 @@
+package org.eclipse.osbp.jpa.services.history;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import javax.persistence.Version;
+
+import org.eclipse.osbp.runtime.common.annotations.HistIsCurrent;
+import org.eclipse.osbp.runtime.common.annotations.HistIsCustomVersion;
+import org.eclipse.osbp.runtime.common.annotations.HistValidUntil;
+import org.eclipse.osbp.runtime.common.historized.UUIDHist;
+import org.eclipse.osbp.runtime.common.util.BeanUtils;
+import org.eclipse.persistence.descriptors.ClassDescriptor;
+import org.eclipse.persistence.internal.helper.DatabaseField;
+import org.eclipse.persistence.mappings.DatabaseMapping;
+
+public class HistorizedDescriptorWrapper {
+
+	private final Class<?> clazz;
+	private final ClassDescriptor descriptor;
+	private DatabaseMapping versionMapping;
+	private DatabaseMapping validUntilMapping;
+	private DatabaseMapping currentMapping;
+	private DatabaseMapping isCustomVersionMapping;
+
+	private DatabaseMapping idMapping;
+	private ClassDescriptor uuidHistDescriptor;
+	private DatabaseMapping id_idMapping;
+	private DatabaseMapping id_validFromMapping;
+
+	public HistorizedDescriptorWrapper(ClassDescriptor descriptor) {
+		this.clazz = descriptor.getJavaClass();
+		this.descriptor = descriptor;
+
+		// find the ID String field by the descriptor
+		List<DatabaseField> pk = descriptor.getPrimaryKeyFields();
+		for (DatabaseMapping mapping : descriptor.getMappings()) {
+			if (mapping.isPrimaryKeyMapping()) {
+				idMapping = mapping;
+				break;
+			}
+		}
+
+		uuidHistDescriptor = idMapping.getReferenceDescriptor();
+
+		Field versionField = BeanUtils.getField(clazz, Version.class);
+		Field validUntilField = BeanUtils.getField(clazz, HistValidUntil.class);
+		Field currentHist = BeanUtils.getField(clazz, HistIsCurrent.class);
+		Field isCustomVersion = BeanUtils.getField(clazz, HistIsCustomVersion.class);
+
+		id_idMapping = uuidHistDescriptor.getMappingForAttributeName("id");
+		id_validFromMapping = uuidHistDescriptor.getMappingForAttributeName("validFrom");
+		versionMapping = descriptor.getMappingForAttributeName(versionField.getName());
+		validUntilMapping = descriptor.getMappingForAttributeName(validUntilField.getName());
+		currentMapping = descriptor.getMappingForAttributeName(currentHist.getName());
+		isCustomVersionMapping = descriptor.getMappingForAttributeName(isCustomVersion.getName());
+	}
+
+	public String getIdAttName() {
+		return idMapping.getAttributeName();
+	}
+
+	public String getId_IdAttName() {
+		return id_idMapping.getAttributeName();
+	}
+
+	public String getId_ValidFromAttName() {
+		return id_validFromMapping.getAttributeName();
+	}
+
+	public String getVersionAttName() {
+		return versionMapping.getAttributeName();
+	}
+
+	public String getValidUntilAttName() {
+		return validUntilMapping.getAttributeName();
+	}
+
+	public String getCurrentHistAttName() {
+		return currentMapping.getAttributeName();
+	}
+
+	public String getIsCustomVersionAttName() {
+		return isCustomVersionMapping.getAttributeName();
+	}
+
+	public UUIDHist getID(Object obj) {
+		return (UUIDHist) idMapping.getAttributeValueFromObject(obj);
+	}
+
+	public int getVersion(Object obj) {
+		return (int) versionMapping.getAttributeValueFromObject(obj);
+	}
+
+	public long getId_ValidFrom(Object obj) {
+		if (obj instanceof UUIDHist) {
+			return ((UUIDHist) obj).getValidFrom();
+		}
+		UUIDHist idHist = (UUIDHist) idMapping.getAttributeValueFromObject(obj);
+		return idHist != null ? idHist.getValidFrom() : -1;
+	}
+
+	public String getId_IdFrom(Object obj) {
+		if (obj instanceof UUIDHist) {
+			return ((UUIDHist) obj).getId();
+		}
+		UUIDHist idHist = (UUIDHist) idMapping.getAttributeValueFromObject(obj);
+		return idHist != null ? idHist.getId() : null;
+	}
+
+	public long getValidUntil(Object obj) {
+		return (long) validUntilMapping.getAttributeValueFromObject(obj);
+	}
+
+	public boolean isCurrentHist(Object obj) {
+		return (boolean) currentMapping.getAttributeValueFromObject(obj);
+	}
+
+	public boolean isCustomVersion(Object obj) {
+		return (boolean) isCustomVersionMapping.getAttributeValueFromObject(obj);
+	}
+
+	public Class<?> getEntityClass() {
+		return descriptor.getJavaClass();
+	}
+
+	public void setID(Object obj, Object value) {
+		idMapping.setAttributeValueInObject(obj, value);
+	}
+
+	public void setVersion(Object obj, int value) {
+		versionMapping.setAttributeValueInObject(obj, value);
+	}
+
+	public void setId_ValidFrom(Object obj, long value) {
+		if (obj instanceof UUIDHist) {
+			((UUIDHist) obj).setValidFrom(value);
+		}
+		UUIDHist idHist = (UUIDHist) idMapping.getAttributeValueFromObject(obj);
+		if (idHist != null) {
+			idHist.setValidFrom(value);
+		}
+	}
+
+	public void setId_IdFrom(Object obj, String value) {
+		if (obj instanceof UUIDHist) {
+			((UUIDHist) obj).setId(value);
+		}
+		UUIDHist idHist = (UUIDHist) idMapping.getAttributeValueFromObject(obj);
+		if (idHist != null) {
+			idHist.setId(value);
+		}
+	}
+
+	public void setValidUntil(Object obj, long value) {
+		validUntilMapping.setAttributeValueInObject(obj, value);
+	}
+
+	public void setCurrentHist(Object obj, boolean value) {
+		currentMapping.setAttributeValueInObject(obj, value);
+	}
+
+	public void setCustomVersion(Object obj, boolean value) {
+		isCustomVersionMapping.setAttributeValueInObject(obj, value);
+	}
+
+}
diff --git a/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedObjectWrapper.java b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedObjectWrapper.java
new file mode 100644
index 0000000..a8173d9
--- /dev/null
+++ b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedObjectWrapper.java
@@ -0,0 +1,109 @@
+package org.eclipse.osbp.jpa.services.history;
+
+import org.eclipse.osbp.runtime.common.historized.UUIDHist;
+import org.eclipse.persistence.descriptors.ClassDescriptor;
+
+/**
+ * This class gives access to historized annotated fields in the given obj.
+ */
+public class HistorizedObjectWrapper {
+
+	private HistorizedDescriptorWrapper delegate;
+	private Object obj;
+
+	public HistorizedObjectWrapper(ClassDescriptor descriptor, Object obj) {
+		delegate = new HistorizedDescriptorWrapper(descriptor);
+		this.obj = obj;
+	}
+
+	public String getIdAttName() {
+		return delegate.getIdAttName();
+	}
+
+	public String getVersionAttName() {
+		return delegate.getVersionAttName();
+	}
+
+	
+	
+	public String getId_IdAttName() {
+		return delegate.getId_IdAttName();
+	}
+
+	public String getId_ValidFromAttName() {
+		return delegate.getId_ValidFromAttName();
+	}
+
+	public long getId_ValidFrom() {
+		return delegate.getId_ValidFrom(obj);
+	}
+
+	public String getId_IdFrom() {
+		return delegate.getId_IdFrom(obj);
+	}
+
+	public void setId_ValidFrom(long value) {
+		delegate.setId_ValidFrom(obj, value);
+	}
+
+	public void setId_IdFrom(String value) {
+		delegate.setId_IdFrom(obj, value);
+	}
+
+	public String getValidUntilAttName() {
+		return delegate.getValidUntilAttName();
+	}
+
+	public String getCurrentHistAttName() {
+		return delegate.getCurrentHistAttName();
+	}
+
+	public String getIsCustomVersionAttName() {
+		return delegate.getIsCustomVersionAttName();
+	}
+
+	public UUIDHist getID() {
+		return delegate.getID(obj);
+	}
+
+	public long getVersion() {
+		return delegate.getVersion(obj);
+	}
+
+	public long getValidUntil() {
+		return delegate.getValidUntil(obj);
+	}
+
+	public boolean isCurrentHist() {
+		return delegate.isCurrentHist(obj);
+	}
+
+	public boolean isCustomVersion() {
+		return delegate.isCustomVersion(obj);
+	}
+
+	public Class<?> getEntityClass() {
+		return delegate.getEntityClass();
+	}
+
+	public void setID(Object value) {
+		delegate.setID(obj, value);
+	}
+
+	public void setVersion(int value) {
+		delegate.setVersion(obj, value);
+	}
+
+	public void setValidUntil(long value) {
+		delegate.setValidUntil(obj, value);
+	}
+
+	public void setCurrentHist(boolean value) {
+		delegate.setCurrentHist(obj, value);
+	}
+
+	public void setCustomVersion(boolean value) {
+		delegate.setCustomVersion(obj, value);
+	}
+
+}
diff --git a/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedQueryRedirector.java b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedQueryRedirector.java
new file mode 100644
index 0000000..96168f5
--- /dev/null
+++ b/org.eclipse.osbp.jpa.services/src/org/eclipse/osbp/jpa/services/history/HistorizedQueryRedirector.java
@@ -0,0 +1,144 @@
+package org.eclipse.osbp.jpa.services.history;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import org.eclipse.persistence.expressions.Expression;
+import org.eclipse.persistence.expressions.ExpressionBuilder;
+import org.eclipse.persistence.internal.sessions.AbstractRecord;
+import org.eclipse.persistence.internal.sessions.AbstractSession;
+import org.eclipse.persistence.internal.sessions.EmptyRecord;
+import org.eclipse.persistence.internal.sessions.UnitOfWorkImpl;
+import org.eclipse.persistence.queries.DatabaseQuery;
+import org.eclipse.persistence.queries.InsertObjectQuery;
+import org.eclipse.persistence.queries.QueryRedirector;
+import org.eclipse.persistence.queries.ReadObjectQuery;
+import org.eclipse.persistence.queries.UpdateObjectQuery;
+import org.eclipse.persistence.queries.WriteObjectQuery;
+import org.eclipse.persistence.sessions.Record;
+import org.eclipse.persistence.sessions.Session;
+
+/**
+ * Manages the versioning of historized and timedependent entities.
+ */
+@SuppressWarnings("serial")
+public class HistorizedQueryRedirector implements QueryRedirector {
+
+	@Override
+	public Object invokeQuery(DatabaseQuery query, Record arguments, Session session) {
+		WriteObjectQuery writeObjectQuery = (WriteObjectQuery) query;
+
+		Object persistedObj = writeObjectQuery.getObject();
+
+		// the object that was persisted / merged
+		//
+		HistorizedObjectWrapper persistedObjWrapper = new HistorizedObjectWrapper(writeObjectQuery.getDescriptor(),
+				persistedObj);
+
+		if (persistedObjWrapper.getVersion() > 1) {
+			throw new IllegalArgumentException(
+					"Version must be 0. Changing historized records is not allowed: " + persistedObj.toString());
+		}
+		Object current = getCurrent(persistedObjWrapper, (AbstractSession) session);
+
+		if (current == null) {
+			persistedObjWrapper.setId_ValidFrom(createNow(persistedObjWrapper));
+			persistedObjWrapper.setValidUntil(getMaxDate());
+			persistedObjWrapper.setCurrentHist(true);
+
+			writeObjectQuery.setDoNotRedirect(true);
+			Object newAdr = writeObjectQuery.execute((AbstractSession) session, (AbstractRecord) arguments);
+			return newAdr;
+		} else {
+
+			// sleep 1ms for minimum time intervall between historized records
+			try {
+				Thread.sleep(1);
+			} catch (InterruptedException e) {
+			}
+
+			// update the address to be historized
+			long now = createNow(persistedObjWrapper);
+			Object histCurrentObj = getCurrentManaged(
+					new HistorizedObjectWrapper(writeObjectQuery.getDescriptor(), current), (AbstractSession) session);
+
+			// the current object in database with flag histCurrent = true
+			//
+			HistorizedObjectWrapper histCurrentObjWrapper = new HistorizedObjectWrapper(
+					writeObjectQuery.getDescriptor(), histCurrentObj);
+
+			if (query.getDescriptor().getObjectBuilder().compareObjects(persistedObj, histCurrentObj,
+					(AbstractSession) session)) {
+				return persistedObj;
+			}
+
+			histCurrentObjWrapper.setCurrentHist(false);
+			histCurrentObjWrapper.setValidUntil(now);
+			UpdateObjectQuery updateCurrent = new UpdateObjectQuery(histCurrentObj);
+			updateCurrent.setDoNotRedirect(true);
+			updateCurrent.setIsUserDefined(true);
+			updateCurrent.execute((AbstractSession) session, (AbstractRecord) arguments);
+
+			persistedObjWrapper.setId_ValidFrom(now);
+			persistedObjWrapper.setValidUntil(getMaxDate());
+			persistedObjWrapper.setCurrentHist(true);
+			persistedObjWrapper.setVersion((int) 0);
+
+			InsertObjectQuery insertObjectQ = new InsertObjectQuery(persistedObj);
+			insertObjectQ.setIsUserDefined(true);
+			insertObjectQ.setDoNotRedirect(true);
+
+			Object newAdr = insertObjectQ.execute((AbstractSession) session, (AbstractRecord) arguments);
+			return newAdr;
+		}
+
+	}
+
+	private long createNow(HistorizedObjectWrapper wrapper) {
+		if (wrapper.isCustomVersion()) {
+			return wrapper.getId_ValidFrom();
+		}
+		return new Date().getTime();
+	}
+
+	private Object getCurrent(HistorizedObjectWrapper wrapper, AbstractSession session) {
+
+		UnitOfWorkImpl uow = session.acquireNonSynchronizedUnitOfWork();
+
+		ReadObjectQuery rq = new ReadObjectQuery(wrapper.getEntityClass());
+
+		ExpressionBuilder eb = rq.getExpressionBuilder();
+		Expression exp = eb.get(wrapper.getIdAttName()).get(wrapper.getId_IdAttName()).equal(wrapper.getID().id)
+				.and(eb.get(wrapper.getCurrentHistAttName()).equal(true));
+		rq.setSelectionCriteria(exp);
+		rq.dontCheckCache();
+		rq.dontMaintainCache();
+
+		Object current = (Object) rq.executeInUnitOfWork(uow, EmptyRecord.getEmptyRecord());
+
+		uow.clearForClose(true);
+		return current;
+	}
+
+	private Object getCurrentManaged(HistorizedObjectWrapper wrapper, AbstractSession session) {
+
+		ReadObjectQuery rq = new ReadObjectQuery(wrapper.getEntityClass());
+
+		ExpressionBuilder eb = rq.getExpressionBuilder();
+		Expression exp = eb.get(wrapper.getIdAttName()).equal(wrapper.getID());
+		rq.setSelectionCriteria(exp);
+
+		Object current = rq.execute(session, EmptyRecord.getEmptyRecord());
+
+		return current;
+	}
+
+	private long getMaxDate() {
+		Calendar cal = Calendar.getInstance();
+		cal.set(2099, Calendar.DECEMBER, 31, 0, 0, 0);
+		cal.set(Calendar.MILLISECOND, 0);
+		Date maxDate = cal.getTime();
+		return maxDate.getTime();
+	}
+
+}