public EntityInfoBuilder<T> addField(String fieldPath, String columnName, EntityFieldType fieldType, boolean identityId) { EntityFieldType type = new EntityFieldType(fieldType.getFieldType(), fieldType.isPrimitive(), identityId); return addField(new FieldInfo(fieldPath, columnName, type)); }
private String getAutoIncrement(ColumnInfo columnInfo) { EntityFieldType fieldType = columnInfo.getFieldType(); if (!fieldType.isIdentityId()) { return ""; } FieldTypeEnum type = fieldType.getFieldType(); switch (type) { case BYTE: case INT: case LONG: case SHORT: case BIGINTEGER: return " AUTO_INCREMENT"; default: logger.warn("Declared IDENTITY @Id strategy over non int type"); return ""; } }
public EntityFieldType buildFieldTypeByPath(String fieldPath, Optional<FieldTypeEnum> fieldTypeEnum) { Field field = findReferencedField(entityClass, fieldPath); JFleetFieldInspector fieldTypeInspector = new JFleetFieldInspector(field); EntityFieldType fieldType = fieldTypeInspector.getFieldType(); return fieldTypeEnum.map(type -> new EntityFieldType(type, fieldType.isPrimitive())).orElse(fieldType); }
@Test public void timeStampTest() { EntityFieldType type = getField("timeStamp"); assertFalse(type.isPrimitive()); assertEquals(FieldTypeEnum.TIMESTAMP, type.getFieldType()); }
@Test public void inspectEntitySequenceId() { List<FieldInfo> fields = fieldsInspector.getFieldsFromClass(EntityWithGeneratedSequenceId.class); assertEquals(2, fields.size()); FieldInfo field = fields.get(0); EntityFieldType fieldType = field.getFieldType(); assertFalse(fieldType.isPrimitive()); assertEquals(FieldTypeEnum.LONG, fieldType.getFieldType()); assertFalse(fieldType.isIdentityId()); }
@Override public String toString(Object obj, EntityFieldType entityFieldType) { if (obj == null) { return null; } FieldTypeEnum fieldType = entityFieldType.getFieldType(); Function<Object, String> function = mappers.get(fieldType); return function.apply(obj); }
private Optional<EntityFieldType> getAnnotatedType(Class<?> javaType) { if (javaType.isEnum()) { return Optional.of(new EntityFieldType(getEnumType(field.getAnnotation(Enumerated.class)))); } else if (Date.class.isAssignableFrom(javaType)) { return Optional.of(new EntityFieldType(getDateFieldType())); } return Optional.empty(); }
public List<ColumnInfo> getNotIdentityColumns() { return columns.stream().filter(f -> !f.getFieldType().isIdentityId()).collect(Collectors.toList()); }
@Test public void sqlTimeStampTest() { EntityFieldType type = getField("sqlTimeStamp"); assertFalse(type.isPrimitive()); assertEquals(FieldTypeEnum.TIMESTAMP, type.getFieldType()); }
@Test public void inspectEntityIdetityId() { List<FieldInfo> fields = fieldsInspector.getFieldsFromClass(EntityWithGeneratedIdentityId.class); assertEquals(2, fields.size()); FieldInfo field = fields.get(0); EntityFieldType fieldType = field.getFieldType(); assertFalse(fieldType.isPrimitive()); assertEquals(FieldTypeEnum.LONG, fieldType.getFieldType()); assertTrue(fieldType.isIdentityId()); }
public Function<Object, Object> preConvert(EntityFieldType type) { switch (type.getFieldType()) { case ENUMORDINAL: return (obj) -> { if (obj != null) { return ((Enum<?>) obj).ordinal(); } return null; }; case ENUMSTRING: return (obj) -> { if (obj != null) { return ((Enum<?>) obj).name(); } return null; }; default: return (obj) -> obj; } }
private Optional<EntityFieldType> getAnnotatedType(Class<?> javaType) { if (javaType.isEnum()) { return Optional.of(new EntityFieldType(getEnumType(field.getAnnotation(JFleetEnumerated.class)))); } else if (Date.class.isAssignableFrom(javaType)) { return Optional.of(new EntityFieldType(getDateFieldType())); } return Optional.empty(); }
private String getPrimaryKey(List<ColumnInfo> columns) { Optional<ColumnInfo> id = columns.stream().filter(col -> col.getFieldType().isIdentityId()).findFirst(); return id.map(col -> ", PRIMARY KEY (" + col.getColumnName() + ")").orElse(""); }
@Test public void localDateTimeTest() { EntityFieldType type = getField("localDateTime"); assertFalse(type.isPrimitive()); assertEquals(FieldTypeEnum.LOCALDATETIME, type.getFieldType()); }
private EntityFieldType getFieldType() { Class<?> javaType = field.getType(); Optional<EntityFieldType> fieldType = fieldTypeInspector.getFieldType(javaType); EntityFieldType type = fieldType.orElseGet(() -> getAnnotatedType(javaType) .orElseThrow(() -> new RuntimeException("Unexpected type on " + field.toString()))); return new EntityFieldType(type.getFieldType(), type.isPrimitive(), isIdentityId()); }
@Override public String toString() { return fieldName + " (" + columnName + "): " + fieldType.getFieldType().name(); }
private String getDbType(EntityFieldType fieldType) { if (fieldType.isIdentityId()) { return getSerial(fieldType); FieldTypeEnum type = fieldType.getFieldType(); switch (type) { case BOOLEAN:
public EntityInfoBuilder<T> addColumn(String columnName, FieldTypeEnum fieldTypeEnum, boolean primitive, boolean identityId, Function<T, Object> accessor) { EntityFieldType fieldType = new EntityFieldType(fieldTypeEnum, primitive, identityId); return addColumn(columnName, fieldType, accessor); }
private String getPrimaryKey(List<ColumnInfo> columns) { Optional<ColumnInfo> id = columns.stream().filter(col -> col.getFieldType().isIdentityId()).findFirst(); return id.map(col -> ", PRIMARY KEY (`" + col.getColumnName() + "`)").orElse(""); }
@Test public void enumStringTest() { EntityFieldType type = getField("enumString"); assertFalse(type.isPrimitive()); assertEquals(FieldTypeEnum.ENUMSTRING, type.getFieldType()); }