Examples with MappingException org.hibernate.MappingException used on opensource projects

Example 1 with MappingException

use of org.hibernate.MappingException in project hibernate-orm by hibernate.

the class AuditedDynamicComponentTest method testAuditedDynamicComponentFailure.

//@Test
public void testAuditedDynamicComponentFailure() throws URISyntaxException {
    final Configuration config = new Configuration();
    final URL hbm = Thread.currentThread().getContextClassLoader().getResource("mappings/dynamicComponents/mapAudited.hbm.xml");
    config.addFile(new File(hbm.toURI()));
    final String auditStrategy = getAuditStrategy();
    if (!StringTools.isEmpty(auditStrategy)) {
        config.setProperty(EnversSettings.AUDIT_STRATEGY, auditStrategy);
    }
    final ServiceRegistry serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(config.getProperties());
    try {
        config.buildSessionFactory(serviceRegistry);
        Assert.fail("MappingException expected");
    } catch (MappingException e) {
        Assert.assertEquals("Audited dynamic-component properties are not supported. Consider applying @NotAudited annotation to " + AuditedDynamicComponentEntity.class.getName() + "#customFields.", e.getMessage());
    } finally {
        ServiceRegistryBuilder.destroy(serviceRegistry);
    }
}

Example 2 with MappingException

use of org.hibernate.MappingException in project hibernate-orm by hibernate.

the class EntitiesConfigurator method configure.

public EntitiesConfigurations configure(MetadataImplementor metadata, ServiceRegistry serviceRegistry, ReflectionManager reflectionManager, MappingCollector mappingCollector, GlobalConfiguration globalConfiguration, AuditEntitiesConfiguration auditEntitiesConfiguration, AuditStrategy auditStrategy, Document revisionInfoXmlMapping, Element revisionInfoRelationMapping) {
    // Creating a name register to capture all audit entity names created.
    final AuditEntityNameRegister auditEntityNameRegister = new AuditEntityNameRegister();
    // Sorting the persistent class topologically - superclass always beforeQuery subclass
    final Iterator<PersistentClass> classes = GraphTopologicalSort.sort(new PersistentClassGraphDefiner(metadata)).iterator();
    final ClassesAuditingData classesAuditingData = new ClassesAuditingData();
    final Map<PersistentClass, EntityXmlMappingData> xmlMappings = new HashMap<>();
    // Reading metadata from annotations
    while (classes.hasNext()) {
        final PersistentClass pc = classes.next();
        // Ensure we're in POJO, not dynamic model, mapping.
        if (pc.getClassName() != null) {
            // Collecting information from annotations on the persistent class pc
            final AnnotationsMetadataReader annotationsMetadataReader = new AnnotationsMetadataReader(globalConfiguration, reflectionManager, pc);
            final ClassAuditingData auditData = annotationsMetadataReader.getAuditData();
            classesAuditingData.addClassAuditingData(pc, auditData);
        }
    }
    // Now that all information is read we can update the calculated fields.
    classesAuditingData.updateCalculatedFields();
    final AuditMetadataGenerator auditMetaGen = new AuditMetadataGenerator(metadata, serviceRegistry, globalConfiguration, auditEntitiesConfiguration, auditStrategy, revisionInfoRelationMapping, auditEntityNameRegister);
    // First pass
    for (Map.Entry<PersistentClass, ClassAuditingData> pcDatasEntry : classesAuditingData.getAllClassAuditedData()) {
        final PersistentClass pc = pcDatasEntry.getKey();
        final ClassAuditingData auditData = pcDatasEntry.getValue();
        final EntityXmlMappingData xmlMappingData = new EntityXmlMappingData();
        if (auditData.isAudited()) {
            if (!StringTools.isEmpty(auditData.getAuditTable().value())) {
                auditEntitiesConfiguration.addCustomAuditTableName(pc.getEntityName(), auditData.getAuditTable().value());
            }
            auditMetaGen.generateFirstPass(pc, auditData, xmlMappingData, true);
        } else {
            auditMetaGen.generateFirstPass(pc, auditData, xmlMappingData, false);
        }
        xmlMappings.put(pc, xmlMappingData);
    }
    // Second pass
    for (Map.Entry<PersistentClass, ClassAuditingData> pcDatasEntry : classesAuditingData.getAllClassAuditedData()) {
        final EntityXmlMappingData xmlMappingData = xmlMappings.get(pcDatasEntry.getKey());
        if (pcDatasEntry.getValue().isAudited()) {
            auditMetaGen.generateSecondPass(pcDatasEntry.getKey(), pcDatasEntry.getValue(), xmlMappingData);
            try {
                mappingCollector.addDocument(xmlMappingData.getMainXmlMapping());
                for (Document additionalMapping : xmlMappingData.getAdditionalXmlMappings()) {
                    mappingCollector.addDocument(additionalMapping);
                }
            } catch (DocumentException e) {
                throw new MappingException(e);
            }
        }
    }
    // Only if there are any versioned classes
    if (auditMetaGen.getEntitiesConfigurations().size() > 0) {
        try {
            if (revisionInfoXmlMapping != null) {
                mappingCollector.addDocument(revisionInfoXmlMapping);
            }
        } catch (DocumentException e) {
            throw new MappingException(e);
        }
    }
    return new EntitiesConfigurations(auditMetaGen.getEntitiesConfigurations(), auditMetaGen.getNotAuditedEntitiesConfigurations());
}

