/** * @deprecated (since 5.2) Use {@link MetamodelImplementor#entityPersister(Class)} instead. */ @Deprecated default EntityPersister getEntityPersister(String entityName) throws MappingException { return getMetamodel().entityPersister( entityName ); }
/** * @deprecated (since 5.2) Use {@link MetamodelImplementor#collectionPersister(String)} instead. */ @Deprecated default CollectionPersister getCollectionPersister(String role) throws MappingException { return getMetamodel().collectionPersister( role ); }
/** * @deprecated (since 5.2) Use {@link MetamodelImplementor#collectionPersisters} instead. */ @Deprecated default Map<String, CollectionPersister> getCollectionPersisters() { return getMetamodel().collectionPersisters(); }
/** * Locate the persister by class or entity name. * * @param name The class or entity name * * @return The defined persister for this entity, or null if none found. * * @throws MappingException */ public EntityPersister findEntityPersisterByName(String name) throws MappingException { // First, try to get the persister using the given name directly. EntityPersister persister = sfi.getMetamodel().entityPersisters().get( name ); if ( persister != null ) { return persister; } // If that didn't work, try using the 'import' name. String importedClassName = sfi.getMetamodel().getImportedClassName( name ); if ( importedClassName == null ) { return null; } return sfi.getMetamodel().entityPersister( importedClassName ); }
Queryable getEntityPersisterUsingImports(String className) { final String importedClassName = getFactory().getMetamodel().getImportedClassName( className ); if ( importedClassName == null ) { return null; } try { return (Queryable) getFactory().getMetamodel().entityPersister( importedClassName ); } catch (MappingException me) { return null; } }
@SuppressWarnings("unchecked") public static <T, S extends T> ManagedTypeDescriptor<S> resolveSubType( ManagedTypeDescriptor<T> baseType, String subTypeName, SessionFactoryImplementor sessionFactory) { final MetamodelImplementor metamodel = sessionFactory.getMetamodel(); if ( baseType instanceof EmbeddedTypeDescriptor<?> ) { // todo : at least validate the string is a valid sub-type of the embeddable class? return (ManagedTypeDescriptor) baseType; } final String importedClassName = metamodel.getImportedClassName( subTypeName ); if ( importedClassName != null ) { // first, try to find it by name directly.. ManagedTypeDescriptor<S> subManagedType = metamodel.entity( importedClassName ); if ( subManagedType != null ) { return subManagedType; } // it could still be a mapped-superclass try { final Class<S> subTypeClass = sessionFactory.getServiceRegistry() .getService( ClassLoaderService.class ) .classForName( importedClassName ); return metamodel.managedType( subTypeClass ); } catch (Exception ignore) { } } throw new IllegalArgumentException( "Unknown sub-type name (" + baseType.getName() + ") : " + subTypeName ); }
sessionFactory().getMetamodel().entityPersister( Item.class ).getNavigableRole() ); assertThat( sessionFactory().getMetamodel().entityPersister( VersionedItem.class ).getCacheAccessStrategy().getAccessType(), equalTo( AccessType.READ_WRITE ) ); sessionFactory().getMetamodel().entityPersister( Event.class ).getCacheAccessStrategy().getAccessType(), equalTo( AccessType.READ_WRITE ) ); .collectionPersister( Event.class.getName() + ".participants" ) .getCacheAccessStrategy() .getAccessType(),
(SessionFactoryImplementor) metadataBuilder.build().buildSessionFactory() ) { final TypeConfiguration typeConfiguration = sessionFactory.getMetamodel().getTypeConfiguration(); final EntityPersister entityPersister = sessionFactory.getMetamodel().entityPersister( MyEntity.class ); final AttributeConverterTypeAdapter geometryAttributeType = assertTyping( AttributeConverterTypeAdapter.class,
/** * @deprecated (since 5.2) Use {@link MetamodelImplementor#entityPersisters} instead. */ @Deprecated default Map<String,EntityPersister> getEntityPersisters() { return getMetamodel().entityPersisters(); }
@Override default EntityTypeDescriptor getEntityTypeByName(String entityName) { return entity( entityName ); } }
for ( EntityPersister persister : factory.getMetamodel().entityPersisters().values() ) { final String[] entitySpaces = (String[]) persister.getQuerySpaces(); if ( affectedEntity( tableSpaces, entitySpaces ) ) { final Set<String> roles = session.getFactory().getMetamodel().getCollectionRolesByEntityParticipant( persister.getEntityName() ); if ( roles != null ) { for ( String role : roles ) { final CollectionPersister collectionPersister = factory.getMetamodel().collectionPersister( role ); if ( collectionPersister.hasCache() ) { collectionCleanups.add(
/** * Retrieve the {@link Type} resolver associated with this factory. * * @return The type resolver * * @deprecated (since 5.3) No replacement, access to and handling of Types will be much different in 6.0 */ @Deprecated public TypeResolver getTypeResolver() { return metamodel.getTypeConfiguration().getTypeResolver(); }
@Override public Set<AssociationKeyMetadata> getAllAssociationKeyMetadata() { Set<AssociationKeyMetadata> allAssociationKeyMetadata = new HashSet<>(); for ( CollectionPersister associationPersister : factory.getMetamodel().collectionPersisters().values() ) { allAssociationKeyMetadata.add( ( (OgmCollectionPersister) associationPersister ).getAssociationKeyMetadata() ); } for ( EntityPersister entityPersister : factory.getMetamodel().entityPersisters().values() ) { for ( String property : entityPersister.getPropertyNames() ) { AssociationKeyMetadata inverseOneToOneAssociationKeyMetadata = ( (OgmEntityPersister) entityPersister ).getInverseOneToOneAssociationKeyMetadata( property ); if ( inverseOneToOneAssociationKeyMetadata != null ) { allAssociationKeyMetadata.add( inverseOneToOneAssociationKeyMetadata ); } } } return allAssociationKeyMetadata; }
final Set<String> roles = factory.getMetamodel().getCollectionRolesByEntityParticipant( persister.getEntityName() ); if ( roles != null ) { for ( String role : roles ) { final CollectionPersister collectionPersister = factory.getMetamodel().collectionPersister( role ); if ( collectionPersister.hasCache() ) { collectionCleanups.add(
@SuppressWarnings("unchecked") public static <T, S extends T> ManagedTypeDescriptor<S> resolveSubType( ManagedTypeDescriptor<T> baseType, String subTypeName, SessionFactoryImplementor sessionFactory) { final MetamodelImplementor metamodel = sessionFactory.getMetamodel(); if ( baseType instanceof EmbeddedTypeDescriptor<?> ) { // todo : at least validate the string is a valid sub-type of the embeddable class? return (ManagedTypeDescriptor) baseType; } final String importedClassName = metamodel.getImportedName( subTypeName ); if ( importedClassName != null ) { // first, try to find it by name directly.. ManagedTypeDescriptor<S> subManagedType = metamodel.entity( importedClassName ); if ( subManagedType != null ) { return subManagedType; } // it could still be a mapped-superclass try { final Class<S> subTypeClass = sessionFactory.getServiceRegistry() .getService( ClassLoaderService.class ) .classForName( importedClassName ); return metamodel.managedType( subTypeClass ); } catch (Exception ignore) { } } throw new IllegalArgumentException( "Unknown sub-type name (" + baseType.getDomainTypeName() + ") : " + subTypeName ); }
CollectionReturn collRtn = (CollectionReturn) ownerDescriptor; String role = collRtn.getOwnerEntityName() + "." + collRtn.getOwnerProperty(); CollectionPersister persister = getFactory().getMetamodel().collectionPersister( role ); EntityType ownerType = (EntityType) persister.getElementType(); entityName = ownerType.getAssociatedEntityName( getFactory() ); return (Queryable) getFactory().getMetamodel().entityPersister( entityName );
@Override public void evictEntityData() { sessionFactory.getMetamodel().entityPersisters().values().forEach( this::evictEntityData ); }
public Root from(Class<T> entityClass) { EntityType<T> entityType = criteriaBuilder.getEntityManagerFactory() .getMetamodel() .entity( entityClass ); if ( entityType == null ) { throw new IllegalArgumentException( entityClass + " is not an entity" ); } return from( entityType ); }
.getTypeConfiguration() .getJdbcToHibernateTypeContributionMap() .get( columnType );
@Override public EntityStatisticsImpl getEntityStatistics(String entityName) { if ( sessionFactory == null ) { return null; } return entityStatsMap.computeIfAbsent( entityName, s -> new EntityStatisticsImpl( sessionFactory.getMetamodel().entityPersister( entityName ) ) ); }