Java Code Examples for javax.persistence.InheritanceType

The following are top voted examples for showing how to use javax.persistence.InheritanceType. These examples are extracted from open source projects. You can vote up the examples you like and your votes will be used in our system to generate more good examples.
Example 1
Project: ibankapp-base   File: UniqueValidatorTest.java   View source code 6 votes vote down vote up
@Test
@Transactional
public void testUniqueAndNum() {
  thrown.expect(BasePersistenceException.class);
  thrown.expectMessage("唯一约束校验失败,ENUM重复");

  TestModelWithEumAndUnique model = new TestModelWithEumAndUnique();
  model.setStatus(InheritanceType.SINGLE_TABLE);
  model.setId("aaa");
  repository.persist(model);

  model = new TestModelWithEumAndUnique();
  model.setId("bbb");
  model.setStatus(InheritanceType.SINGLE_TABLE);
  repository.persist(model);
}
 
Example 2
Project: celerio   File: InheritanceFactory.java   View source code 6 votes vote down vote up
private void putEntityByTableNameForEntityWithInheritance() {
    // Attention, for SINGLE_TABLE inheritance strategy, we only put the root entity.

    for (EntityConfig entityConfig : config.getCelerio().getEntityConfigs()) {
        Entity entity = config.getProject().getEntityByName(entityConfig.getEntityName());

        if (entity.hasInheritance() && !config.getProject().hasEntityBySchemaAndTableName(entity.getTable().getSchemaName(), entity.getTable().getName())) {
            InheritanceType inheritanceType = entity.getInheritance().getStrategy();

            if (inheritanceType == InheritanceType.SINGLE_TABLE) {
                if (entity.isRoot()) {
                    config.getProject().putEntity(entity);
                }
            } else if (inheritanceType == InheritanceType.JOINED || inheritanceType == InheritanceType.TABLE_PER_CLASS) {
                config.getProject().putEntity(entity);
            } else {
                log.warning("Invalid case, there should be an inheritance type");
            }
        }
    }
}
 
Example 3
Project: hyperjaxb3   File: EntityMapping.java   View source code 6 votes vote down vote up
public void createEntity$Inheritance(Mapping context,
		ClassOutline classOutline, final Entity entity) {
	final InheritanceType inheritanceStrategy = getInheritanceStrategy(
			context, classOutline, entity);

	if (isRootClass(context, classOutline)) {
		if (entity.getInheritance() == null
				|| entity.getInheritance().getStrategy() == null) {
			entity.setInheritance(new Inheritance());
			entity.getInheritance().setStrategy(inheritanceStrategy.name());
		}
	} else {
		if (entity.getInheritance() != null
				&& entity.getInheritance().getStrategy() != null) {
			entity.setInheritance(null);
		}
	}
}
 
Example 4
Project: hyperjaxb3   File: EntityMapping.java   View source code 6 votes vote down vote up
public javax.persistence.InheritanceType getInheritanceStrategy(
		Mapping context, ClassOutline classOutline, Entity entity) {
	if (isRootClass(context, classOutline)) {
		if (entity.getInheritance() != null
				&& entity.getInheritance().getStrategy() != null) {
			return InheritanceType.valueOf(entity.getInheritance()
					.getStrategy());
		} else {
			return javax.persistence.InheritanceType.JOINED;
		}
	} else {
		final ClassOutline superClassOutline = getSuperClass(context,
				classOutline);
		final Entity superClassEntity = context.getCustomizing().getEntity(
				superClassOutline);

		return getInheritanceStrategy(context, superClassOutline,
				superClassEntity);
	}
}
 
Example 5
Project: org.fastnate   File: EntityClass.java   View source code 6 votes vote down vote up
/**
 * 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();
}
 
Example 6
Project: lams   File: InheritanceState.java   View source code 5 votes vote down vote up
private void extractInheritanceType() {
	XAnnotatedElement element = getClazz();
	Inheritance inhAnn = element.getAnnotation( Inheritance.class );
	MappedSuperclass mappedSuperClass = element.getAnnotation( MappedSuperclass.class );
	if ( mappedSuperClass != null ) {
		setEmbeddableSuperclass( true );
		setType( inhAnn == null ? null : inhAnn.strategy() );
	}
	else {
		setType( inhAnn == null ? InheritanceType.SINGLE_TABLE : inhAnn.strategy() );
	}
}
 
Example 7
Project: lams   File: AnnotationBinder.java   View source code 5 votes vote down vote up
/**
 * For the mapped entities build some temporary data-structure containing information about the
 * inheritance status of a class.
 *
 * @param orderedClasses Order list of all annotated entities and their mapped superclasses
 *
 * @return A map of {@code InheritanceState}s keyed against their {@code XClass}.
 */