Example 3 with MappingException

use of org.hibernate.MappingException in project hibernate-orm by hibernate.

the class RevisionInfoConfiguration method searchForRevisionInfoCfgInProperties.

private void searchForRevisionInfoCfgInProperties(XClass clazz, ReflectionManager reflectionManager, MutableBoolean revisionNumberFound, MutableBoolean revisionTimestampFound, MutableBoolean modifiedEntityNamesFound, String accessType) {
    for (XProperty property : clazz.getDeclaredProperties(accessType)) {
        final RevisionNumber revisionNumber = property.getAnnotation(RevisionNumber.class);
        final RevisionTimestamp revisionTimestamp = property.getAnnotation(RevisionTimestamp.class);
        final ModifiedEntityNames modifiedEntityNames = property.getAnnotation(ModifiedEntityNames.class);
        if (revisionNumber != null) {
            if (revisionNumberFound.isSet()) {
                throw new MappingException("Only one property may be annotated with @RevisionNumber!");
            }
            final XClass revisionNumberClass = property.getType();
            if (reflectionManager.equals(revisionNumberClass, Integer.class) || reflectionManager.equals(revisionNumberClass, Integer.TYPE)) {
                revisionInfoIdData = new PropertyData(property.getName(), property.getName(), accessType, null);
                revisionNumberFound.set();
            } else if (reflectionManager.equals(revisionNumberClass, Long.class) || reflectionManager.equals(revisionNumberClass, Long.TYPE)) {
                revisionInfoIdData = new PropertyData(property.getName(), property.getName(), accessType, null);
                revisionNumberFound.set();
                // The default is integer
                revisionPropType = "long";
            } else {
                throw new MappingException("The field annotated with @RevisionNumber must be of type " + "int, Integer, long or Long");
            }
            // Getting the @Column definition of the revision number property, to later use that info to
            // generate the same mapping for the relation from an audit table's revision number to the
            // revision entity revision number.
            final Column revisionPropColumn = property.getAnnotation(Column.class);
            if (revisionPropColumn != null) {
                revisionPropSqlType = revisionPropColumn.columnDefinition();
            }
        }
        if (revisionTimestamp != null) {
            if (revisionTimestampFound.isSet()) {
                throw new MappingException("Only one property may be annotated with @RevisionTimestamp!");
            }
            final XClass revisionTimestampClass = property.getType();
            if (reflectionManager.equals(revisionTimestampClass, Long.class) || reflectionManager.equals(revisionTimestampClass, Long.TYPE) || reflectionManager.equals(revisionTimestampClass, Date.class) || reflectionManager.equals(revisionTimestampClass, java.sql.Date.class)) {
                revisionInfoTimestampData = new PropertyData(property.getName(), property.getName(), accessType, null);
                revisionTimestampFound.set();
            } else {
                throw new MappingException("The field annotated with @RevisionTimestamp must be of type " + "long, Long, java.util.Date or java.sql.Date");
            }
        }
        if (modifiedEntityNames != null) {
            if (modifiedEntityNamesFound.isSet()) {
                throw new MappingException("Only one property may be annotated with @ModifiedEntityNames!");
            }
            final XClass modifiedEntityNamesClass = property.getType();
            if (reflectionManager.equals(modifiedEntityNamesClass, Set.class) && reflectionManager.equals(property.getElementClass(), String.class)) {
                modifiedEntityNamesData = new PropertyData(property.getName(), property.getName(), accessType, null);
                modifiedEntityNamesFound.set();
            } else {
                throw new MappingException("The field annotated with @ModifiedEntityNames must be of Set<String> type.");
            }
        }
    }
}

