예제 #1
0
  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);
  }
  private static GenerationStrategyPair buildGenerationStrategyPair(
      final SessionFactoryImplementor sessionFactory, final Property mappingProperty) {
    final ValueGeneration valueGeneration = mappingProperty.getValueGenerationStrategy();
    if (valueGeneration != null
        && valueGeneration.getGenerationTiming() != GenerationTiming.NEVER) {
      // the property is generated in full. build the generation strategy pair.
      if (valueGeneration.getValueGenerator() != null) {
        // in-memory generation
        return new GenerationStrategyPair(
            FullInMemoryValueGenerationStrategy.create(valueGeneration));
      } else {
        // in-db generation
        return new GenerationStrategyPair(create(sessionFactory, mappingProperty, valueGeneration));
      }
    } else if (mappingProperty.getValue() instanceof Component) {
      final CompositeGenerationStrategyPairBuilder builder =
          new CompositeGenerationStrategyPairBuilder(mappingProperty);
      interpretPartialCompositeValueGeneration(
          sessionFactory, (Component) mappingProperty.getValue(), builder);
      return builder.buildPair();
    }

    return NO_GEN_PAIR;
  }
 private static boolean isUpdateGenerated(Property property) {
   return property.getValueGenerationStrategy() != null
       && property.getValueGenerationStrategy().getGenerationTiming() == GenerationTiming.ALWAYS;
 }
 private boolean isInsertGenerated(Property property) {
   return property.getValueGenerationStrategy() != null
       && property.getValueGenerationStrategy().getGenerationTiming() != GenerationTiming.NEVER;
 }
  /**
   * 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");
        }
    }
  }