public static Map<XClass, InheritanceState> buildInheritanceStates(
		List<XClass> orderedClasses,
		Mappings mappings) {
	ReflectionManager reflectionManager = mappings.getReflectionManager();
	Map<XClass, InheritanceState> inheritanceStatePerClass = new HashMap<XClass, InheritanceState>(
			orderedClasses.size()
	);
	for ( XClass clazz : orderedClasses ) {
		InheritanceState superclassState = InheritanceState.getSuperclassInheritanceState(
				clazz, inheritanceStatePerClass
		);
		InheritanceState state = new InheritanceState( clazz, inheritanceStatePerClass, mappings );
		if ( superclassState != null ) {
			//the classes are ordered thus preventing an NPE
			//FIXME if an entity has subclasses annotated @MappedSperclass wo sub @Entity this is wrong
			superclassState.setHasSiblings( true );
			InheritanceState superEntityState = InheritanceState.getInheritanceStateOfSuperEntity(
					clazz, inheritanceStatePerClass
			);
			state.setHasParents( superEntityState != null );
			final boolean nonDefault = state.getType() != null && !InheritanceType.SINGLE_TABLE
					.equals( state.getType() );
			if ( superclassState.getType() != null ) {
				final boolean mixingStrategy = state.getType() != null && !state.getType()
						.equals( superclassState.getType() );
				if ( nonDefault && mixingStrategy ) {
					LOG.invalidSubStrategy( clazz.getName() );
				}
				state.setType( superclassState.getType() );
			}
		}
		inheritanceStatePerClass.put( clazz, state );
	}
	return inheritanceStatePerClass;
}
 
Example 8
Project: lams   File: JPAOverriddenAnnotationReader.java   View source code 5 votes vote down vote up
private Inheritance getInheritance(Element tree, XMLContext.Default defaults) {
	Element element = tree != null ? tree.element( "inheritance" ) : null;
	if ( element != null ) {
		AnnotationDescriptor ad = new AnnotationDescriptor( Inheritance.class );
		Attribute attr = element.attribute( "strategy" );
		InheritanceType strategy = InheritanceType.SINGLE_TABLE;
		if ( attr != null ) {
			String value = attr.getValue();
			if ( "SINGLE_TABLE".equals( value ) ) {
				strategy = InheritanceType.SINGLE_TABLE;
			}
			else if ( "JOINED".equals( value ) ) {
				strategy = InheritanceType.JOINED;
			}
			else if ( "TABLE_PER_CLASS".equals( value ) ) {
				strategy = InheritanceType.TABLE_PER_CLASS;
			}
			else {
				throw new AnnotationException(
						"Unknown InheritanceType in XML: " + value + " (" + SCHEMA_VALIDATION + ")"
				);
			}
		}
		ad.setValue( "strategy", strategy );
		return AnnotationFactory.create( ad );
	}
	else if ( defaults.canUseJavaAnnotations() ) {
		return getPhysicalAnnotation( Inheritance.class );
	}
	else {
		return null;
	}
}
 
Example 9
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@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));
}
 
Example 10
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@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", 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(nodeLabel),
            Arrays.asList(baseClass, subClassA, subClassB));

    assertThat(clazz, equalTo(baseClass));
}
 
Example 11
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheClassNameWithTablePerClassInheritance() 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.TABLE_PER_CLASS);

    final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC, simpleClassNameA)._extends(jBaseClass);
    jSubclassA.annotate(Entity.class);

    final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclassB.annotate(Entity.class);

    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(simpleClassNameB),
            Arrays.asList(baseClass, subClassA, subClassB));

    assertThat(clazz, equalTo(subClassB));
}
 
