diff --git a/src/main/java/com/avaje/ebean/config/dbplatform/DbTypeMap.java b/src/main/java/com/avaje/ebean/config/dbplatform/DbTypeMap.java
index 44acc110f..d4fc32cc7 100644
--- a/src/main/java/com/avaje/ebean/config/dbplatform/DbTypeMap.java
+++ b/src/main/java/com/avaje/ebean/config/dbplatform/DbTypeMap.java
@@ -9,16 +9,76 @@ import java.util.Map;
*/
public class DbTypeMap {
+ /**
+ * A map to reverse lookup the type by name.
+ *
+ * Used when converting from logical types to platform types which we
+ * want to do with 2 phase DDL generation.
+ */
+ static Map lookup = new HashMap();
+
+ static {
+ lookup.put("BOOLEAN", Types.BOOLEAN);
+ lookup.put("BIT", Types.BIT);
+ lookup.put("INTEGER", Types.INTEGER);
+ lookup.put("BIGINT", Types.BIGINT);
+ lookup.put("REAL", Types.REAL);
+ // Float is most common REAL mapping to have that as well
+ lookup.put("FLOAT", Types.REAL);
+
+ lookup.put("DOUBLE", Types.DOUBLE);
+ lookup.put("SMALLINT", Types.SMALLINT);
+ lookup.put("TINYINT", Types.TINYINT);
+ lookup.put("DECIMAL", Types.DECIMAL);
+ lookup.put("VARCHAR", Types.VARCHAR);
+ // VARCHAR2 - extra for Oracle specific column definition
+ lookup.put("VARCHAR2", Types.VARCHAR);
+ lookup.put("CHAR", Types.CHAR);
+ lookup.put("BLOB", Types.BLOB);
+ lookup.put("CLOB", Types.CLOB);
+
+ lookup.put("LONGVARBINARY", Types.LONGVARBINARY);
+ lookup.put("LONGVARCHAR", Types.LONGVARCHAR);
+ lookup.put("VARBINARY", Types.VARBINARY);
+ lookup.put("BINARY", Types.BINARY);
+ lookup.put("DATE", Types.DATE);
+ lookup.put("TIME", Types.TIME);
+ lookup.put("TIMESTAMP", Types.TIMESTAMP);
+
+ // Not standard java.sql.Types
+ // logical JSON storage types
+ lookup.put("JSON", DbType.JSON);
+ lookup.put("JSONB", DbType.JSONB);
+ lookup.put("JSONCLOB", DbType.JSONClob);
+ lookup.put("JSONBLOB", DbType.JSONBlob);
+ lookup.put("JSONVARCHAR", DbType.JSONVarchar);
+ }
+
+
private final Map typeMap = new HashMap();
+ /**
+ * Return the DbTypeMap with standard (not platform specific) types.
+ *
+ * This has some extended JSON types (JSON, JSONB, JSONVarchar, JSONClob, JSONBlob).
+ * These types get translated to specific database platform types during DDL generation.
+ */
+ public static DbTypeMap logicalTypes() {
+ return new DbTypeMap(true);
+ }
+
public DbTypeMap() {
- loadDefaults();
+ loadDefaults(false);
+ }
+
+ private DbTypeMap(boolean logicalTypes) {
+ loadDefaults(logicalTypes);
}
/**
* Load the standard types. These can be overridden by DB specific platform.
*/
- private void loadDefaults() {
+ private void loadDefaults(boolean logicalTypes) {
put(Types.BOOLEAN, new DbType("boolean"));
put(Types.BIT, new DbType("bit"));
@@ -37,11 +97,21 @@ public class DbTypeMap {
put(Types.BLOB, new DbType("blob"));
put(Types.CLOB, new DbType("clob"));
- put(DbType.JSON, new DbType("clob")); // Postgres maps this to JSON
- put(DbType.JSONB, new DbType("clob")); // Postgres maps this to JSONB
- put(DbType.JSONClob, new DbType("clob"));
- put(DbType.JSONBlob, new DbType("blob"));
- put(DbType.JSONVarchar, new DbType("varchar", 1000));
+ if (logicalTypes) {
+ // keep it logical for 2 layer DDL generation
+ put(DbType.JSON, new DbType("json"));
+ put(DbType.JSONB, new DbType("jsonb"));
+ put(DbType.JSONClob, new DbType("jsonclob"));
+ put(DbType.JSONBlob, new DbType("jsonblob"));
+ put(DbType.JSONVarchar, new DbType("jsonvarchar", 1000));
+
+ } else {
+ put(DbType.JSON, new DbType("clob")); // Postgres maps this to JSON
+ put(DbType.JSONB, new DbType("clob")); // Postgres maps this to JSONB
+ put(DbType.JSONClob, new DbType("clob"));
+ put(DbType.JSONBlob, new DbType("blob"));
+ put(DbType.JSONVarchar, new DbType("varchar", 1000));
+ }
put(Types.LONGVARBINARY, new DbType("longvarbinary"));
put(Types.LONGVARCHAR, new DbType("lonvarchar"));
@@ -54,6 +124,28 @@ public class DbTypeMap {
}
+ /**
+ * Lookup the platform specific DbType given the standard sql type name.
+ */
+ public DbType lookup(String name) {
+ name = name.trim().toUpperCase();
+ Integer typeKey = lookup.get(name);
+ if (typeKey == null) {
+ throw new IllegalArgumentException("Unknown type [" + name + "] - not standard sql type");
+ }
+ // handle JSON types mapped to clob, blob and varchar
+ switch (typeKey) {
+ case DbType.JSONBlob:
+ return get(Types.BLOB);
+ case DbType.JSONClob:
+ return get(Types.CLOB);
+ case DbType.JSONVarchar:
+ return get(Types.VARCHAR);
+ default:
+ return get(typeKey);
+ }
+ }
+
/**
* Override the type for a given JDBC type.
*/
@@ -65,13 +157,6 @@ public class DbTypeMap {
* Return the type for a given jdbc type.
*/
public DbType get(int jdbcType) {
-
- DbType dbType = typeMap.get(jdbcType);
- if (dbType == null) {
- String m = "No DB type for JDBC type " + jdbcType;
- throw new RuntimeException(m);
- }
-
- return dbType;
+ return typeMap.get(jdbcType);
}
}
diff --git a/src/main/java/com/avaje/ebean/config/dbplatform/PostgresPlatform.java b/src/main/java/com/avaje/ebean/config/dbplatform/PostgresPlatform.java
index 15b4d9b46..15b7b4ecf 100644
--- a/src/main/java/com/avaje/ebean/config/dbplatform/PostgresPlatform.java
+++ b/src/main/java/com/avaje/ebean/config/dbplatform/PostgresPlatform.java
@@ -39,6 +39,9 @@ public class PostgresPlatform extends DatabasePlatform {
this.openQuote = "\"";
this.closeQuote = "\"";
+ DbType dbTypeText = new DbType("text");
+ DbType dbBytea = new DbType("bytea", false);
+
dbTypeMap.put(DbType.HSTORE, new DbType("hstore"));
dbTypeMap.put(DbType.JSON, new DbType("json"));
dbTypeMap.put(DbType.JSONB, new DbType("jsonb"));
@@ -48,13 +51,13 @@ public class PostgresPlatform extends DatabasePlatform {
dbTypeMap.put(Types.TINYINT, new DbType("smallint"));
dbTypeMap.put(Types.DECIMAL, new DbType("decimal", 38));
- dbTypeMap.put(Types.BINARY, new DbType("bytea", false));
- dbTypeMap.put(Types.VARBINARY, new DbType("bytea", false));
+ dbTypeMap.put(Types.BINARY, dbBytea);
+ dbTypeMap.put(Types.VARBINARY, dbBytea);
- dbTypeMap.put(Types.BLOB, new DbType("bytea", false));
- dbTypeMap.put(Types.CLOB, new DbType("text"));
- dbTypeMap.put(Types.LONGVARBINARY, new DbType("bytea", false));
- dbTypeMap.put(Types.LONGVARCHAR, new DbType("text"));
+ dbTypeMap.put(Types.BLOB, dbBytea);
+ dbTypeMap.put(Types.CLOB, dbTypeText);
+ dbTypeMap.put(Types.LONGVARBINARY, dbBytea);
+ dbTypeMap.put(Types.LONGVARCHAR, dbTypeText);
dbDdlSyntax.setDropTableCascade("cascade");
dbDdlSyntax.setDropIfExists("if exists");
diff --git a/src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanProperty.java b/src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanProperty.java
index 5ded7f048..032e201e9 100644
--- a/src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanProperty.java
+++ b/src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanProperty.java
@@ -186,6 +186,7 @@ public class DeployBeanProperty {
this.desc = desc;
this.propertyType = propertyType;
this.scalarType = wrapScalarType(propertyType, scalarType, typeConverter);
+ this.dbType = (scalarType == null) ? 0 : scalarType.getJdbcType();
}
/**
diff --git a/src/test/java/com/avaje/ebean/config/dbplatform/DbTypeMapTest.java b/src/test/java/com/avaje/ebean/config/dbplatform/DbTypeMapTest.java
new file mode 100644
index 000000000..3a0fc9055
--- /dev/null
+++ b/src/test/java/com/avaje/ebean/config/dbplatform/DbTypeMapTest.java
@@ -0,0 +1,38 @@
+package com.avaje.ebean.config.dbplatform;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+
+public class DbTypeMapTest {
+
+ @Test
+ public void testLookupRender_given_postgresPlatformType() throws Exception {
+
+ PostgresPlatform pg = new PostgresPlatform();
+ DbTypeMap dbTypeMap = pg.getDbTypeMap();
+
+ assertThat(dbTypeMap.lookup("clob").renderType(0,0)).isEqualTo("text");
+ assertThat(dbTypeMap.lookup("CLOB").renderType(0, 0)).isEqualTo("text");
+
+ assertThat(dbTypeMap.lookup("varchar").renderType(20,0)).isEqualTo("varchar(20)");
+
+ assertThat(dbTypeMap.lookup("json").renderType(0,0)).isEqualTo("json");
+ assertThat(dbTypeMap.lookup("jsonb").renderType(0,0)).isEqualTo("jsonb");
+ assertThat(dbTypeMap.lookup("jsonclob").renderType(0,0)).isEqualTo("text");
+ assertThat(dbTypeMap.lookup("jsonblob").renderType(0,0)).isEqualTo("bytea");
+ assertThat(dbTypeMap.lookup("jsonvarchar").renderType(200,0)).isEqualTo("varchar(200)");
+
+ }
+
+ @Test
+ public void testPlatformTypes() {
+
+ DbTypeMap dbTypeMap = DbTypeMap.logicalTypes();
+ DbType dbType = dbTypeMap.get(DbType.JSON);
+ DbType json = dbTypeMap.lookup("json");
+
+ assertThat(dbType).isSameAs(json);
+ }
+}
\ No newline at end of file