+ * By default the content will be stored in a DB Clob except on Postgres where DB JSON type is used. + *
{@code + * + * // Store as JSON on Postgres or Clob on other databases + * @DbJson + * Map content; + * + * }
{@code + * + * // Store as JSONB on Postgres or Clob on other databases + * @DbJson(storage = DbJsonType.JSONB) + * Map content; + * + * }
+ * The content will be stored on Postgres using it's JSONB type and as Clob for other databases. + *
+ * This is equivalent to using @DbJson(storage = DbJsonType.JSONB) + *
@DbJson(storage = DbJsonType.JSONB)
{@code + * + * // Store as JSONB on Postgres or Clob on other databases + * @DbJsonB + * Map content; + * + * }
@@ -65,10 +52,16 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { private final ConcurrentHashMap> nativeMap; - private final ConcurrentHashMap> customTypeMap; - private final DefaultTypeFactory extraTypeFactory; + private final ScalarTypeJsonMap JSON_MAP_CLOB = new ScalarTypeJsonMap.Clob(); + + private final ScalarTypeJsonMap jsonMapClob = JSON_MAP_CLOB; + private final ScalarTypeJsonMap jsonMapBlob = new ScalarTypeJsonMap.Blob(); + private final ScalarTypeJsonMap jsonMapVarchar = new ScalarTypeJsonMap.Varchar(); + private final ScalarTypeJsonMap jsonMapJson; + private final ScalarTypeJsonMap jsonMapJsonb; + private final ScalarTypeFile fileType = new ScalarTypeFile(); private final ScalarType charType = new ScalarTypeChar(); @@ -134,9 +127,6 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { */ public DefaultTypeManager(ServerConfig config, BootupClasses bootupClasses) { - int clobType = config.getDatabasePlatform().getClobDbType(); - int blobType = config.getDatabasePlatform().getBlobDbType(); - this.jsonDateTime = config.getJsonDateTime(); this.checkImmutable = new CheckImmutable(this); this.reflectScalarBuilder = new ReflectionBasedTypeBuilder(this); @@ -144,18 +134,24 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { this.compoundTypeMap = new ConcurrentHashMap, CtCompoundType>(); this.typeMap = new ConcurrentHashMap, ScalarType>(); this.nativeMap = new ConcurrentHashMap>(); - this.customTypeMap = new ConcurrentHashMap>(); - - this.customTypeMap.put(ScalarTypePostgresHstore.KEY, new ScalarTypePostgresHstore()); this.objectMapperPresent = ClassUtil.isPresent("com.fasterxml.jackson.databind.ObjectMapper", this.getClass()); this.extraTypeFactory = new DefaultTypeFactory(config); - initialiseStandard(jsonDateTime, clobType, blobType, config.isUuidStoreAsBinary()); + initialiseStandard(jsonDateTime, config); initialiseJavaTimeTypes(jsonDateTime, config); initialiseJodaTypes(jsonDateTime); + if (isPostgres(config.getDatabasePlatform())) { + // Postgres has special DB types for JSON/JSONB + this.jsonMapJson = new ScalarTypeJsonMapPostgres.JSON(); + this.jsonMapJsonb = new ScalarTypeJsonMapPostgres.JSONB(); + } else { + this.jsonMapJson = JSON_MAP_CLOB; + this.jsonMapJsonb = JSON_MAP_CLOB; + } + if (bootupClasses != null) { initialiseCustomScalarTypes(jsonDateTime, bootupClasses, config); initialiseScalarConverters(bootupClasses); @@ -163,12 +159,8 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { } } - /** - * Lookup a special or custom scalar type by key. - */ - @Override - public ScalarType getScalarTypeFromKey(String specialTypeKey) { - return customTypeMap.get(specialTypeKey); + private boolean isPostgres(DatabasePlatform databasePlatform) { + return databasePlatform.getName().toLowerCase().startsWith("postgre"); } public boolean isKnownImmutable(Class cls) { @@ -295,6 +287,24 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { return reader; } + @Override + public ScalarType getJsonScalarType(Class type, int dbType) { + + if (type.equals(Map.class)) { + switch (dbType) { + case Types.VARCHAR : return jsonMapVarchar; + case Types.BLOB: return jsonMapBlob; + case Types.CLOB : return jsonMapClob; + case DbType.JSONB: return jsonMapJsonb; + case DbType.JSON: return jsonMapJson; + default: + return jsonMapJson; + } + } + + throw new IllegalArgumentException("Type [" + type + "] unsupported for @DbJson mapping"); + } + /** * Return a ScalarType for a given class. * @@ -370,8 +380,8 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { return value; } + @SuppressWarnings("ResultOfMethodCallIgnored") private boolean isIntegerType(String s) { - try { Integer.parseInt(s); return true; @@ -685,7 +695,14 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { * Register all the standard types supported. This is the standard JDBC types * plus some other common types such as java.util.Date and java.util.Calendar. */ - protected void initialiseStandard(JsonConfig.DateTime mode, int platformClobType, int platformBlobType, boolean binaryUUID) { + protected void initialiseStandard(JsonConfig.DateTime mode, ServerConfig config) { + + boolean binaryUUID = config.isUuidStoreAsBinary(); + DatabasePlatform databasePlatform = config.getDatabasePlatform(); + int platformClobType = databasePlatform.getClobDbType(); + int platformBlobType = databasePlatform.getBlobDbType(); + + nativeMap.put(DbType.HSTORE, new ScalarTypePostgresHstore()); ScalarType utilDateType = extraTypeFactory.createUtilDate(mode); typeMap.put(java.util.Date.class, utilDateType); diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java new file mode 100644 index 000000000..31081879f --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java @@ -0,0 +1,26 @@ +package com.avaje.ebeaninternal.server.type; + +/** + * Detects when content has been modified and as such needs to be persisted (included in an update). + */ +public class ModifyAwareFlag implements ModifyAwareOwner { + + boolean dirty; + + @Override + public boolean isMarkedDirty() { + if (!dirty) return false; + dirty = false; + return true; + } + + @Override + public void markAsModified() { + dirty = true; + } + + @Override + public void resetMarkedDirty() { + dirty = false; + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java new file mode 100644 index 000000000..1c5096146 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java @@ -0,0 +1,166 @@ +package com.avaje.ebeaninternal.server.type; + +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +/** + * Modify aware wrapper of a list. + */ +public class ModifyAwareList implements List, ModifyAwareOwner { + + final List list; + + final ModifyAwareOwner owner; + + public ModifyAwareList(List list) { + this.list = list; + this.owner = new ModifyAwareFlag(); + } + + public ModifyAwareList(ModifyAwareOwner owner, List list) { + this.list = list; + this.owner = owner; + } + + @Override + public boolean isMarkedDirty() { + return owner.isMarkedDirty(); + } + + @Override + public void markAsModified() { + owner.markAsModified(); + } + + @Override + public void resetMarkedDirty() { + owner.resetMarkedDirty(); + } + + @Override + public int size() { + return list.size(); + } + + @Override + public boolean isEmpty() { + return list.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return list.contains(o); + } + + @Override + public Iterator iterator() { + return new ModifyAwareIterator(owner, list.iterator()); + } + + @Override + public Object[] toArray() { + return list.toArray(); + } + + @Override + public T[] toArray(T[] a) { + return list.toArray(a); + } + + @Override + public boolean add(E e) { + owner.markAsModified(); + return list.add(e); + } + + @Override + public boolean remove(Object o) { + owner.markAsModified(); + return list.remove(o); + } + + @Override + public boolean containsAll(Collection c) { + return list.containsAll(c); + } + + @Override + public boolean addAll(Collection c) { + owner.markAsModified(); + return list.addAll(c); + } + + @Override + public boolean addAll(int index, Collection c) { + owner.markAsModified(); + return list.addAll(index, c); + } + + @Override + public boolean removeAll(Collection c) { + owner.markAsModified(); + return list.removeAll(c); + } + + @Override + public boolean retainAll(Collection c) { + owner.markAsModified(); + return list.retainAll(c); + } + + @Override + public void clear() { + owner.markAsModified(); + list.clear(); + } + + @Override + public E get(int index) { + return list.get(index); + } + + @Override + public E set(int index, E element) { + owner.markAsModified(); + return list.set(index, element); + } + + @Override + public void add(int index, E element) { + owner.markAsModified(); + list.add(index, element); + } + + @Override + public E remove(int index) { + owner.markAsModified(); + return list.remove(index); + } + + @Override + public int indexOf(Object o) { + return list.indexOf(o); + } + + @Override + public int lastIndexOf(Object o) { + return list.lastIndexOf(o); + } + + @Override + public ListIterator listIterator() { + return new ModifyAwareListIterator(owner, list.listIterator()); + } + + @Override + public ListIterator listIterator(int index) { + return new ModifyAwareListIterator(owner, list.listIterator(index)); + } + + @Override + public List subList(int fromIndex, int toIndex) { + return new ModifyAwareList(owner,list.subList(fromIndex, toIndex)); + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java new file mode 100644 index 000000000..2b5bdc362 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java @@ -0,0 +1,66 @@ +package com.avaje.ebeaninternal.server.type; + +import java.util.ListIterator; + +/** + * Modify aware wrapper of a ListIterator. + */ +public class ModifyAwareListIterator implements ListIterator { + + final ModifyAwareOwner owner; + + final ListIterator iterator; + + public ModifyAwareListIterator(ModifyAwareOwner owner, ListIterator iterator) { + this.owner = owner; + this.iterator = iterator; + } + + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + + @Override + public E next() { + return iterator.next(); + } + + @Override + public boolean hasPrevious() { + return iterator.hasPrevious(); + } + + @Override + public E previous() { + return iterator.previous(); + } + + @Override + public int nextIndex() { + return iterator.nextIndex(); + } + + @Override + public int previousIndex() { + return iterator.previousIndex(); + } + + @Override + public void remove() { + owner.markAsModified(); + iterator.remove(); + } + + @Override + public void set(E e) { + owner.markAsModified(); + iterator.set(e); + } + + @Override + public void add(E e) { + owner.markAsModified(); + iterator.add(e); + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java index 234c231bd..724dde7e7 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java @@ -9,18 +9,21 @@ import java.util.Set; */ public class ModifyAwareMap implements Map, ModifyAwareOwner { - /** - * Dirty flag set when the map has been modified. - */ - private boolean dirty; + final ModifyAwareOwner owner; /** * The underlying map. */ - private Map map; + final Map map; public ModifyAwareMap(Map underyling) { this.map = underyling; + this.owner = new ModifyAwareFlag(); + } + + public ModifyAwareMap(ModifyAwareOwner owner, Map underyling) { + this.owner = owner; + this.map = underyling; } public String toString() { @@ -29,12 +32,17 @@ public class ModifyAwareMap implements Map, ModifyAwareOwner { @Override public boolean isMarkedDirty() { - return dirty; + return owner.isMarkedDirty(); } @Override public void markAsModified() { - dirty = true; + owner.markAsModified(); + } + + @Override + public void resetMarkedDirty() { + owner.resetMarkedDirty(); } @Override diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java index 542278c9f..fe2d6f85a 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java @@ -7,6 +7,7 @@ public interface ModifyAwareOwner { /** * Return true if the value is considered dirty. + * Note that this resets the dirty status back to clean. */ boolean isMarkedDirty(); @@ -14,4 +15,10 @@ public interface ModifyAwareOwner { * Marks the object as modified. */ void markAsModified(); + + /** + * Reset the dirty state to clean. + */ + void resetMarkedDirty(); + } diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java b/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java index 851a45935..54965a6b7 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java @@ -168,6 +168,15 @@ public class RsetDataReader implements DataReader { return readStringLob(reader); } + @Override + public Reader getClobReader() throws SQLException { + Clob clob = rset.getClob(pos()); + if (clob == null) { + return null; + } + return clob.getCharacterStream(); + } + public String getStringClob() throws SQLException { Clob clob = rset.getClob(pos()); @@ -212,6 +221,14 @@ public class RsetDataReader implements DataReader { return getBinaryLob(in); } + public InputStream getBlobInputStream() throws SQLException { + Blob blob = rset.getBlob(pos()); + if (blob == null) { + return null; + } + return blob.getBinaryStream(); + } + protected byte[] getBinaryLob(InputStream in) throws SQLException { try { diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java new file mode 100644 index 000000000..3f80ce5c2 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java @@ -0,0 +1,214 @@ +package com.avaje.ebeaninternal.server.type; + +import com.avaje.ebean.text.TextException; +import com.avaje.ebean.text.json.EJson; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.sql.SQLException; +import java.sql.Types; +import java.util.Map; + +/** + * Type which maps Map to various DB types (Clob, Varchar, Blob) in JSON format. + */ +public abstract class ScalarTypeJsonMap extends ScalarTypeBase { + + public static class Clob extends ScalarTypeJsonMap { + + public Clob() { + super(Types.CLOB); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + Reader reader = dataReader.getClobReader(); + if (reader == null) { + return null; + } + try { + Map map = parse(reader); + reader.close(); + return map; + } catch (IOException e) { + throw new SQLException("Error reading Clob stream from DB", e); + } + } + } + + public static class Varchar extends ScalarTypeJsonMap { + + public Varchar() { + super(Types.VARCHAR); + } + } + + public static class Blob extends ScalarTypeJsonMap { + public Blob() { + super(Types.BLOB); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + InputStream is = dataReader.getBlobInputStream(); + if (is == null) { + return null; + } + try { + InputStreamReader reader = new InputStreamReader(is); + Map map = parse(reader); + reader.close(); + return map; + } catch (IOException e) { + throw new SQLException("Error reading Blob stream from DB", e); + } + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + if (value == null) { + b.setNull(Types.BLOB); + } else { + String rawJson = formatValue(value); + InputStream stream = new ByteArrayInputStream(rawJson.getBytes(StandardCharsets.UTF_8)); + b.setBlob(stream); + } + } + } + + public ScalarTypeJsonMap(int jdbcType) { + super(Map.class, false, jdbcType); + } + + /** + * Map is a mutable type. Use the isDirty() method to check for dirty state. + */ + @Override + public boolean isMutable() { + return true; + } + + /** + * Return true if the value should be considered dirty (and included in an update). + */ + @Override + public boolean isDirty(Object value) { + return !(value instanceof ModifyAwareOwner) || ((ModifyAwareOwner) value).isMarkedDirty(); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + String rawJson = dataReader.getString(); + if (rawJson == null) { + return null; + } + return parse(rawJson); + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + if (value == null) { + b.setNull(Types.VARCHAR); + } else { + String rawJson = formatValue(value); + b.setString(rawJson); + } + } + + @Override + public Object toJdbcType(Object value) { + return value; + } + + @Override + public Map toBeanType(Object value) { + return (Map) value; + } + + @Override + public String formatValue(Map v) { + try { + return EJson.write(v); + } catch (IOException e) { + throw new TextException(e); + } + } + + @Override + public Map parse(String value) { + try { + // return a modify aware map + return EJson.parseObject(value, true); + } catch (IOException e) { + throw new TextException(e); + } + } + + public Map parse(Reader reader) { + try { + // return a modify aware map + return EJson.parseObject(reader, true); + } catch (IOException e) { + throw new TextException(e); + } + } + + @Override + public Map convertFromMillis(long dateTime) { + throw new RuntimeException("Should never be called"); + } + + @Override + public boolean isDateTimeCapable() { + return false; + } + + @Override + public Map readData(DataInput dataInput) throws IOException { + if (!dataInput.readBoolean()) { + return null; + } else { + String json = dataInput.readUTF(); + return parse(json); + } + } + + @Override + public void writeData(DataOutput dataOutput, Map v) throws IOException { + if (v == null) { + dataOutput.writeBoolean(false); + } else { + dataOutput.writeBoolean(true); + String json = format(v); + dataOutput.writeUTF(json); + } + } + + @Override + public void jsonWrite(JsonGenerator ctx, String name, Map value) throws IOException { + // write the field name followed by the Map/JSON Object + if (value == null) { + ctx.writeNullField(name); + } else { + ctx.writeFieldName(name); + EJson.write(value, ctx); + } + } + + @Override + public Map jsonRead(JsonParser ctx, JsonToken event) throws IOException { + // at this point the BeanProperty has read the START_OBJECT token + // to check for a null value. Pass the START_OBJECT token through to + // the EJson parsing so that it knows the first token has been read + return EJson.parseObject(ctx, event); + } + +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java new file mode 100644 index 000000000..388826545 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java @@ -0,0 +1,55 @@ +package com.avaje.ebeaninternal.server.type; + +import com.avaje.ebean.config.dbplatform.DbType; +import org.postgresql.util.PGobject; + +import java.sql.SQLException; +import java.util.Map; + +/** + * Support for the Postgres DB types JSON and JSONB. + */ +public abstract class ScalarTypeJsonMapPostgres extends ScalarTypeJsonMap { + + private static final String POSTGRES_TYPE_JSON = "json"; + + private static final String POSTGRES_TYPE_JSONB = "jsonb"; + + final String postgresType; + + ScalarTypeJsonMapPostgres(int jdbcType, String postgresType) { + super(jdbcType); + this.postgresType = postgresType; + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + String rawJson = (value == null) ? null : formatValue(value); + + PGobject pgo = new PGobject(); + pgo.setType(postgresType); + pgo.setValue(rawJson); + b.setObject(pgo); + } + + /** + * ScalarType mapping java Map type to Postgres JSON database type. + */ + public static class JSON extends ScalarTypeJsonMapPostgres { + + public JSON() { + super(DbType.JSON, POSTGRES_TYPE_JSON); + } + } + + /** + * ScalarType mapping java Map type to Postgres JSONB database type. + */ + public static class JSONB extends ScalarTypeJsonMapPostgres { + + public JSONB() { + super(DbType.JSONB, POSTGRES_TYPE_JSONB); + } + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java index e8866c327..d91def549 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java @@ -1,18 +1,18 @@ package com.avaje.ebeaninternal.server.type; +import com.avaje.ebean.config.dbplatform.DbType; +import com.avaje.ebean.text.TextException; +import com.avaje.ebean.text.json.EJson; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; + import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.sql.SQLException; import java.util.Map; -import com.avaje.ebean.config.dbplatform.PostgresPlatform; -import com.avaje.ebean.text.json.EJson; -import com.avaje.ebean.text.TextException; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.core.JsonToken; - /** * Postgres Hstore type which maps Map to a single 'HStore column' in the DB. */ @@ -21,10 +21,8 @@ public class ScalarTypePostgresHstore extends ScalarTypeBase { public static final String KEY = "hstore"; - public static final int HSTORE_TYPE = PostgresPlatform.TYPE_HSTORE; - public ScalarTypePostgresHstore() { - super(Map.class, false, HSTORE_TYPE); + super(Map.class, false, DbType.HSTORE); } @Override diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java b/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java index efaf2b3b4..71cd5db12 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java @@ -58,7 +58,10 @@ public interface TypeManager { ScalarType createEnumScalarType(Class enumType); /** - * Find a scalarType using a custom type key. Used for Hstore and similar special types. + * Return the ScalarType used to handle JSON content. + * + * Note that type expected to be JsonNode or Map. + * */ - ScalarType getScalarTypeFromKey(String specialTypeKey); + ScalarType getJsonScalarType(Class type, int dbType); } diff --git a/src/test/java/com/avaje/ebean/json/EJsonTests.java b/src/test/java/com/avaje/ebean/json/EJsonTests.java index 434db49eb..366831bf1 100644 --- a/src/test/java/com/avaje/ebean/json/EJsonTests.java +++ b/src/test/java/com/avaje/ebean/json/EJsonTests.java @@ -1,6 +1,7 @@ package com.avaje.ebean.json; import com.avaje.ebean.text.json.EJson; +import com.avaje.ebeaninternal.server.type.ModifyAwareMap; import com.fasterxml.jackson.core.JsonFactory; import com.fasterxml.jackson.core.JsonParser; import org.junit.Assert; @@ -203,4 +204,46 @@ public class EJsonTests { } + @Test + public void test_map_nested_modifyAware() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + + Assert.assertFalse(map.isMarkedDirty()); + Assert.assertEquals(4, map.size()); + + map.put("name", "jim"); + Assert.assertTrue(map.isMarkedDirty()); + + } + + @SuppressWarnings("unchecked") + @Test + public void test_map_nested_modifyAwareNestedList() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + Assert.assertFalse(map.isMarkedDirty()); + + List nums = (List) map.get("nums"); + nums.add(4); + Assert.assertTrue(map.isMarkedDirty()); + + } + + @SuppressWarnings("unchecked") + @Test + public void test_map_nested_modifyAwareNestedObject() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + Assert.assertFalse(map.isMarkedDirty()); + + Map org = (Map) map.get("org"); + org.put("extra","foo"); + Assert.assertTrue(map.isMarkedDirty()); + + } + } diff --git a/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java new file mode 100644 index 000000000..3c194c83c --- /dev/null +++ b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java @@ -0,0 +1,228 @@ +package com.avaje.ebeaninternal.server.type; + +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + + +public class ModifyAwareListTest { + + private ModifyAwareList createList() { + ArrayList list = new ArrayList(); + list.addAll(Arrays.asList("A","B","C","D","E")); + return new ModifyAwareList(list); + } + private ModifyAwareList createEmptyList() { + return new ModifyAwareList(new ArrayList()); + } + + @Test + public void testSize() throws Exception { + + assertEquals(5, createList().size()); + } + + @Test + public void testIsEmpty() throws Exception { + + assertFalse(createList().isEmpty()); + assertTrue(createEmptyList().isEmpty()); + } + + @Test + public void testContains() throws Exception { + + assertTrue(createList().contains("B")); + assertFalse(createList().contains("Z")); + } + + @Test + public void testIterator() throws Exception { + + ModifyAwareList list = createList(); + Iterator iterator = list.iterator(); + assertTrue(iterator.hasNext()); + assertEquals("A", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testToArray() throws Exception { + + Object[] objects = createList().toArray(); + assertEquals(5, objects.length); + assertEquals("A", objects[0]); + assertEquals("E", objects[4]); + } + + @Test + public void testToArray1() throws Exception { + + String[] objects = createList().toArray(new String[5]); + assertEquals(5, objects.length); + assertEquals("A", objects[0]); + assertEquals("E", objects[4]); + } + + @Test + public void testAdd() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.add("F"); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testRemove() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.remove("A"); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testContainsAll() throws Exception { + + ModifyAwareList list = createList(); + + assertTrue(list.containsAll(Arrays.asList("A", "B"))); + assertFalse(list.containsAll(Arrays.asList("A", "B", "Z"))); + } + + @Test + public void testAddAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.addAll(Arrays.asList("F", "G"))); + assertTrue(list.isMarkedDirty()); + } + + + @Test + public void testRemoveAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.removeAll(Arrays.asList("A", "G"))); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testRetainAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.retainAll(Arrays.asList("A", "B"))); + assertTrue(list.isMarkedDirty()); + assertEquals(2, list.size()); + } + + @Test + public void testClear() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.clear(); + assertTrue(list.isMarkedDirty()); + assertEquals(0, list.size()); + + } + + @Test + public void testGet() throws Exception { + + ModifyAwareList list = createList(); + + assertEquals("A", list.get(0)); + assertEquals("B", list.get(1)); + assertEquals("E", list.get(4)); + } + + @Test + public void testSet() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.set(0, "Z"); + assertTrue(list.isMarkedDirty()); + assertEquals(5, list.size()); + } + + @Test + public void testIndexOf() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertEquals(2, list.indexOf("C")); + assertEquals(-1, list.indexOf("Z")); + assertFalse(list.isMarkedDirty()); + } + + @Test + public void testLastIndexOf() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertEquals(2, list.lastIndexOf("C")); + assertEquals(-1, list.lastIndexOf("Z")); + assertFalse(list.isMarkedDirty()); + } + + @Test + public void testListIterator() throws Exception { + + ModifyAwareList list = createList(); + ListIterator iterator = list.listIterator(); + assertTrue(iterator.hasNext()); + assertEquals("A", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testListIterator1() throws Exception { + + ModifyAwareList list = createList(); + ListIterator iterator = list.listIterator(2); + assertTrue(iterator.hasNext()); + assertEquals("C", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + + } + + @Test + public void testSubList() throws Exception { + + ModifyAwareList list = createList(); + List sub = list.subList(1, 3); + assertEquals("B", sub.get(0)); + assertEquals("C", sub.get(1)); + + assertFalse(list.isMarkedDirty()); + + sub.remove("C"); + assertTrue(list.isMarkedDirty()); + } +} \ No newline at end of file diff --git a/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java new file mode 100644 index 000000000..1f9a09b12 --- /dev/null +++ b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java @@ -0,0 +1,180 @@ +package com.avaje.ebeaninternal.server.type; + +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + +public class ModifyAwareMapTest { + + private ModifyAwareMap createMap() { + LinkedHashMap map = new LinkedHashMap(); + map.put("A", "one"); + map.put("B", "two"); + map.put("C", "three"); + map.put("D", "four"); + map.put("E", "five"); + return new ModifyAwareMap(map); + } + + private ModifyAwareMap createEmptyMap() { + LinkedHashMap map = new LinkedHashMap(); + return new ModifyAwareMap(map); + } + + @Test + public void testToString() throws Exception { + + ModifyAwareMap map = createMap(); + assertEquals(map.map.toString(), map.toString()); + } + + @Test + public void testIsMarkedDirty() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.put("A", "change"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testMarkAsModified() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.markAsModified(); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testSize() throws Exception { + + ModifyAwareMap map = createMap(); + assertEquals(5, map.size()); + } + + @Test + public void testIsEmpty() throws Exception { + + assertFalse(createMap().isEmpty()); + assertTrue(createEmptyMap().isEmpty()); + } + + @Test + public void testContainsKey() throws Exception { + + ModifyAwareMap map = createMap(); + assertTrue(map.containsKey("A")); + assertFalse(map.containsKey("Z")); + } + + @Test + public void testContainsValue() throws Exception { + ModifyAwareMap map = createMap(); + assertTrue(map.containsValue("one")); + assertFalse(map.containsValue("junk")); + } + + @Test + public void testGet() throws Exception { + + ModifyAwareMap map = createMap(); + + assertEquals("two", map.get("B")); + assertNull(map.get("Z")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testPut() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.put("A", "mod"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testRemove() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.remove("A"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testPutAllWithEmpty() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Map other = new HashMap(); + map.putAll(other); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testPutAll() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Map other = new HashMap(); + other.put("A", "one"); + map.putAll(other); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testClear() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.clear(); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testKeySet() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Set keys = map.keySet(); + assertEquals(map.size(), keys.size()); + assertTrue(keys.contains("A")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testValues() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Collection values = map.values(); + assertEquals(map.size(), values.size()); + assertTrue(values.contains("one")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testEntrySet() throws Exception { + + ModifyAwareMap map = createMap(); + Set> entries = map.entrySet(); + + assertFalse(map.isMarkedDirty()); + + assertEquals(map.size(), entries.size()); + assertFalse(map.isMarkedDirty()); + } +} \ No newline at end of file diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java b/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java new file mode 100644 index 000000000..4681860c5 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java @@ -0,0 +1,67 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMap; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.IOException; +import java.util.LinkedHashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapBasic extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + //String s1 = "{\"docId\":19,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMap bean = new EBasicJsonMap(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMap bean1 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + + // content changes detected - dirty state so included in update + Map content1 = bean1.getContent(); + content1.put("additional", "newValue"); + content1.put("docId", 99L); + bean1.setName("two"); + Ebean.save(bean1); + + EBasicJsonMap bean2 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + // name changed and docId changed + assertEquals("two", bean2.getName()); + assertEquals(99L, bean2.getContent().get("docId")); + assertEquals("newValue", bean2.getContent().get("additional")); + + content1.put("additional", "modValue"); + bean1.setName("three"); + bean1.setContent(content1); + Ebean.save(bean1); + + EBasicJsonMap bean3 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + assertEquals("three", bean3.getName()); + assertEquals(99L, bean3.getContent().get("docId")); + assertEquals("modValue", bean3.getContent().get("additional")); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java b/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java new file mode 100644 index 000000000..6b081a5ea --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMapBlob; +import com.avaje.tests.model.json.EBasicJsonMapVarchar; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapBlob extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapBlob bean = new EBasicJsonMapBlob(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapBlob bean1 = Ebean.find(EBasicJsonMapBlob.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java b/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java new file mode 100644 index 000000000..f3b250cc6 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMapJsonB; +import com.avaje.tests.model.json.EBasicJsonMapJsonB; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapJsonB extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapJsonB bean = new EBasicJsonMapJsonB(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapJsonB bean1 = Ebean.find(EBasicJsonMapJsonB.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java b/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java new file mode 100644 index 000000000..b8ae74021 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMap; +import com.avaje.tests.model.json.EBasicJsonMapVarchar; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapVarchar extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapVarchar bean = new EBasicJsonMapVarchar(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapVarchar bean1 = Ebean.find(EBasicJsonMapVarchar.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java new file mode 100644 index 000000000..6a68998e7 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java @@ -0,0 +1,55 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMap { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java new file mode 100644 index 000000000..b01873056 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java @@ -0,0 +1,56 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; +import com.avaje.ebean.annotation.DbJsonType; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapBlob { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson(storage = DbJsonType.BLOB) + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java new file mode 100644 index 000000000..c8ece036f --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java @@ -0,0 +1,55 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJsonB; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapJsonB { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJsonB + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java new file mode 100644 index 000000000..648574201 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java @@ -0,0 +1,56 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; +import com.avaje.ebean.annotation.DbJsonType; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapVarchar { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson(storage = DbJsonType.VARCHAR)//, length = 2200) + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +}
@@ -370,8 +380,8 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { return value; } + @SuppressWarnings("ResultOfMethodCallIgnored") private boolean isIntegerType(String s) { - try { Integer.parseInt(s); return true; @@ -685,7 +695,14 @@ public final class DefaultTypeManager implements TypeManager, KnownImmutable { * Register all the standard types supported. This is the standard JDBC types * plus some other common types such as java.util.Date and java.util.Calendar. */ - protected void initialiseStandard(JsonConfig.DateTime mode, int platformClobType, int platformBlobType, boolean binaryUUID) { + protected void initialiseStandard(JsonConfig.DateTime mode, ServerConfig config) { + + boolean binaryUUID = config.isUuidStoreAsBinary(); + DatabasePlatform databasePlatform = config.getDatabasePlatform(); + int platformClobType = databasePlatform.getClobDbType(); + int platformBlobType = databasePlatform.getBlobDbType(); + + nativeMap.put(DbType.HSTORE, new ScalarTypePostgresHstore()); ScalarType utilDateType = extraTypeFactory.createUtilDate(mode); typeMap.put(java.util.Date.class, utilDateType); diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java new file mode 100644 index 000000000..31081879f --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareFlag.java @@ -0,0 +1,26 @@ +package com.avaje.ebeaninternal.server.type; + +/** + * Detects when content has been modified and as such needs to be persisted (included in an update). + */ +public class ModifyAwareFlag implements ModifyAwareOwner { + + boolean dirty; + + @Override + public boolean isMarkedDirty() { + if (!dirty) return false; + dirty = false; + return true; + } + + @Override + public void markAsModified() { + dirty = true; + } + + @Override + public void resetMarkedDirty() { + dirty = false; + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java new file mode 100644 index 000000000..1c5096146 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareList.java @@ -0,0 +1,166 @@ +package com.avaje.ebeaninternal.server.type; + +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +/** + * Modify aware wrapper of a list. + */ +public class ModifyAwareList implements List, ModifyAwareOwner { + + final List list; + + final ModifyAwareOwner owner; + + public ModifyAwareList(List list) { + this.list = list; + this.owner = new ModifyAwareFlag(); + } + + public ModifyAwareList(ModifyAwareOwner owner, List list) { + this.list = list; + this.owner = owner; + } + + @Override + public boolean isMarkedDirty() { + return owner.isMarkedDirty(); + } + + @Override + public void markAsModified() { + owner.markAsModified(); + } + + @Override + public void resetMarkedDirty() { + owner.resetMarkedDirty(); + } + + @Override + public int size() { + return list.size(); + } + + @Override + public boolean isEmpty() { + return list.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return list.contains(o); + } + + @Override + public Iterator iterator() { + return new ModifyAwareIterator(owner, list.iterator()); + } + + @Override + public Object[] toArray() { + return list.toArray(); + } + + @Override + public T[] toArray(T[] a) { + return list.toArray(a); + } + + @Override + public boolean add(E e) { + owner.markAsModified(); + return list.add(e); + } + + @Override + public boolean remove(Object o) { + owner.markAsModified(); + return list.remove(o); + } + + @Override + public boolean containsAll(Collection c) { + return list.containsAll(c); + } + + @Override + public boolean addAll(Collection c) { + owner.markAsModified(); + return list.addAll(c); + } + + @Override + public boolean addAll(int index, Collection c) { + owner.markAsModified(); + return list.addAll(index, c); + } + + @Override + public boolean removeAll(Collection c) { + owner.markAsModified(); + return list.removeAll(c); + } + + @Override + public boolean retainAll(Collection c) { + owner.markAsModified(); + return list.retainAll(c); + } + + @Override + public void clear() { + owner.markAsModified(); + list.clear(); + } + + @Override + public E get(int index) { + return list.get(index); + } + + @Override + public E set(int index, E element) { + owner.markAsModified(); + return list.set(index, element); + } + + @Override + public void add(int index, E element) { + owner.markAsModified(); + list.add(index, element); + } + + @Override + public E remove(int index) { + owner.markAsModified(); + return list.remove(index); + } + + @Override + public int indexOf(Object o) { + return list.indexOf(o); + } + + @Override + public int lastIndexOf(Object o) { + return list.lastIndexOf(o); + } + + @Override + public ListIterator listIterator() { + return new ModifyAwareListIterator(owner, list.listIterator()); + } + + @Override + public ListIterator listIterator(int index) { + return new ModifyAwareListIterator(owner, list.listIterator(index)); + } + + @Override + public List subList(int fromIndex, int toIndex) { + return new ModifyAwareList(owner,list.subList(fromIndex, toIndex)); + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java new file mode 100644 index 000000000..2b5bdc362 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareListIterator.java @@ -0,0 +1,66 @@ +package com.avaje.ebeaninternal.server.type; + +import java.util.ListIterator; + +/** + * Modify aware wrapper of a ListIterator. + */ +public class ModifyAwareListIterator implements ListIterator { + + final ModifyAwareOwner owner; + + final ListIterator iterator; + + public ModifyAwareListIterator(ModifyAwareOwner owner, ListIterator iterator) { + this.owner = owner; + this.iterator = iterator; + } + + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + + @Override + public E next() { + return iterator.next(); + } + + @Override + public boolean hasPrevious() { + return iterator.hasPrevious(); + } + + @Override + public E previous() { + return iterator.previous(); + } + + @Override + public int nextIndex() { + return iterator.nextIndex(); + } + + @Override + public int previousIndex() { + return iterator.previousIndex(); + } + + @Override + public void remove() { + owner.markAsModified(); + iterator.remove(); + } + + @Override + public void set(E e) { + owner.markAsModified(); + iterator.set(e); + } + + @Override + public void add(E e) { + owner.markAsModified(); + iterator.add(e); + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java index 234c231bd..724dde7e7 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareMap.java @@ -9,18 +9,21 @@ import java.util.Set; */ public class ModifyAwareMap implements Map, ModifyAwareOwner { - /** - * Dirty flag set when the map has been modified. - */ - private boolean dirty; + final ModifyAwareOwner owner; /** * The underlying map. */ - private Map map; + final Map map; public ModifyAwareMap(Map underyling) { this.map = underyling; + this.owner = new ModifyAwareFlag(); + } + + public ModifyAwareMap(ModifyAwareOwner owner, Map underyling) { + this.owner = owner; + this.map = underyling; } public String toString() { @@ -29,12 +32,17 @@ public class ModifyAwareMap implements Map, ModifyAwareOwner { @Override public boolean isMarkedDirty() { - return dirty; + return owner.isMarkedDirty(); } @Override public void markAsModified() { - dirty = true; + owner.markAsModified(); + } + + @Override + public void resetMarkedDirty() { + owner.resetMarkedDirty(); } @Override diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java index 542278c9f..fe2d6f85a 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ModifyAwareOwner.java @@ -7,6 +7,7 @@ public interface ModifyAwareOwner { /** * Return true if the value is considered dirty. + * Note that this resets the dirty status back to clean. */ boolean isMarkedDirty(); @@ -14,4 +15,10 @@ public interface ModifyAwareOwner { * Marks the object as modified. */ void markAsModified(); + + /** + * Reset the dirty state to clean. + */ + void resetMarkedDirty(); + } diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java b/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java index 851a45935..54965a6b7 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/RsetDataReader.java @@ -168,6 +168,15 @@ public class RsetDataReader implements DataReader { return readStringLob(reader); } + @Override + public Reader getClobReader() throws SQLException { + Clob clob = rset.getClob(pos()); + if (clob == null) { + return null; + } + return clob.getCharacterStream(); + } + public String getStringClob() throws SQLException { Clob clob = rset.getClob(pos()); @@ -212,6 +221,14 @@ public class RsetDataReader implements DataReader { return getBinaryLob(in); } + public InputStream getBlobInputStream() throws SQLException { + Blob blob = rset.getBlob(pos()); + if (blob == null) { + return null; + } + return blob.getBinaryStream(); + } + protected byte[] getBinaryLob(InputStream in) throws SQLException { try { diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java new file mode 100644 index 000000000..3f80ce5c2 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMap.java @@ -0,0 +1,214 @@ +package com.avaje.ebeaninternal.server.type; + +import com.avaje.ebean.text.TextException; +import com.avaje.ebean.text.json.EJson; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.sql.SQLException; +import java.sql.Types; +import java.util.Map; + +/** + * Type which maps Map to various DB types (Clob, Varchar, Blob) in JSON format. + */ +public abstract class ScalarTypeJsonMap extends ScalarTypeBase { + + public static class Clob extends ScalarTypeJsonMap { + + public Clob() { + super(Types.CLOB); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + Reader reader = dataReader.getClobReader(); + if (reader == null) { + return null; + } + try { + Map map = parse(reader); + reader.close(); + return map; + } catch (IOException e) { + throw new SQLException("Error reading Clob stream from DB", e); + } + } + } + + public static class Varchar extends ScalarTypeJsonMap { + + public Varchar() { + super(Types.VARCHAR); + } + } + + public static class Blob extends ScalarTypeJsonMap { + public Blob() { + super(Types.BLOB); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + InputStream is = dataReader.getBlobInputStream(); + if (is == null) { + return null; + } + try { + InputStreamReader reader = new InputStreamReader(is); + Map map = parse(reader); + reader.close(); + return map; + } catch (IOException e) { + throw new SQLException("Error reading Blob stream from DB", e); + } + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + if (value == null) { + b.setNull(Types.BLOB); + } else { + String rawJson = formatValue(value); + InputStream stream = new ByteArrayInputStream(rawJson.getBytes(StandardCharsets.UTF_8)); + b.setBlob(stream); + } + } + } + + public ScalarTypeJsonMap(int jdbcType) { + super(Map.class, false, jdbcType); + } + + /** + * Map is a mutable type. Use the isDirty() method to check for dirty state. + */ + @Override + public boolean isMutable() { + return true; + } + + /** + * Return true if the value should be considered dirty (and included in an update). + */ + @Override + public boolean isDirty(Object value) { + return !(value instanceof ModifyAwareOwner) || ((ModifyAwareOwner) value).isMarkedDirty(); + } + + @Override + public Map read(DataReader dataReader) throws SQLException { + + String rawJson = dataReader.getString(); + if (rawJson == null) { + return null; + } + return parse(rawJson); + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + if (value == null) { + b.setNull(Types.VARCHAR); + } else { + String rawJson = formatValue(value); + b.setString(rawJson); + } + } + + @Override + public Object toJdbcType(Object value) { + return value; + } + + @Override + public Map toBeanType(Object value) { + return (Map) value; + } + + @Override + public String formatValue(Map v) { + try { + return EJson.write(v); + } catch (IOException e) { + throw new TextException(e); + } + } + + @Override + public Map parse(String value) { + try { + // return a modify aware map + return EJson.parseObject(value, true); + } catch (IOException e) { + throw new TextException(e); + } + } + + public Map parse(Reader reader) { + try { + // return a modify aware map + return EJson.parseObject(reader, true); + } catch (IOException e) { + throw new TextException(e); + } + } + + @Override + public Map convertFromMillis(long dateTime) { + throw new RuntimeException("Should never be called"); + } + + @Override + public boolean isDateTimeCapable() { + return false; + } + + @Override + public Map readData(DataInput dataInput) throws IOException { + if (!dataInput.readBoolean()) { + return null; + } else { + String json = dataInput.readUTF(); + return parse(json); + } + } + + @Override + public void writeData(DataOutput dataOutput, Map v) throws IOException { + if (v == null) { + dataOutput.writeBoolean(false); + } else { + dataOutput.writeBoolean(true); + String json = format(v); + dataOutput.writeUTF(json); + } + } + + @Override + public void jsonWrite(JsonGenerator ctx, String name, Map value) throws IOException { + // write the field name followed by the Map/JSON Object + if (value == null) { + ctx.writeNullField(name); + } else { + ctx.writeFieldName(name); + EJson.write(value, ctx); + } + } + + @Override + public Map jsonRead(JsonParser ctx, JsonToken event) throws IOException { + // at this point the BeanProperty has read the START_OBJECT token + // to check for a null value. Pass the START_OBJECT token through to + // the EJson parsing so that it knows the first token has been read + return EJson.parseObject(ctx, event); + } + +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java new file mode 100644 index 000000000..388826545 --- /dev/null +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypeJsonMapPostgres.java @@ -0,0 +1,55 @@ +package com.avaje.ebeaninternal.server.type; + +import com.avaje.ebean.config.dbplatform.DbType; +import org.postgresql.util.PGobject; + +import java.sql.SQLException; +import java.util.Map; + +/** + * Support for the Postgres DB types JSON and JSONB. + */ +public abstract class ScalarTypeJsonMapPostgres extends ScalarTypeJsonMap { + + private static final String POSTGRES_TYPE_JSON = "json"; + + private static final String POSTGRES_TYPE_JSONB = "jsonb"; + + final String postgresType; + + ScalarTypeJsonMapPostgres(int jdbcType, String postgresType) { + super(jdbcType); + this.postgresType = postgresType; + } + + @Override + public void bind(DataBind b, Map value) throws SQLException { + + String rawJson = (value == null) ? null : formatValue(value); + + PGobject pgo = new PGobject(); + pgo.setType(postgresType); + pgo.setValue(rawJson); + b.setObject(pgo); + } + + /** + * ScalarType mapping java Map type to Postgres JSON database type. + */ + public static class JSON extends ScalarTypeJsonMapPostgres { + + public JSON() { + super(DbType.JSON, POSTGRES_TYPE_JSON); + } + } + + /** + * ScalarType mapping java Map type to Postgres JSONB database type. + */ + public static class JSONB extends ScalarTypeJsonMapPostgres { + + public JSONB() { + super(DbType.JSONB, POSTGRES_TYPE_JSONB); + } + } +} diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java index e8866c327..d91def549 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/ScalarTypePostgresHstore.java @@ -1,18 +1,18 @@ package com.avaje.ebeaninternal.server.type; +import com.avaje.ebean.config.dbplatform.DbType; +import com.avaje.ebean.text.TextException; +import com.avaje.ebean.text.json.EJson; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; + import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.sql.SQLException; import java.util.Map; -import com.avaje.ebean.config.dbplatform.PostgresPlatform; -import com.avaje.ebean.text.json.EJson; -import com.avaje.ebean.text.TextException; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.core.JsonToken; - /** * Postgres Hstore type which maps Map to a single 'HStore column' in the DB. */ @@ -21,10 +21,8 @@ public class ScalarTypePostgresHstore extends ScalarTypeBase { public static final String KEY = "hstore"; - public static final int HSTORE_TYPE = PostgresPlatform.TYPE_HSTORE; - public ScalarTypePostgresHstore() { - super(Map.class, false, HSTORE_TYPE); + super(Map.class, false, DbType.HSTORE); } @Override diff --git a/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java b/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java index efaf2b3b4..71cd5db12 100644 --- a/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java +++ b/src/main/java/com/avaje/ebeaninternal/server/type/TypeManager.java @@ -58,7 +58,10 @@ public interface TypeManager { ScalarType createEnumScalarType(Class enumType); /** - * Find a scalarType using a custom type key. Used for Hstore and similar special types. + * Return the ScalarType used to handle JSON content. + * + * Note that type expected to be JsonNode or Map. + * */ - ScalarType getScalarTypeFromKey(String specialTypeKey); + ScalarType getJsonScalarType(Class type, int dbType); } diff --git a/src/test/java/com/avaje/ebean/json/EJsonTests.java b/src/test/java/com/avaje/ebean/json/EJsonTests.java index 434db49eb..366831bf1 100644 --- a/src/test/java/com/avaje/ebean/json/EJsonTests.java +++ b/src/test/java/com/avaje/ebean/json/EJsonTests.java @@ -1,6 +1,7 @@ package com.avaje.ebean.json; import com.avaje.ebean.text.json.EJson; +import com.avaje.ebeaninternal.server.type.ModifyAwareMap; import com.fasterxml.jackson.core.JsonFactory; import com.fasterxml.jackson.core.JsonParser; import org.junit.Assert; @@ -203,4 +204,46 @@ public class EJsonTests { } + @Test + public void test_map_nested_modifyAware() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + + Assert.assertFalse(map.isMarkedDirty()); + Assert.assertEquals(4, map.size()); + + map.put("name", "jim"); + Assert.assertTrue(map.isMarkedDirty()); + + } + + @SuppressWarnings("unchecked") + @Test + public void test_map_nested_modifyAwareNestedList() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + Assert.assertFalse(map.isMarkedDirty()); + + List nums = (List) map.get("nums"); + nums.add(4); + Assert.assertTrue(map.isMarkedDirty()); + + } + + @SuppressWarnings("unchecked") + @Test + public void test_map_nested_modifyAwareNestedObject() throws IOException { + + String jsonInput = "{\"name\":\"rob\",\"age\":12,\"org\":{\"name\":\"superorg\",\"rating\":4},\"nums\":[1,2,3]}"; + ModifyAwareMap map = (ModifyAwareMap) EJson.parseObject(jsonInput, true); + Assert.assertFalse(map.isMarkedDirty()); + + Map org = (Map) map.get("org"); + org.put("extra","foo"); + Assert.assertTrue(map.isMarkedDirty()); + + } + } diff --git a/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java new file mode 100644 index 000000000..3c194c83c --- /dev/null +++ b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareListTest.java @@ -0,0 +1,228 @@ +package com.avaje.ebeaninternal.server.type; + +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + + +public class ModifyAwareListTest { + + private ModifyAwareList createList() { + ArrayList list = new ArrayList(); + list.addAll(Arrays.asList("A","B","C","D","E")); + return new ModifyAwareList(list); + } + private ModifyAwareList createEmptyList() { + return new ModifyAwareList(new ArrayList()); + } + + @Test + public void testSize() throws Exception { + + assertEquals(5, createList().size()); + } + + @Test + public void testIsEmpty() throws Exception { + + assertFalse(createList().isEmpty()); + assertTrue(createEmptyList().isEmpty()); + } + + @Test + public void testContains() throws Exception { + + assertTrue(createList().contains("B")); + assertFalse(createList().contains("Z")); + } + + @Test + public void testIterator() throws Exception { + + ModifyAwareList list = createList(); + Iterator iterator = list.iterator(); + assertTrue(iterator.hasNext()); + assertEquals("A", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testToArray() throws Exception { + + Object[] objects = createList().toArray(); + assertEquals(5, objects.length); + assertEquals("A", objects[0]); + assertEquals("E", objects[4]); + } + + @Test + public void testToArray1() throws Exception { + + String[] objects = createList().toArray(new String[5]); + assertEquals(5, objects.length); + assertEquals("A", objects[0]); + assertEquals("E", objects[4]); + } + + @Test + public void testAdd() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.add("F"); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testRemove() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.remove("A"); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testContainsAll() throws Exception { + + ModifyAwareList list = createList(); + + assertTrue(list.containsAll(Arrays.asList("A", "B"))); + assertFalse(list.containsAll(Arrays.asList("A", "B", "Z"))); + } + + @Test + public void testAddAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.addAll(Arrays.asList("F", "G"))); + assertTrue(list.isMarkedDirty()); + } + + + @Test + public void testRemoveAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.removeAll(Arrays.asList("A", "G"))); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testRetainAll() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertTrue(list.retainAll(Arrays.asList("A", "B"))); + assertTrue(list.isMarkedDirty()); + assertEquals(2, list.size()); + } + + @Test + public void testClear() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.clear(); + assertTrue(list.isMarkedDirty()); + assertEquals(0, list.size()); + + } + + @Test + public void testGet() throws Exception { + + ModifyAwareList list = createList(); + + assertEquals("A", list.get(0)); + assertEquals("B", list.get(1)); + assertEquals("E", list.get(4)); + } + + @Test + public void testSet() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + list.set(0, "Z"); + assertTrue(list.isMarkedDirty()); + assertEquals(5, list.size()); + } + + @Test + public void testIndexOf() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertEquals(2, list.indexOf("C")); + assertEquals(-1, list.indexOf("Z")); + assertFalse(list.isMarkedDirty()); + } + + @Test + public void testLastIndexOf() throws Exception { + + ModifyAwareList list = createList(); + assertFalse(list.isMarkedDirty()); + + assertEquals(2, list.lastIndexOf("C")); + assertEquals(-1, list.lastIndexOf("Z")); + assertFalse(list.isMarkedDirty()); + } + + @Test + public void testListIterator() throws Exception { + + ModifyAwareList list = createList(); + ListIterator iterator = list.listIterator(); + assertTrue(iterator.hasNext()); + assertEquals("A", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + } + + @Test + public void testListIterator1() throws Exception { + + ModifyAwareList list = createList(); + ListIterator iterator = list.listIterator(2); + assertTrue(iterator.hasNext()); + assertEquals("C", iterator.next()); + assertFalse(list.isMarkedDirty()); + + iterator.remove(); + assertTrue(list.isMarkedDirty()); + + } + + @Test + public void testSubList() throws Exception { + + ModifyAwareList list = createList(); + List sub = list.subList(1, 3); + assertEquals("B", sub.get(0)); + assertEquals("C", sub.get(1)); + + assertFalse(list.isMarkedDirty()); + + sub.remove("C"); + assertTrue(list.isMarkedDirty()); + } +} \ No newline at end of file diff --git a/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java new file mode 100644 index 000000000..1f9a09b12 --- /dev/null +++ b/src/test/java/com/avaje/ebeaninternal/server/type/ModifyAwareMapTest.java @@ -0,0 +1,180 @@ +package com.avaje.ebeaninternal.server.type; + +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + +public class ModifyAwareMapTest { + + private ModifyAwareMap createMap() { + LinkedHashMap map = new LinkedHashMap(); + map.put("A", "one"); + map.put("B", "two"); + map.put("C", "three"); + map.put("D", "four"); + map.put("E", "five"); + return new ModifyAwareMap(map); + } + + private ModifyAwareMap createEmptyMap() { + LinkedHashMap map = new LinkedHashMap(); + return new ModifyAwareMap(map); + } + + @Test + public void testToString() throws Exception { + + ModifyAwareMap map = createMap(); + assertEquals(map.map.toString(), map.toString()); + } + + @Test + public void testIsMarkedDirty() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.put("A", "change"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testMarkAsModified() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.markAsModified(); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testSize() throws Exception { + + ModifyAwareMap map = createMap(); + assertEquals(5, map.size()); + } + + @Test + public void testIsEmpty() throws Exception { + + assertFalse(createMap().isEmpty()); + assertTrue(createEmptyMap().isEmpty()); + } + + @Test + public void testContainsKey() throws Exception { + + ModifyAwareMap map = createMap(); + assertTrue(map.containsKey("A")); + assertFalse(map.containsKey("Z")); + } + + @Test + public void testContainsValue() throws Exception { + ModifyAwareMap map = createMap(); + assertTrue(map.containsValue("one")); + assertFalse(map.containsValue("junk")); + } + + @Test + public void testGet() throws Exception { + + ModifyAwareMap map = createMap(); + + assertEquals("two", map.get("B")); + assertNull(map.get("Z")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testPut() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.put("A", "mod"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testRemove() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.remove("A"); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testPutAllWithEmpty() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Map other = new HashMap(); + map.putAll(other); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testPutAll() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Map other = new HashMap(); + other.put("A", "one"); + map.putAll(other); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testClear() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + map.clear(); + assertTrue(map.isMarkedDirty()); + } + + @Test + public void testKeySet() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Set keys = map.keySet(); + assertEquals(map.size(), keys.size()); + assertTrue(keys.contains("A")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testValues() throws Exception { + + ModifyAwareMap map = createMap(); + assertFalse(map.isMarkedDirty()); + + Collection values = map.values(); + assertEquals(map.size(), values.size()); + assertTrue(values.contains("one")); + assertFalse(map.isMarkedDirty()); + } + + @Test + public void testEntrySet() throws Exception { + + ModifyAwareMap map = createMap(); + Set> entries = map.entrySet(); + + assertFalse(map.isMarkedDirty()); + + assertEquals(map.size(), entries.size()); + assertFalse(map.isMarkedDirty()); + } +} \ No newline at end of file diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java b/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java new file mode 100644 index 000000000..4681860c5 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapBasic.java @@ -0,0 +1,67 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMap; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.IOException; +import java.util.LinkedHashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapBasic extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + //String s1 = "{\"docId\":19,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMap bean = new EBasicJsonMap(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMap bean1 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + + // content changes detected - dirty state so included in update + Map content1 = bean1.getContent(); + content1.put("additional", "newValue"); + content1.put("docId", 99L); + bean1.setName("two"); + Ebean.save(bean1); + + EBasicJsonMap bean2 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + // name changed and docId changed + assertEquals("two", bean2.getName()); + assertEquals(99L, bean2.getContent().get("docId")); + assertEquals("newValue", bean2.getContent().get("additional")); + + content1.put("additional", "modValue"); + bean1.setName("three"); + bean1.setContent(content1); + Ebean.save(bean1); + + EBasicJsonMap bean3 = Ebean.find(EBasicJsonMap.class, bean.getId()); + + assertEquals("three", bean3.getName()); + assertEquals(99L, bean3.getContent().get("docId")); + assertEquals("modValue", bean3.getContent().get("additional")); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java b/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java new file mode 100644 index 000000000..6b081a5ea --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapBlob.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMapBlob; +import com.avaje.tests.model.json.EBasicJsonMapVarchar; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapBlob extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapBlob bean = new EBasicJsonMapBlob(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapBlob bean1 = Ebean.find(EBasicJsonMapBlob.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java b/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java new file mode 100644 index 000000000..f3b250cc6 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapJsonB.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMapJsonB; +import com.avaje.tests.model.json.EBasicJsonMapJsonB; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapJsonB extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapJsonB bean = new EBasicJsonMapJsonB(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapJsonB bean1 = Ebean.find(EBasicJsonMapJsonB.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java b/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java new file mode 100644 index 000000000..b8ae74021 --- /dev/null +++ b/src/test/java/com/avaje/tests/json/TestJsonMapVarchar.java @@ -0,0 +1,40 @@ +package com.avaje.tests.json; + +import com.avaje.ebean.BaseTestCase; +import com.avaje.ebean.Ebean; +import com.avaje.ebean.text.json.EJson; +import com.avaje.tests.model.json.EBasicJsonMap; +import com.avaje.tests.model.json.EBasicJsonMapVarchar; +import org.junit.Test; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class TestJsonMapVarchar extends BaseTestCase { + + @Test + public void testInsertUpdateDelete() throws IOException { + + String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}"; + + Map content = EJson.parseObject(s0); + + EBasicJsonMapVarchar bean = new EBasicJsonMapVarchar(); + bean.setName("one"); + bean.setContent(content); + + Ebean.save(bean); + + EBasicJsonMapVarchar bean1 = Ebean.find(EBasicJsonMapVarchar.class, bean.getId()); + + assertEquals(bean.getId(), bean1.getId()); + assertEquals(bean.getName(), bean1.getName()); + assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType")); + assertEquals(18L, bean1.getContent().get("docId")); + + bean1.setName("just change name"); + Ebean.save(bean1); + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java new file mode 100644 index 000000000..6a68998e7 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMap.java @@ -0,0 +1,55 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMap { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java new file mode 100644 index 000000000..b01873056 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapBlob.java @@ -0,0 +1,56 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; +import com.avaje.ebean.annotation.DbJsonType; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapBlob { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson(storage = DbJsonType.BLOB) + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java new file mode 100644 index 000000000..c8ece036f --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapJsonB.java @@ -0,0 +1,55 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJsonB; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapJsonB { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJsonB + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +} diff --git a/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java new file mode 100644 index 000000000..648574201 --- /dev/null +++ b/src/test/java/com/avaje/tests/model/json/EBasicJsonMapVarchar.java @@ -0,0 +1,56 @@ +package com.avaje.tests.model.json; + +import com.avaje.ebean.annotation.DbJson; +import com.avaje.ebean.annotation.DbJsonType; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Version; +import java.util.Map; + +@Entity +public class EBasicJsonMapVarchar { + + @Id + Long id; + + @Version + Long version; + + String name; + + @DbJson(storage = DbJsonType.VARCHAR)//, length = 2200) + Map content; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getVersion() { + return version; + } + + public void setVersion(Long version) { + this.version = version; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Map getContent() { + return content; + } + + public void setContent(Map content) { + this.content = content; + } +}
+ * Note that type expected to be JsonNode or Map. + *