public static String[] getJDBCTypes() { checkTypes(); return (String[]) jdbcTypes.keySet().toArray(new String[jdbcTypes.size()]); }
private String typeCodeName(int sqlTypeCode) { return sqlTypeCode + "(" + JDBCToHibernateTypeHelper.getJDBCTypeName(sqlTypeCode) + ")"; }
public String columnToHibernateTypeName(TableIdentifier table, String columnName, int sqlType, int length, int precision, int scale, boolean nullable, boolean generatedIdentifier) { String preferredHibernateType = JDBCToHibernateTypeHelper.getPreferredHibernateType(sqlType, length, precision, scale, nullable, generatedIdentifier); String location = "<no info>"; if(log.isDebugEnabled()) { String info = " t:" + JDBCToHibernateTypeHelper.getJDBCTypeName( sqlType ) + " l:" + length + " p:" + precision + " s:" + scale + " n:" + nullable + " id:" + generatedIdentifier; if(table!=null) { location = TableNameQualifier.qualify(table.getCatalog(), table.getSchema(), table.getName() ) + "." + columnName + info; } else { location += " Column: " + columnName + info; } } if(preferredHibernateType==null) { log.debug("No default type found for [" + location + "] falling back to [serializable]"); return "serializable"; } else { log.debug("Default type found for [" + location + "] to [" + preferredHibernateType + "]"); return preferredHibernateType; } }
column.setSqlTypeCode(new Integer(sqlType) ); if(intBounds(size) ) { if(JDBCToHibernateTypeHelper.typeHasLength(sqlType) ) { column.setLength(size); if(JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType) ) { column.setPrecision(size); if(JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType) ) { column.setScale(decimalDigits);
private static void bindTypeMappings(Element typeMapping, OverrideRepository repository) { Iterator<?> iterator = typeMapping.elements("sql-type").iterator(); while (iterator.hasNext() ) { Element element = (Element) iterator.next(); int jdbcType = JDBCToHibernateTypeHelper.getJDBCType(element.attributeValue("jdbc-type") ); SQLTypeMapping mapping = new SQLTypeMapping(jdbcType ); mapping.setHibernateType( getHibernateType( element ) ); mapping.setLength(getInteger(element.attributeValue("length"), SQLTypeMapping.UNKNOWN_LENGTH) ); mapping.setPrecision(getInteger(element.attributeValue("precision"), SQLTypeMapping.UNKNOWN_PRECISION) ); mapping.setScale(getInteger(element.attributeValue("scale"), SQLTypeMapping.UNKNOWN_SCALE) ); String notNull = element.attributeValue("not-null"); if(notNull==null) { mapping.setNullable(null); } else { boolean nullable = notNull.equals( "false" ); mapping.setNullable( Boolean.valueOf(nullable) ); } if(StringHelper.isEmpty(mapping.getHibernateType())) { throw new MappingException("No hibernate-type specified for " + element.attributeValue("jdbc-type") + " at " + element.getUniquePath()); } repository.addTypeMapping(mapping); } }
String attributeValue = element.attributeValue("jdbc-type"); if(StringHelper.isNotEmpty(attributeValue)) { column.setSqlTypeCode(new Integer(JDBCToHibernateTypeHelper.getJDBCType(attributeValue)));
public String columnToHibernateTypeName(TableIdentifier table, String columnName, int sqlType, int length, int precision, int scale, boolean nullable, boolean generatedIdentifier) { String result = null; String location = ""; String info = " t:" + JDBCToHibernateTypeHelper.getJDBCTypeName( sqlType ) + " l:" + length + " p:" + precision + " s:" + scale + " n:" + nullable + " id:" + generatedIdentifier; if(table!=null) { location = TableNameQualifier.qualify(table.getCatalog(), table.getSchema(), table.getName() ) + "." + columnName; } else { location += " Column: " + columnName + info; } if(table!=null && columnName!=null) { result = typeForColumn.get(new TableColumnKey(table, columnName)); if(result!=null) { log.debug("explicit column mapping found for [" + location + "] to [" + result + "]"); return result; } } result = OverrideRepository.this.getPreferredHibernateType(sqlType, length, precision, scale, nullable); if(result==null) { return super.columnToHibernateTypeName(table, columnName, sqlType, length, precision, scale, nullable, generatedIdentifier); } else { log.debug("<type-mapping> found for [" + location + info + "] to [" + result + "]"); return result; } }
public static int getJDBCType(String value) { checkTypes(); Integer number = (Integer) jdbcTypes.get(value); if(number==null) { try { return Integer.parseInt(value); } catch (NumberFormatException nfe) { throw new MappingException("jdbc-type: " + value + " is not a known JDBC Type nor a valid number"); } } else { return number.intValue(); } }
public void visit( Table table, Column col, IssueCollector pc) { if ( currentDbTable == null ) { return; } Column dbColumn = currentDbTable .getColumn( new Column( col.getName() ) ); if ( dbColumn == null ) { pc.reportIssue( new Issue( "SCHEMA_COLUMN_MISSING", Issue.HIGH_PRIORITY, table(table) + " is missing column: " + col.getName() ) ); } else { //TODO: this needs to be able to know if a type is truly compatible or not. Right now it requires an exact match. //String sqlType = col.getSqlType( dialect, mapping ); int dbTypeCode = dbColumn.getSqlTypeCode().intValue(); int modelTypeCode = col .getSqlTypeCode( mapping ); // TODO: sqltype name string if ( !(dbTypeCode == modelTypeCode ) ) { pc.reportIssue( new Issue( "SCHEMA_COLUMN_TYPE_MISMATCH", Issue.NORMAL_PRIORITY, table(table) + " has a wrong column type for " + col.getName() + ", expected: " + JDBCToHibernateTypeHelper.getJDBCTypeName(modelTypeCode) + " but was " + JDBCToHibernateTypeHelper.getJDBCTypeName(dbTypeCode) + " in db") ); } } }