Example 4 with MappingException

use of org.hibernate.MappingException in project hibernate-orm by hibernate.

the class RevisionInfoConfiguration method configure.

public RevisionInfoConfigurationResult configure(MetadataImplementor metadata, ReflectionManager reflectionManager) {
    boolean revisionEntityFound = false;
    RevisionInfoGenerator revisionInfoGenerator = null;
    Class<?> revisionInfoClass = null;
    for (PersistentClass persistentClass : metadata.getEntityBindings()) {
        // Ensure we're in POJO, not dynamic model, mapping.
        if (persistentClass.getClassName() != null) {
            XClass clazz;
            try {
                clazz = reflectionManager.classForName(persistentClass.getClassName());
            } catch (ClassLoadingException e) {
                throw new MappingException(e);
            }
            final RevisionEntity revisionEntity = clazz.getAnnotation(RevisionEntity.class);
            if (revisionEntity != null) {
                if (revisionEntityFound) {
                    throw new MappingException("Only one entity may be annotated with @RevisionEntity!");
                }
                // Checking if custom revision entity isn't audited
                if (clazz.getAnnotation(Audited.class) != null) {
                    throw new MappingException("An entity annotated with @RevisionEntity cannot be audited!");
                }
                revisionEntityFound = true;
                final MutableBoolean revisionNumberFound = new MutableBoolean();
                final MutableBoolean revisionTimestampFound = new MutableBoolean();
                final MutableBoolean modifiedEntityNamesFound = new MutableBoolean();
                searchForRevisionInfoCfg(clazz, reflectionManager, revisionNumberFound, revisionTimestampFound, modifiedEntityNamesFound);
                if (!revisionNumberFound.isSet()) {
                    throw new MappingException("An entity annotated with @RevisionEntity must have a field annotated " + "with @RevisionNumber!");
                }
                if (!revisionTimestampFound.isSet()) {
                    throw new MappingException("An entity annotated with @RevisionEntity must have a field annotated " + "with @RevisionTimestamp!");
                }
                revisionInfoEntityName = persistentClass.getEntityName();
                revisionInfoClass = persistentClass.getMappedClass();
                final Class<? extends RevisionListener> revisionListenerClass = getRevisionListenerClass(revisionEntity.value());
                revisionInfoTimestampType = persistentClass.getProperty(revisionInfoTimestampData.getName()).getType();
                if (globalCfg.isTrackEntitiesChangedInRevision() || (globalCfg.isUseRevisionEntityWithNativeId() && DefaultTrackingModifiedEntitiesRevisionEntity.class.isAssignableFrom(revisionInfoClass)) || (!globalCfg.isUseRevisionEntityWithNativeId() && SequenceIdTrackingModifiedEntitiesRevisionEntity.class.isAssignableFrom(revisionInfoClass)) || modifiedEntityNamesFound.isSet()) {
                    // If tracking modified entities parameter is enabled, custom revision info entity is a subtype
                    // of DefaultTrackingModifiedEntitiesRevisionEntity class, or @ModifiedEntityNames annotation is used.
                    revisionInfoGenerator = new DefaultTrackingModifiedEntitiesRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass, revisionListenerClass, revisionInfoTimestampData, isTimestampAsDate(), modifiedEntityNamesData, metadata.getMetadataBuildingOptions().getServiceRegistry());
                    globalCfg.setTrackEntitiesChangedInRevision(true);
                } else {
                    revisionInfoGenerator = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass, revisionListenerClass, revisionInfoTimestampData, isTimestampAsDate(), metadata.getMetadataBuildingOptions().getServiceRegistry());
                }
            }
        }
    }
    // In case of a custom revision info generator, the mapping will be null.
    Document revisionInfoXmlMapping = null;
    final Class<? extends RevisionListener> revisionListenerClass = getRevisionListenerClass(RevisionListener.class);
    if (revisionInfoGenerator == null) {
        if (globalCfg.isTrackEntitiesChangedInRevision()) {
            revisionInfoClass = globalCfg.isUseRevisionEntityWithNativeId() ? DefaultTrackingModifiedEntitiesRevisionEntity.class : SequenceIdTrackingModifiedEntitiesRevisionEntity.class;
            revisionInfoEntityName = revisionInfoClass.getName();
            revisionInfoGenerator = new DefaultTrackingModifiedEntitiesRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass, revisionListenerClass, revisionInfoTimestampData, isTimestampAsDate(), modifiedEntityNamesData, metadata.getMetadataBuildingOptions().getServiceRegistry());
        } else {
            revisionInfoClass = globalCfg.isUseRevisionEntityWithNativeId() ? DefaultRevisionEntity.class : SequenceIdRevisionEntity.class;
            revisionInfoGenerator = new DefaultRevisionInfoGenerator(revisionInfoEntityName, revisionInfoClass, revisionListenerClass, revisionInfoTimestampData, isTimestampAsDate(), metadata.getMetadataBuildingOptions().getServiceRegistry());
        }
        revisionInfoXmlMapping = generateDefaultRevisionInfoXmlMapping();
    }
    return new RevisionInfoConfigurationResult(revisionInfoGenerator, revisionInfoXmlMapping, new RevisionInfoQueryCreator(revisionInfoEntityName, revisionInfoIdData.getName(), revisionInfoTimestampData.getName(), isTimestampAsDate()), generateRevisionInfoRelationMapping(), new RevisionInfoNumberReader(revisionInfoClass, revisionInfoIdData, metadata.getMetadataBuildingOptions().getServiceRegistry()), globalCfg.isTrackEntitiesChangedInRevision() ? new ModifiedEntityNamesReader(revisionInfoClass, modifiedEntityNamesData, metadata.getMetadataBuildingOptions().getServiceRegistry()) : null, revisionInfoEntityName, revisionInfoClass, revisionInfoTimestampData);
}

