From 30c3a435d695b7c4a0a7d26bbb621f8adfe3678b Mon Sep 17 00:00:00 2001 From: Robin Bygrave Date: Mon, 3 Aug 2015 17:29:57 +1200 Subject: [PATCH] Internal changes for DB Migration / DDL generation #369 --- .../ebean/config/dbplatform/DbTypeMap.java | 115 +++++++++++++++--- .../config/dbplatform/PostgresPlatform.java | 15 ++- .../deploy/meta/DeployBeanProperty.java | 1 + .../config/dbplatform/DbTypeMapTest.java | 38 ++++++ 4 files changed, 148 insertions(+), 21 deletions(-) create mode 100644 src/test/java/com/avaje/ebean/config/dbplatform/DbTypeMapTest.java 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