protected boolean isRequiredInConstructor(Property field) { if (hasMetaAttribute(field, "default-value")) { return false; } if (field.getValue() != null) { if (!field.isOptional() && (field.getValueGenerationStrategy() == null || field .getValueGenerationStrategy() .getGenerationTiming() .equals(GenerationTiming.NEVER))) { return true; } else if (field.getValue() instanceof Component) { Component c = (Component) field.getValue(); Iterator<?> it = c.getPropertyIterator(); while (it.hasNext()) { Property prop = (Property) it.next(); if (isRequiredInConstructor(prop)) { return true; } } } } return false; }
@Deprecated public static StandardProperty buildStandardProperty(Property property, boolean lazyAvailable) { final Type type = property.getValue().getType(); // we need to dirty check collections, since they can cause an owner // version number increment // we need to dirty check many-to-ones with not-found="ignore" in order // to update the cache (not the database), since in this case a null // entity reference can lose information boolean alwaysDirtyCheck = type.isAssociationType() && ((AssociationType) type).isAlwaysDirtyChecked(); return new StandardProperty( property.getName(), type, lazyAvailable && property.isLazy(), property.isInsertable(), property.isUpdateable(), property.getValueGenerationStrategy(), property.isOptional(), alwaysDirtyCheck || property.isUpdateable(), property.isOptimisticLocked(), property.getCascadeStyle(), property.getValue().getFetchMode()); }
/** * Generates a VersionProperty representation for an entity mapping given its version mapping * Property. * * @param property The version mapping Property. * @param lazyAvailable Is property lazy loading currently available. * @return The appropriate VersionProperty definition. */ public static VersionProperty buildVersionProperty( EntityPersister persister, SessionFactoryImplementor sessionFactory, int attributeNumber, Property property, boolean lazyAvailable) { String mappedUnsavedValue = ((KeyValue) property.getValue()).getNullValue(); VersionValue unsavedValue = UnsavedValueFactory.getUnsavedVersionValue( mappedUnsavedValue, getGetter(property), (VersionType) property.getType(), getConstructor(property.getPersistentClass())); boolean lazy = lazyAvailable && property.isLazy(); return new VersionProperty( persister, sessionFactory, attributeNumber, property.getName(), property.getValue().getType(), new BaselineAttributeInformation.Builder() .setLazy(lazy) .setInsertable(property.isInsertable()) .setUpdateable(property.isUpdateable()) .setValueGenerationStrategy(property.getValueGenerationStrategy()) .setNullable(property.isOptional()) .setDirtyCheckable(property.isUpdateable() && !lazy) .setVersionable(property.isOptimisticLocked()) .setCascadeStyle(property.getCascadeStyle()) .createInformation(), unsavedValue); }
/** * Build a normal attribute. * * @param ownerType The descriptor of the attribute owner (aka declarer). * @param property The Hibernate property descriptor for the attribute * @param <X> The type of the owner * @param <Y> The attribute type * @return The built attribute descriptor or null if the attribute is not part of the JPA 2 model * (eg backrefs) */ @SuppressWarnings({"unchecked"}) public <X, Y> AttributeImplementor<X, Y> buildAttribute( AbstractManagedType<X> ownerType, Property property) { if (property.isSynthetic()) { // hide synthetic/virtual properties (fabricated by Hibernate) from the JPA metamodel. LOG.tracef( "Skipping synthetic property %s(%s)", ownerType.getJavaType().getName(), property.getName()); return null; } LOG.trace( "Building attribute [" + ownerType.getJavaType().getName() + "." + property.getName() + "]"); final AttributeContext<X> attributeContext = wrap(ownerType, property); final AttributeMetadata<X, Y> attributeMetadata = determineAttributeMetadata(attributeContext, NORMAL_MEMBER_RESOLVER); if (attributeMetadata == null) { return null; } if (attributeMetadata.isPlural()) { return buildPluralAttribute((PluralAttributeMetadata) attributeMetadata); } final SingularAttributeMetadata<X, Y> singularAttributeMetadata = (SingularAttributeMetadata<X, Y>) attributeMetadata; final Type<Y> metaModelType = getMetaModelType(singularAttributeMetadata.getValueContext()); return new SingularAttributeImpl<X, Y>( attributeMetadata.getName(), attributeMetadata.getJavaType(), ownerType, attributeMetadata.getMember(), false, false, property.isOptional(), metaModelType, attributeMetadata.getPersistentAttributeType()); }
/** * Generate a non-identifier (and non-version) attribute based on the given mapped property from * the given entity * * @param property The mapped property. * @param lazyAvailable Is property lazy loading currently available. * @return The appropriate NonIdentifierProperty definition. */ public static NonIdentifierAttribute buildEntityBasedAttribute( EntityPersister persister, SessionFactoryImplementor sessionFactory, int attributeNumber, Property property, boolean lazyAvailable) { final Type type = property.getValue().getType(); final NonIdentifierAttributeNature nature = decode(type); // we need to dirty check collections, since they can cause an owner // version number increment // we need to dirty check many-to-ones with not-found="ignore" in order // to update the cache (not the database), since in this case a null // entity reference can lose information boolean alwaysDirtyCheck = type.isAssociationType() && ((AssociationType) type).isAlwaysDirtyChecked(); switch (nature) { case BASIC: { return new EntityBasedBasicAttribute( persister, sessionFactory, attributeNumber, property.getName(), type, new BaselineAttributeInformation.Builder() .setLazy(lazyAvailable && property.isLazy()) .setInsertable(property.isInsertable()) .setUpdateable(property.isUpdateable()) .setValueGenerationStrategy(property.getValueGenerationStrategy()) .setNullable(property.isOptional()) .setDirtyCheckable(alwaysDirtyCheck || property.isUpdateable()) .setVersionable(property.isOptimisticLocked()) .setCascadeStyle(property.getCascadeStyle()) .setFetchMode(property.getValue().getFetchMode()) .createInformation()); } case COMPOSITE: { return new EntityBasedCompositionAttribute( persister, sessionFactory, attributeNumber, property.getName(), (CompositeType) type, new BaselineAttributeInformation.Builder() .setLazy(lazyAvailable && property.isLazy()) .setInsertable(property.isInsertable()) .setUpdateable(property.isUpdateable()) .setValueGenerationStrategy(property.getValueGenerationStrategy()) .setNullable(property.isOptional()) .setDirtyCheckable(alwaysDirtyCheck || property.isUpdateable()) .setVersionable(property.isOptimisticLocked()) .setCascadeStyle(property.getCascadeStyle()) .setFetchMode(property.getValue().getFetchMode()) .createInformation()); } case ENTITY: case ANY: case COLLECTION: { return new EntityBasedAssociationAttribute( persister, sessionFactory, attributeNumber, property.getName(), (AssociationType) type, new BaselineAttributeInformation.Builder() .setLazy(lazyAvailable && property.isLazy()) .setInsertable(property.isInsertable()) .setUpdateable(property.isUpdateable()) .setValueGenerationStrategy(property.getValueGenerationStrategy()) .setNullable(property.isOptional()) .setDirtyCheckable(alwaysDirtyCheck || property.isUpdateable()) .setVersionable(property.isOptimisticLocked()) .setCascadeStyle(property.getCascadeStyle()) .setFetchMode(property.getValue().getFetchMode()) .createInformation()); } default: { throw new HibernateException("Internal error"); } } }