项目：org.fastnate
文件：EntityClass.java
/**
* Determine the inheritance type and discriminator properties.
*/
private void buildInheritance() {
// Check,if we've got an explicit inheritance type
final Inheritance inheritance = this.entityClass.getAnnotation(Inheritance.class);
if (inheritance != null) {
this.inheritanceType = inheritance.strategy();
}
// Find the root of our hierarchy
this.hierarchyRoot = this;
findHierarchyRoot(this.entityClass.getSuperclass());
// We scan only classes that we are about to write
// So we don't kNow,that there is a subclass entity - until we find one
// This Could be to late for InheritanceType.SINGLE_TABLE - the defaault type
// That's why we build a discriminator,if one of the inheritance annotations exists
if (this.inheritanceType == null && this.entityClass.isAnnotationPresent(discriminatorColumn.class)
|| this.entityClass.isAnnotationPresent(discriminatorValue.class)) {
this.inheritanceType = InheritanceType.SINGLE_TABLE;
}
builddiscriminator();
}
项目：lams
文件：JPAOverriddenAnnotationReader.java
private discriminatorColumn getdiscriminatorColumn(Element tree,XMLContext.Default defaults) {
Element element = tree != null ? tree.element( "discriminator-column" ) : null;
if ( element != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( discriminatorColumn.class );
copyStringAttribute( ad,element,"name",false );
copyStringAttribute( ad,"column-deFinition",false );
String value = element.attributeValue( "discriminator-type" );
discriminatorType type = discriminatorType.STRING;
if ( value != null ) {
if ( "STRING".equals( value ) ) {
type = discriminatorType.STRING;
}
else if ( "CHAR".equals( value ) ) {
type = discriminatorType.CHAR;
}
else if ( "INTEGER".equals( value ) ) {
type = discriminatorType.INTEGER;
}
else {
throw new AnnotationException(
"UnkNown discrimiatorType in XML: " + value + " (" + SCHEMA_VALIDATION + ")"
);
}
}
ad.setValue( "discriminatorType",type );
copyIntegerAttribute( ad,"length" );
return AnnotationFactory.create( ad );
}
else if ( defaults.canUseJavaAnnotations() ) {
return getPhysicalAnnotation( discriminatorColumn.class );
}
else {
return null;
}
}
项目：jpa-unit
文件：EntityUtilsTest.java
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheClassNameWithSingleTableInheritance() throws Exception {
final String simpleClassNameBase = "EntityClass";
final String simpleClassNameA = "SubEntityClassA";
final String simpleClassNameB = "SubEntityClassB";
final JPackage jp = jcodemodel.rootPackage();
final JDefinedClass jbaseClass = jp._class(JMod.PUBLIC,simpleClassNameBase);
jbaseClass.annotate(Entity.class);
jbaseClass.annotate(Inheritance.class).param("strategy",InheritanceType.SINGLE_TABLE);
jbaseClass.annotate(discriminatorColumn.class).param("name","TYPE");
final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC,simpleClassNameA)._extends(jbaseClass);
jSubclassA.annotate(Entity.class);
jSubclassA.annotate(discriminatorValue.class).param("value","A");
final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC,simpleClassNameB)._extends(jbaseClass);
jSubclassB.annotate(Entity.class);
jSubclassB.annotate(discriminatorValue.class).param("value","B");
buildModel(testFolder.getRoot(),jcodemodel);
compileModel(testFolder.getRoot());
final Class<?> baseClass = loadClass(testFolder.getRoot(),jbaseClass.name());
final Class<?> subClassA = loadClass(testFolder.getRoot(),jSubclassA.name());
final Class<?> subClassB = loadClass(testFolder.getRoot(),jSubclassB.name());
final Class<?> clazz = EntityUtils.getEntityClassFromNodeLabels(Arrays.asList(simpleClassNameBase),Arrays.asList(baseClass,subClassA,subClassB));
assertthat(clazz,equalTo(baseClass));
}
项目：jpa-unit
文件：EntityUtilsTest.java
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheTableAnnotationWithSingleTableInheritance() throws Exception {
final String simpleClassNameBase = "EntityClass";
final String simpleClassNameA = "SubEntityClassA";
final String simpleClassNameB = "SubEntityClassB";
final String nodeLabel = "ENTITY_CLASS";
final JPackage jp = jcodemodel.rootPackage();
final JDefinedClass jbaseClass = jp._class(JMod.PUBLIC,simpleClassNameBase);
jbaseClass.annotate(Entity.class);
jbaseClass.annotate(Table.class).param("name",nodeLabel);
jbaseClass.annotate(Inheritance.class).param("strategy",jSubclassB.name());
final Class<?> clazz = EntityUtils.getEntityClassFromNodeLabels(Arrays.asList(nodeLabel),equalTo(baseClass));
}
项目：org.fastnate
文件：EntityClass.java
private void builddiscriminator() {
if (this.inheritanceType == InheritanceType.SINGLE_TABLE || this.inheritanceType == InheritanceType.JOINED) {
final discriminatorColumn column = this.hierarchyRoot.entityClass.getAnnotation(discriminatorColumn.class);
if (column != null || this.inheritanceType != InheritanceType.JOINED
|| this.context.getProvider().isJoineddiscriminatorNeeded()) {
this.discriminatorColumn = this.table.resolveColumn(column == null ? "DTYPE" : column.name());
this.discriminator = builddiscriminator(this,column);
}
}
}
项目：org.fastnate
文件：EntityClass.java
private ColumnExpression builddiscriminator(final EntityClass<?> c,final discriminatorColumn column) {
final discriminatorType type;
final int maxLength;
if (column == null) {
type = discriminatorType.STRING;
final int defaultMaxLength = 31;
maxLength = defaultMaxLength;
} else {
type = column.discriminatorType();
maxLength = column.length();
}
final discriminatorValue value = this.entityClass.getAnnotation(discriminatorValue.class);
if (type == discriminatorType.INTEGER) {
return PrimitiveColumnExpression.create(
value == null ? c.getEntityName().hashCode() : Integer.parseInt(value.value()),getContext().getDialect());
}
final String v = value == null ? c.getEntityName() : value.value();
if (StringUtils.isEmpty(v)) {
throw new IllegalArgumentException("Missing discriminator value for: " + c.getEntityClass());
}
if (type == discriminatorType.STRING) {
return PrimitiveColumnExpression.create(v.length() <= maxLength ? v : v.substring(0,maxLength),getContext().getDialect());
} else if (type == discriminatorType.CHAR) {
return PrimitiveColumnExpression.create(v.substring(0,1),getContext().getDialect());
}
throw new IllegalArgumentException("UnkNown discriminator type: " + type);
}
public static Ejb3discriminatorColumn builddiscriminatorColumn(
discriminatorType type,discriminatorColumn discAnn,discriminatorFormula discFormulaAnn,Mappings mappings) {
Ejb3discriminatorColumn discriminatorColumn = new Ejb3discriminatorColumn();
discriminatorColumn.setMappings( mappings );
discriminatorColumn.setImplicit( true );
if ( discFormulaAnn != null ) {
discriminatorColumn.setImplicit( false );
discriminatorColumn.setFormula( discFormulaAnn.value() );
}
else if ( discAnn != null ) {
discriminatorColumn.setImplicit( false );
if ( !BinderHelper.isEmptyAnnotationValue( discAnn.columnDeFinition() ) ) {
discriminatorColumn.setsqlType(
discAnn.columnDeFinition()
);
}
if ( !BinderHelper.isEmptyAnnotationValue( discAnn.name() ) ) {
discriminatorColumn.setLogicalColumnName( discAnn.name() );
}
discriminatorColumn.setNullable( false );
}
if ( discriminatorType.CHAR.equals( type ) ) {
discriminatorColumn.setdiscriminatorTypeName( "character" );
discriminatorColumn.setImplicit( false );
}
else if ( discriminatorType.INTEGER.equals( type ) ) {
discriminatorColumn.setdiscriminatorTypeName( "integer" );
discriminatorColumn.setImplicit( false );
}
else if ( discriminatorType.STRING.equals( type ) || type == null ) {
if ( discAnn != null ) discriminatorColumn.setLength( discAnn.length() );
discriminatorColumn.setdiscriminatorTypeName( "string" );
}
else {
throw new AssertionFailure( "UnkNown discriminator type: " + type );
}
discriminatorColumn.bind();
return discriminatorColumn;
}
项目：lams
文件：AnnotationBinder.java
/**
* Process all discriminator-related Metadata per rules for "single table" inheritance
*/
private static Ejb3discriminatorColumn processSingleTablediscriminatorProperties(
XClass clazzToProcess,Mappings mappings,InheritanceState inheritanceState,EntityBinder entityBinder) {
final boolean isRoot = !inheritanceState.hasParents();
Ejb3discriminatorColumn discriminatorColumn = null;
javax.persistence.discriminatorColumn discAnn = clazzToProcess.getAnnotation(
javax.persistence.discriminatorColumn.class
);
discriminatorType discriminatorType = discAnn != null
? discAnn.discriminatorType()
: discriminatorType.STRING;
org.hibernate.annotations.discriminatorFormula discFormulaAnn = clazzToProcess.getAnnotation(
org.hibernate.annotations.discriminatorFormula.class
);
if ( isRoot ) {
discriminatorColumn = Ejb3discriminatorColumn.builddiscriminatorColumn(
discriminatorType,discAnn,discFormulaAnn,mappings
);
}
if ( discAnn != null && !isRoot ) {
LOG.invaliddiscriminatorAnnotation( clazzToProcess.getName() );
}
final String discriminatorValue = clazzToProcess.isAnnotationPresent( discriminatorValue.class )
? clazzToProcess.getAnnotation( discriminatorValue.class ).value()
: null;
entityBinder.setdiscriminatorValue( discriminatorValue );
discriminatorOptions discriminatorOptions = clazzToProcess.getAnnotation( discriminatorOptions.class );
if ( discriminatorOptions != null) {
entityBinder.setForcediscriminator( discriminatorOptions.force() );
entityBinder.setInsertablediscriminator( discriminatorOptions.insert() );
}
return discriminatorColumn;
}
项目：lams
文件：AnnotationBinder.java
/**
* Process all discriminator-related Metadata per rules for "joined" inheritance
*/
private static Ejb3discriminatorColumn processJoineddiscriminatorProperties(
XClass clazzToProcess,EntityBinder entityBinder) {
if ( clazzToProcess.isAnnotationPresent( discriminatorFormula.class ) ) {
throw new MappingException( "@discriminatorFormula on joined inheritance not supported at this time" );
}
// discriminatorValue handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
final discriminatorValue discriminatorValueAnnotation = clazzToProcess.getAnnotation( discriminatorValue.class );
final String discriminatorValue = discriminatorValueAnnotation != null
? clazzToProcess.getAnnotation( discriminatorValue.class ).value()
: null;
entityBinder.setdiscriminatorValue( discriminatorValue );
// discriminatorColumn handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
final discriminatorColumn discriminatorColumnAnnotation = clazzToProcess.getAnnotation( discriminatorColumn.class );
if ( !inheritanceState.hasParents() ) {
// we want to process the discriminator column if either:
// 1) There is an explicit discriminatorColumn annotation && we are not told to ignore them
// 2) There is not an explicit discriminatorColumn annotation && we are told to create them implicitly
final boolean generatediscriminatorColumn;
if ( discriminatorColumnAnnotation != null ) {
if ( mappings.ignoreExplicitdiscriminatorColumnForJoinedInheritance() ) {
LOG.debugf( "Ignoring explicit discriminatorColumn annotation on ",clazzToProcess.getName() );
generatediscriminatorColumn = false;
}
else {
LOG.applyingExplicitdiscriminatorColumnForJoined(
clazzToProcess.getName(),AvailableSettings.IGnorE_EXPLICIT_disCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS
);
generatediscriminatorColumn = true;
}
}
else {
if ( mappings.useImplicitdiscriminatorColumnForJoinedInheritance() ) {
LOG.debug( "Applying implicit discriminatorColumn using discriminatorColumn defaults" );
generatediscriminatorColumn = true;
}
else {
LOG.debug( "Ignoring implicit (absent) discriminatorColumn" );
generatediscriminatorColumn = false;
}
}
if ( generatediscriminatorColumn ) {
final discriminatorType discriminatorType = discriminatorColumnAnnotation != null
? discriminatorColumnAnnotation.discriminatorType()
: discriminatorType.STRING;
return Ejb3discriminatorColumn.builddiscriminatorColumn(
discriminatorType,discriminatorColumnAnnotation,null,mappings
);
}
}
else {
if ( discriminatorColumnAnnotation != null ) {
LOG.invaliddiscriminatorAnnotation( clazzToProcess.getName() );
}
}
return null;
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。