private static void registerEntityNameResolvers(EntityPersister persister, Map<EntityNameResolver,Object> entityNameResolvers) { if ( persister.getEntityMetamodel() == null || persister.getEntityMetamodel().getTuplizer() == null ) { return; } registerEntityNameResolvers( persister.getEntityMetamodel().getTuplizer(), entityNameResolvers ); }
private String[] formulaTemplates(String reference, int expectedSize) { try { final int propertyIndex = elementPersister.getEntityMetamodel().getPropertyIndex( reference ); return ( (Queryable) elementPersister ).getSubclassPropertyFormulaTemplateClosure()[propertyIndex]; } catch (Exception e) { return new String[expectedSize]; } }
private EntityMode getEntityMode(Criteria criteria, CriteriaQuery criteriaQuery) { final EntityPersister meta = criteriaQuery.getFactory().getEntityPersister( criteriaQuery.getEntityName( criteria ) ); final EntityMode result = meta.getEntityMode(); if ( ! meta.getEntityMetamodel().getTuplizer().isInstance( exampleEntity ) ) { throw new ClassCastException( exampleEntity.getClass().getName() ); } return result; }
public CollectionKey(CollectionPersister persister, Serializable key) { this( persister.getRole(), key, persister.getKeyType(), persister.getOwnerEntityPersister().getEntityMetamodel().getEntityMode(), persister.getFactory() ); }
@Override public AnyMappingDefinition toAnyDefinition() { return new StandardAnyTypeDefinition( (AnyType) getType(), getSource().getEntityMetamodel().getProperties()[ attributeNumber() ].isLazy() ); }
@Override public ExpandingEntityQuerySpace makeEntityQuerySpace( String uid, EntityPersister entityPersister, boolean canJoinsBeRequired) { checkQuerySpaceDoesNotExist( uid ); // as a temporary fix for HHH-8980 and HHH-8830 we circumvent allowing // inner joins (canJoinsBeRequired) when the persister is part of an // entity inheritance. // // hasSubclasses() is the closest we can come to even knowing if the // entity is part of a hierarchy. But its enough, since if there are no // subclasses we cannot have the case where the attribute to join comes from // a subclass :) // // a better long term fix is to expose whether a joined association attribute // is defined on the class/superClass(es) or on the subClass(es). Attributes // from the subClass(es) should not be inner joined; it is ok to inner join // attributes from the class/superClass(es). final EntityQuerySpaceImpl space = new EntityQuerySpaceImpl( entityPersister, uid, this, canJoinsBeRequired && !entityPersister.getEntityMetamodel().hasSubclasses() ); registerQuerySpace( space ); return space; }
private EntityMetamodel getDeclarerEntityMetamodel(AbstractIdentifiableType<?> ownerType) { final Type.PersistenceType persistenceType = ownerType.getPersistenceType(); if ( persistenceType == Type.PersistenceType.ENTITY ) { return context.getSessionFactory() .getMetamodel() .entityPersister( ownerType.getTypeName() ) .getEntityMetamodel(); } else if ( persistenceType == Type.PersistenceType.MAPPED_SUPERCLASS ) { PersistentClass persistentClass = context.getPersistentClassHostingProperties( (MappedSuperclassTypeImpl<?>) ownerType ); return context.getSessionFactory() .getMetamodel() .entityPersister( persistentClass.getClassName() ) .getEntityMetamodel(); } else { throw new AssertionFailure( "Cannot get the metamodel for PersistenceType: " + persistenceType ); } }
@Test public void testTypeSelection() { int index = sessionFactory().getEntityPersister( MaterializedBlobEntity.class.getName() ).getEntityMetamodel().getPropertyIndex( "theBytes" ); Type type = sessionFactory().getEntityPersister( MaterializedBlobEntity.class.getName() ).getEntityMetamodel().getProperties()[index].getType(); assertEquals( MaterializedBlobType.INSTANCE, type ); }
public void associationProcessed(OuterJoinableAssociation oja, int position) { associationsByAlias.put( oja.getRhsAlias(), oja ); positionsByAlias.put( oja.getRhsAlias(), position ); EntityPersister entityPersister = null; if ( oja.getJoinableType().isCollectionType() ) { entityPersister = ( ( QueryableCollection) oja.getJoinable() ).getElementPersister(); } else if ( oja.getJoinableType().isEntityType() ) { entityPersister = ( EntityPersister ) oja.getJoinable(); } if ( entityPersister != null && entityPersister.getIdentifierType().isComponentType() && ! entityPersister.getEntityMetamodel().getIdentifierProperty().isEmbedded() && hasAssociation( (CompositeType) entityPersister.getIdentifierType() ) ) { aliasesForAssociationsWithCompositesIds.add( oja.getRhsAlias() ); } }
/** * give the interceptor an opportunity to override the default instantiation */ @Override public Object instantiate(EntityPersister persister, Serializable id) throws HibernateException { checkOpenOrWaitingForAutoClose(); checkTransactionSynchStatus(); Object result = getInterceptor().instantiate( persister.getEntityName(), persister.getEntityMetamodel().getEntityMode(), id ); if ( result == null ) { result = persister.instantiate( id, this ); } delayedAfterCompletion(); return result; }
public String[] getIdentifierPropertyNames() { if ( getEntityPersister() != null ) { String identifierPropertyName = getEntityPersister().getIdentifierPropertyName(); if ( identifierPropertyName != null ) { return new String[] { identifierPropertyName }; } else { final IdentifierProperty identifierProperty = getEntityPersister().getEntityMetamodel() .getIdentifierProperty(); if ( identifierProperty.hasIdentifierMapper() && !identifierProperty.isEmbedded() ) { return new String[] { PropertyPath.IDENTIFIER_MAPPER_PROPERTY }; } else { if ( EmbeddedComponentType.class.isInstance( identifierProperty.getType() ) ) { return ( (EmbeddedComponentType) identifierProperty.getType() ).getPropertyNames(); } } } } return new String[] { EntityPersister.ENTITY_ID }; } }
&& !entityPersister.getEntityMetamodel().getIdentifierProperty().isVirtual() && entityPersister.getEntityMetamodel().getIdentifierProperty().isEmbedded() ) {
@Test @TestForIssue( jiraKey = "HHH-10360") public void testNaturalIdNullability() { final EntityPersister persister = sessionFactory().getEntityPersister( Account.class.getName() ); final int propertyIndex = persister.getEntityMetamodel().getPropertyIndex( "shortCode" ); // the natural ID mapped as non-nullable assertFalse( persister.getPropertyNullability()[propertyIndex] ); }
@Test @TestForIssue( jiraKey = "HHH-10360") public void testNaturalIdNullability() { final EntityPersister persister = sessionFactory().getEntityPersister( User.class.getName() ); final int propertyIndex = persister.getEntityMetamodel().getPropertyIndex( "userName" ); // nullability is not specified, so it should be non-nullable by hbm-specific default assertFalse( persister.getPropertyNullability()[propertyIndex] ); }
@Test @TestForIssue( jiraKey = "HHH-10360") public void testNaturalIdNullability() { final EntityPersister persister = sessionFactory().getEntityPersister( User.class.getName() ); final EntityMetamodel entityMetamodel = persister.getEntityMetamodel(); // nullability is not specified, so it should be nullable by annotations-specific default assertTrue( persister.getPropertyNullability()[entityMetamodel.getPropertyIndex( "uid" )] ); }
if ( persister.getEntityMetamodel().getIdentifierProperty().isEmbedded() ) { final EmbeddedComponentType dependentIdType = (EmbeddedComponentType) persister.getEntityMetamodel().getIdentifierProperty().getType(); if ( dependentIdType.getSubtypes().length == 1 ) { final Type singleSubType = dependentIdType.getSubtypes()[0];
private void assertAccessType(SessionFactoryImplementor factory, Class<?> classUnderTest, AccessType accessType) { EntityTuplizer tuplizer = factory.getEntityPersister( classUnderTest.getName() ) .getEntityMetamodel() .getTuplizer(); if ( AccessType.FIELD.equals( accessType ) ) { Assert.assertTrue( "Field access was expected.", tuplizer.getGetter( 0 ) instanceof GetterFieldImpl ); } else { Assert.assertTrue( "Property access was expected.", tuplizer.getGetter( 0 ) instanceof GetterMethodImpl ); } } }
public enum NullabilityCheckType { CREATE, UPDATE, DELETE }
@Test public void test() { doInHibernate( this::sessionFactory, s -> { TestEntity entity = s.get( TestEntity.class, entityId ); Assert.assertFalse( Hibernate.isPropertyInitialized( entity, "description" ) ); EntityPersister entityPersister = sessionFactory().getMetamodel().entityPersister( TestEntity.class ); boolean[] propertyLaziness = entityPersister.getPropertyLaziness(); assertEquals( 1, propertyLaziness.length ); assertTrue( propertyLaziness[0] ); // Make sure NonIdentifierAttribute#isLazy is consistent (HHH-10551) NonIdentifierAttribute[] properties = entityPersister.getEntityMetamodel().getProperties(); assertEquals( 1, properties.length ); assertTrue( properties[0].isLazy() ); } ); }
private void checkInterceptor(Parent parent, boolean isNullExpected) { final BytecodeEnhancementMetadata bytecodeEnhancementMetadata = sessionFactory() .getMetamodel() .entityPersister( Parent.class ) .getEntityMetamodel() .getBytecodeEnhancementMetadata(); if ( isNullExpected ) { // if a null Interceptor is expected, then there shouldn't be any uninitialized attributes assertFalse( bytecodeEnhancementMetadata.hasUnFetchedAttributes( parent ) ); assertNull( bytecodeEnhancementMetadata.extractInterceptor( parent ) ); } else { assertNotNull( bytecodeEnhancementMetadata.extractInterceptor( parent ) ); } }