Example 12
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheTableAnnotationWithTablePerClassInheritance() throws Exception {
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameA = "SubEntityClassA";
    final String simpleClassNameB = "SubEntityClassB";

    final String nodeLabelBase = "ENTITY_CLASS";
    final String nodeLabelA = "ENTITY_CLASS_A";
    final String nodeLabelB = "ENTITY_CLASS_B";

    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Table.class).param("name", nodeLabelBase);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.TABLE_PER_CLASS);

    final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC, simpleClassNameA)._extends(jBaseClass);
    jSubclassA.annotate(Entity.class);
    jSubclassA.annotate(Table.class).param("name", nodeLabelA);

    final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclassB.annotate(Entity.class);
    jSubclassB.annotate(Table.class).param("name", nodeLabelB);

    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(nodeLabelA),
            Arrays.asList(baseClass, subClassA, subClassB));

    assertThat(clazz, equalTo(subClassA));
}
 
Example 13
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheClassNameWithJoinedInheritance() 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.JOINED);

    final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC, simpleClassNameA)._extends(jBaseClass);
    jSubclassA.annotate(Entity.class);

    final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclassB.annotate(Entity.class);

    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(simpleClassNameB),
            Arrays.asList(baseClass, subClassA, subClassB));

    assertThat(clazz, equalTo(subClassB));
}
 
Example 14
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheTableAnnotationWithJoinedInheritance() throws Exception {
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameA = "SubEntityClassA";
    final String simpleClassNameB = "SubEntityClassB";

    final String nodeLabelBase = "ENTITY_CLASS";
    final String nodeLabelA = "ENTITY_CLASS_A";
    final String nodeLabelB = "ENTITY_CLASS_B";

    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Table.class).param("name", nodeLabelBase);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.JOINED);

    final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC, simpleClassNameA)._extends(jBaseClass);
    jSubclassA.annotate(Entity.class);
    jSubclassA.annotate(Table.class).param("name", nodeLabelA);

    final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclassB.annotate(Entity.class);
    jSubclassB.annotate(Table.class).param("name", nodeLabelB);

    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(nodeLabelA),
            Arrays.asList(baseClass, subClassA, subClassB));

    assertThat(clazz, equalTo(subClassA));
}
 
Example 15
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAFieldAnnotatedWithId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String idPropertyName = "key";

    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.TABLE_PER_CLASS);
    jBaseClass.field(JMod.PRIVATE, String.class, idPropertyName).annotate(Id.class);

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclass.annotate(Entity.class);

    buildModel(testFolder.getRoot(), jCodeModel);

    compileModel(testFolder.getRoot());

    final Class<?> subClass = loadClass(testFolder.getRoot(), jSubclass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(subClass);

    // THEN
    assertThat(namesOfIdProperties.size(), equalTo(1));
    assertThat(namesOfIdProperties, hasItem(idPropertyName));
}
 
Example 16
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAMethodAnnotatedWithId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String idPropertyName = "key";

    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.TABLE_PER_CLASS);
    jBaseClass.method(JMod.PUBLIC, jCodeModel.VOID, "getKey").annotate(Id.class);

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclass.annotate(Entity.class);

    buildModel(testFolder.getRoot(), jCodeModel);

    compileModel(testFolder.getRoot());

    final Class<?> subClass = loadClass(testFolder.getRoot(), jSubclass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(subClass);

    // THEN
    assertThat(namesOfIdProperties.size(), equalTo(1));
    assertThat(namesOfIdProperties, hasItem(idPropertyName));
}
 
Example 17
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAFieldAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jCodeModel.rootPackage();

    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC, "IdType");
    jIdTypeClass.annotate(Embeddable.class);
    jIdTypeClass.field(JMod.PRIVATE, Integer.class, id1PropertyName);
    jIdTypeClass.field(JMod.PRIVATE, String.class, id2PropertyName);

    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.TABLE_PER_CLASS);
    jBaseClass.field(JMod.PRIVATE, jIdTypeClass, compositeIdPropertyName).annotate(EmbeddedId.class);

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclass.annotate(Entity.class);

    buildModel(testFolder.getRoot(), jCodeModel);

    compileModel(testFolder.getRoot());

    final Class<?> entityClass = loadClass(testFolder.getRoot(), jSubclass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(entityClass);

    // THEN
    assertThat(namesOfIdProperties.size(), equalTo(2));
    assertThat(namesOfIdProperties,
            hasItems(compositeIdPropertyName + "." + id1PropertyName, compositeIdPropertyName + "." + id2PropertyName));
}
 