Example 5 with MappingException

use of org.hibernate.MappingException in project querydsl by querydsl.

the class JPADomainExporter method handleProperty.

private void handleProperty(EntityType entityType, Class<?> cl, Attribute<?, ?> p) throws NoSuchMethodException, ClassNotFoundException {
    Class<?> clazz = Object.class;
    try {
        clazz = p.getJavaType();
    } catch (MappingException e) {
    // ignore
    }
    Type propertyType = getType(cl, clazz, p.getName());
    AnnotatedElement annotated = getAnnotatedElement(cl, p.getName());
    propertyType = getTypeOverride(propertyType, annotated);
    if (propertyType == null) {
        return;
    }
    if (p.isCollection()) {
        if (p instanceof MapAttribute) {
            MapAttribute<?, ?, ?> map = (MapAttribute<?, ?, ?>) p;
            Type keyType = typeFactory.get(map.getKeyJavaType());
            Type valueType = typeFactory.get(map.getElementType().getJavaType());
            valueType = getPropertyType(p, valueType);
            propertyType = new SimpleType(propertyType, normalize(propertyType.getParameters().get(0), keyType), normalize(propertyType.getParameters().get(1), valueType));
        } else {
            Type valueType = typeFactory.get(((PluralAttribute<?, ?, ?>) p).getElementType().getJavaType());
            valueType = getPropertyType(p, valueType);
            propertyType = new SimpleType(propertyType, normalize(propertyType.getParameters().get(0), valueType));
        }
    } else {
        propertyType = getPropertyType(p, propertyType);
    }
    Property property = createProperty(entityType, p.getName(), propertyType, annotated);
    entityType.addProperty(property);
}