@@ -1,14 +1,15 @@
 package org.javawebstack.orm;
 
-import com.google.gson.annotations.Expose;
 import org.javawebstack.injector.Injector;
 import org.javawebstack.orm.exception.ORMQueryException;
 import org.javawebstack.orm.query.Query;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 
@@ -22,6 +23,7 @@ public class Model {
 
     {
         inject();
+        updateOriginal();
     }
 
     static {
@@ -36,20 +38,61 @@ public class Model {
         }
     }
 
-    @Expose(serialize = false, deserialize = false)
-    private boolean internalEntryExists = false;
-    @Expose(serialize = false, deserialize = false)
-    private final Map<Class<? extends Model>, Object> internalJoinedModels = new HashMap<>();
-    @Expose(serialize = false, deserialize = false)
-    private final Map<String, Object> internalLastValue = new HashMap<>();
+    private transient boolean internalEntryExists = false;
+    private transient final Map<Class<? extends Model>, Object> internalJoinedModels = new HashMap<>();
+    private transient Map<String, Object> internalOriginalValues = new HashMap<>();
 
     void internalAddJoinedModel(Class<? extends Model> type, Object entity) {
         internalJoinedModels.put(type, entity);
     }
 
-    void internalSetLastValue(String key, Object value) {
-        if (value == null) internalLastValue.remove(key);
-        else internalLastValue.put(key, value);
+    void updateOriginal() {
+        internalOriginalValues = getFieldValues();
+    }
+
+    public Map<String, Object> getFieldValues() {
+        TableInfo info = Repo.get(getClass()).getInfo();
+        Map<String, Object> values = new HashMap<>();
+        for(String field : info.getFields()) {
+            try {
+                values.put(field, info.getField(field).get(this));
+            } catch (IllegalAccessException ignored) { }
+        }
+        return values;
+    }
+
+    public Map<String, Object> getOriginalValues() {
+        return internalOriginalValues;
+    }
+
+    public <T> T getOriginalValue(String field) {
+        if(internalOriginalValues.get(field) == null)
+            return null;
+        return (T) internalOriginalValues.get(field);
+    }
+
+    public boolean isDirty(String... fields) {
+        List<String> dirty = getDirtyFields();
+        for(String f : fields) {
+            if(dirty.contains(f))
+                return true;
+        }
+        return false;
+    }
+
+    public List<String> getDirtyFields() {
+        List<String> dirty = new ArrayList<>();
+        Map<String, Object> original = getOriginalValues();
+        Map<String, Object> current = getFieldValues();
+        for(String key : current.keySet()) {
+            Object o = original.get(key);
+            Object c = current.get(key);
+            if(o == null && c == null)
+                continue;
+            if(o == null || !o.equals(c))
+                dirty.add(key);
+        }
+        return dirty;
     }
 
     public <T extends Model> T getJoined(Class<T> model) {
@@ -68,26 +111,6 @@ void setEntryExists(boolean exists) {
         this.internalEntryExists = exists;
     }
 
-    @Deprecated
-    public boolean isDirty(String... fields) {
-        Repo<?> repo = Repo.get(getClass());
-        for (String field : fields) {
-            try {
-                Object value = repo.getInfo().getField(field).get(this);
-                Object oldValue = internalLastValue.get(field);
-                if ((value == null && oldValue != null) || (oldValue == null && value != null))
-                    return true;
-                if (value == null)
-                    continue;
-                if (!value.equals(oldValue))
-                    return true;
-            } catch (IllegalAccessException e) {
-                throw new ORMQueryException(e);
-            }
-        }
-        return false;
-    }
-
     public void inject() {
         Injector injector = Repo.get(getClass()).getInfo().getConfig().getInjector();
         if (injector != null)
 
@@ -67,4 +67,8 @@ public static void autoMigrate(boolean fresh) {
         AutoMigrator.migrate(fresh, repositories.values().toArray(new Repo<?>[0]));
     }
 
+    public void reset() {
+        repositories.clear();
+    }
+
 }
@@ -107,6 +107,7 @@ public void create(T entry) {
         executeCreate(entry);
         observers.forEach(o -> o.created(entry));
         observers.forEach(o -> o.saved(entry));
+        entry.updateOriginal();
     }
 
     private void executeCreate(T entry) {
@@ -159,6 +160,7 @@ public void update(T entry) {
         where(info.getIdField(), getId(entry)).update(entry);
         observers.forEach(o -> o.updated(entry));
         observers.forEach(o -> o.saved(entry));
+        entry.updateOriginal();
     }
 
     public void delete(T entry) {
@@ -172,6 +174,7 @@ public void delete(T entry) {
             }
         }
         observers.forEach(o -> o.deleted(entry));
+        entry.updateOriginal();
     }
 
     public void restore(T entry) {
@@ -192,7 +195,9 @@ public void finalDelete(T entry) {
     }
 
     public T refresh(T entry) {
-        return where(info.getIdField(), getId(entry)).refresh(entry);
+        where(info.getIdField(), getId(entry)).refresh(entry);
+        entry.updateOriginal();
+        return entry;
     }
 
     public T get(Object id) {
 
@@ -50,9 +50,9 @@ public static <T extends Model> T mapBack(Repo<T> repo, ResultSet rs, T t) {
         t.setEntryExists(true);
         for (String fieldName : repo.getInfo().getFields()) {
             Object value = getValue(rs, repo.getInfo().getType(fieldName).getJavaType(), repo.getInfo().getTableName(), repo.getInfo().getColumnName(fieldName));
-            t.internalSetLastValue(fieldName, value);
             setValue(repo, fieldName, t, value);
         }
+        t.updateOriginal();
         return t;
     }
 
@@ -125,7 +125,6 @@ private static <T extends Model> void setValue(Repo<T> repo, String fieldName, T
             for (TypeMapper mapper : repo.getInfo().getConfig().getTypeMappers())
                 value = mapper.mapToJava(value, repo.getInfo().getField(fieldName).getType());
             repo.getInfo().getField(fieldName).set(entry, value);
-            entry.internalSetLastValue(fieldName, value);
         } catch (IllegalAccessException e) {
             throw new ORMQueryException(e);
         }
Original file line number	Diff line number	Diff line change
`@@ -67,4 +67,8 @@ public static void autoMigrate(boolean fresh) {`
`67`	`67`	`AutoMigrator.migrate(fresh, repositories.values().toArray(new Repo<?>[0]));`
`68`	`68`	`}`
`69`	`69`
	`70`	`+ public void reset() {`
	`71`	`+ repositories.clear();`
	`72`	`+ }`
	`73`	`+`
`70`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,6 +107,7 @@ public void create(T entry) {`
`107`	`107`	`executeCreate(entry);`
`108`	`108`	`observers.forEach(o -> o.created(entry));`
`109`	`109`	`observers.forEach(o -> o.saved(entry));`
	`110`	`+ entry.updateOriginal();`
`110`	`111`	`}`
`111`	`112`
`112`	`113`	`private void executeCreate(T entry) {`
`@@ -159,6 +160,7 @@ public void update(T entry) {`
`159`	`160`	`where(info.getIdField(), getId(entry)).update(entry);`
`160`	`161`	`observers.forEach(o -> o.updated(entry));`
`161`	`162`	`observers.forEach(o -> o.saved(entry));`
	`163`	`+ entry.updateOriginal();`
`162`	`164`	`}`
`163`	`165`
`164`	`166`	`public void delete(T entry) {`
`@@ -172,6 +174,7 @@ public void delete(T entry) {`
`172`	`174`	`}`
`173`	`175`	`}`
`174`	`176`	`observers.forEach(o -> o.deleted(entry));`
	`177`	`+ entry.updateOriginal();`
`175`	`178`	`}`
`176`	`179`
`177`	`180`	`public void restore(T entry) {`
`@@ -192,7 +195,9 @@ public void finalDelete(T entry) {`
`192`	`195`	`}`
`193`	`196`
`194`	`197`	`public T refresh(T entry) {`
`195`		`- return where(info.getIdField(), getId(entry)).refresh(entry);`
	`198`	`+ where(info.getIdField(), getId(entry)).refresh(entry);`
	`199`	`+ entry.updateOriginal();`
	`200`	`+ return entry;`
`196`	`201`	`}`
`197`	`202`
`198`	`203`	`public T get(Object id) {`
Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,9 @@ public static <T extends Model> T mapBack(Repo<T> repo, ResultSet rs, T t) {`
`50`	`50`	`t.setEntryExists(true);`
`51`	`51`	`for (String fieldName : repo.getInfo().getFields()) {`
`52`	`52`	`Object value = getValue(rs, repo.getInfo().getType(fieldName).getJavaType(), repo.getInfo().getTableName(), repo.getInfo().getColumnName(fieldName));`
`53`		`- t.internalSetLastValue(fieldName, value);`
`54`	`53`	`setValue(repo, fieldName, t, value);`
`55`	`54`	`}`
	`55`	`+ t.updateOriginal();`
`56`	`56`	`return t;`
`57`	`57`	`}`
`58`	`58`
`@@ -125,7 +125,6 @@ private static <T extends Model> void setValue(Repo<T> repo, String fieldName, T`
`125`	`125`	`for (TypeMapper mapper : repo.getInfo().getConfig().getTypeMappers())`
`126`	`126`	`value = mapper.mapToJava(value, repo.getInfo().getField(fieldName).getType());`
`127`	`127`	`repo.getInfo().getField(fieldName).set(entry, value);`
`128`		`- entry.internalSetLastValue(fieldName, value);`
`129`	`128`	`} catch (IllegalAccessException e) {`
`130`	`129`	`throw new ORMQueryException(e);`
`131`	`130`	`}`