Example 18
Project: jpa-unit   File: EntityUtilsTest.java   View source code 5 votes vote down vote up
@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAMethodAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jCodeModel.rootPackage();

    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC, "IdType");
    jIdTypeClass.annotate(Embeddable.class);
    jIdTypeClass.field(JMod.PRIVATE, Integer.class, id1PropertyName);
    jIdTypeClass.field(JMod.PRIVATE, String.class, id2PropertyName);

    final JDefinedClass jBaseClass = jp._class(JMod.PUBLIC, simpleClassNameBase);
    jBaseClass.annotate(Entity.class);
    jBaseClass.annotate(Inheritance.class).param("strategy", InheritanceType.TABLE_PER_CLASS);
    final JMethod method = jBaseClass.method(JMod.PUBLIC, jIdTypeClass, "getCompositeKey");
    method.annotate(EmbeddedId.class);
    method.body()._return(JExpr._null());

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC, simpleClassNameB)._extends(jBaseClass);
    jSubclass.annotate(Entity.class);

    buildModel(testFolder.getRoot(), jCodeModel);

    compileModel(testFolder.getRoot());

    final Class<?> entityClass = loadClass(testFolder.getRoot(), jSubclass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(entityClass);

    // THEN
    assertThat(namesOfIdProperties.size(), equalTo(2));
    assertThat(namesOfIdProperties,
            hasItems(compositeIdPropertyName + "." + id1PropertyName, compositeIdPropertyName + "." + id2PropertyName));
}
 
Example 19
Project: cuba   File: MetadataImpl.java   View source code 5 votes vote down vote up
protected String getEntityNameForIdGeneration(MetaClass metaClass) {
    MetaClass result = metaClass.getAncestors().stream()
            .filter(mc -> {
                // use root of inheritance tree if the strategy is JOINED because ID is stored in the root table
                Class<?> javaClass = mc.getJavaClass();
                Inheritance inheritance = javaClass.getAnnotation(Inheritance.class);
                return inheritance != null && inheritance.strategy() == InheritanceType.JOINED;
            })
            .findFirst()
            .orElse(metaClass);
    return result.getName();
}
 
Example 20
Project: celerio   File: EntityConfigFactory.java   View source code 5 votes vote down vote up
private void resolveMissingInheritanceStrategyOnEntityConfigs(Map<String, EntityConfig> entityConfigsByEntityName) {
    for (EntityConfig entityConfig : entityConfigsByEntityName.values()) {
        if (!entityConfig.hasInheritance()) {
            continue;
        }

        EntityConfig current = entityConfig;
        while (current.hasParentEntityName()) {
            current = entityConfigsByEntityName.get(current.getParentEntityName().toUpperCase());
            Assert.notNull(current, "The parent entity " + current.getParentEntityName() + " could not be found in the configuration.");
        }
        // root may use default...
        if (!current.getInheritance().hasStrategy()) {
            // default...
            current.getInheritance().setStrategy(InheritanceType.SINGLE_TABLE);
        }

        if (entityConfig.getInheritance().hasStrategy()) {
            Assert.isTrue(
                    entityConfig.getInheritance().getStrategy() == current.getInheritance().getStrategy(),
                    "The entityConfig " + entityConfig.getEntityName()
                            + " must not declare an inheritance strategy that is different from the strategy declared in the root entity "
                            + current.getEntityName());
        }

        // for internal convenient purposes we propagate it
        entityConfig.getInheritance().setStrategy(current.getInheritance().getStrategy());
    }
}
 
Example 21
Project: celerio   File: Entity.java   View source code 5 votes vote down vote up
public boolean is(InheritanceType strategy) {
    Assert.notNull(strategy);
    if (getInheritance() == null) {
        return false;
    }
    return strategy == getInheritance().getStrategy();
}
 
Example 22
Project: celerio   File: Inheritance.java   View source code 5 votes vote down vote up
public boolean is(InheritanceType strategy) {
    return this.strategy == strategy;
}
 
Example 23
Project: hyperjaxb3   File: EntityMapping.java   View source code 5 votes vote down vote up
private void createEntity$Table(Mapping context, ClassOutline classOutline,
		Entity entity) {
	final InheritanceType inheritanceStrategy = getInheritanceStrategy(
			context, classOutline, entity);
	switch (inheritanceStrategy) {
	case JOINED:
		if (entity.getTable() == null) {
			entity.setTable(new Table());
		}
		createTable(context, classOutline, entity.getTable());
		break;
	case SINGLE_TABLE:
		if (isRootClass(context, classOutline)) {
			if (entity.getTable() == null) {
				entity.setTable(new Table());
			}
			createTable(context, classOutline, entity.getTable());
		} else {
			if (entity.getTable() != null) {
				entity.setTable(null);
			}
		}
		break;
	case TABLE_PER_CLASS:
		if (entity.getTable() == null) {
			entity.setTable(new Table());
		}
		createTable(context, classOutline, entity.getTable());
		break;
	default:
		throw new IllegalArgumentException("Unknown inheritance strategy.");
	}
}
 
Example 24
Project: org.fastnate   File: EntityClass.java   View source code 5 votes vote down vote up
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);
		}
	}
}
 
Example 25
Project: org.fastnate   File: EntityClass.java   View source code 5 votes vote down vote up
private void findHierarchyRoot(final Class<? super E> inspectedClass) {
	if (inspectedClass != null) {
		if (!inspectedClass.isAnnotationPresent(Entity.class)) {
			findHierarchyRoot(inspectedClass.getSuperclass());
		} else {
			this.parentEntityClass = inspectedClass;
			final EntityClass<? super E> parentDescription = this.context.getDescription(inspectedClass);
			this.accessStyle = parentDescription.getAccessStyle();
			if (parentDescription.inheritanceType == null) {
				parentDescription.inheritanceType = InheritanceType.SINGLE_TABLE;
				parentDescription.buildDiscriminator();
			}
			if (this.inheritanceType == null) {
				this.inheritanceType = parentDescription.inheritanceType;
				this.hierarchyRoot = parentDescription.hierarchyRoot;
			} else if (parentDescription.inheritanceType != InheritanceType.TABLE_PER_CLASS) {
				this.hierarchyRoot = parentDescription.hierarchyRoot;
			}
			if (parentDescription.getInheritanceType() == InheritanceType.JOINED) {
				this.joinedParentClass = parentDescription;
				buildPrimaryKeyJoinColumn();
			} else {
				if (parentDescription.getInheritanceType() == InheritanceType.SINGLE_TABLE) {
					this.table = parentDescription.table;
				}
				this.joinedParentClass = parentDescription.joinedParentClass;
				this.primaryKeyJoinColumn = parentDescription.primaryKeyJoinColumn;
			}
		}
	}
}
 
Example 26
Project: lams   File: InheritanceState.java   View source code 4 votes vote down vote up
boolean hasTable() {
	return !hasParents() || !InheritanceType.SINGLE_TABLE.equals( getType() );
}
 
Example 27
Project: lams   File: InheritanceState.java   View source code 4 votes vote down vote up
boolean hasDenormalizedTable() {
	return hasParents() && InheritanceType.TABLE_PER_CLASS.equals( getType() );
}
 
Example 28
Project: lams   File: InheritanceState.java   View source code 4 votes vote down vote up
public InheritanceType getType() {
	return type;
}
 
Example 29
Project: lams   File: InheritanceState.java   View source code 4 votes vote down vote up
public void setType(InheritanceType type) {
	this.type = type;
}
 
Example 30
Project: ibankapp-base   File: TestModelWithEumAndUnique.java   View source code 4 votes vote down vote up
@Column
@Enumerated(EnumType.STRING)
public InheritanceType getStatus() {
  return status;
}
 
Example 31
Project: ibankapp-base   File: TestModelWithEumAndUnique.java   View source code 4 votes vote down vote up
void setStatus(InheritanceType status) {
  this.status = status;
}
 
Example 32
Project: celerio   File: EntityConfig.java   View source code 4 votes vote down vote up
public boolean is(InheritanceType strategy) {
    return hasInheritance() && getInheritance().is(strategy);
}