Пример #1
0
  @Configuration
  public Option[] config() throws Exception {
    final Properties paxExamEnvironment = loadPaxExamEnvironmentProperties();

    final boolean debug =
        ConfigurationHelper.getBoolean(
            "org.hibernate.testing.osgi.paxExam.debug", Environment.getProperties(), DEBUG);

    return options(
        when(debug).useOptions(debugConfiguration("5005", true)),
        karafDistributionConfiguration()
            .frameworkUrl(
                paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.distroUrl"))
            .karafVersion(
                paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.version"))
            .name("Apache Karaf")
            .unpackDirectory(
                new File(
                    paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.unpackDir")))
            .useDeployFolder(false),
        editConfigurationFileExtend(
            "etc/org.ops4j.pax.url.mvn.cfg",
            "org.ops4j.pax.url.mvn.repositories",
            "https://repository.jboss.org/nexus/content/groups/public/"),
        configureConsole().ignoreLocalConsole().ignoreRemoteShell(),
        when(debug).useOptions(keepRuntimeFolder()),
        logLevel(LogLevelOption.LogLevel.INFO),
        features(featureXmlUrl(paxExamEnvironment), "hibernate-orm"),
        features(testingFeatureXmlUrl(), "hibernate-osgi-testing"));
  }
Пример #2
0
  static {
    try {
      Map<Object, Object> properties = getEntityManagerProperties();

      Environment.verifyProperties(properties);
      ConfigurationHelper.resolvePlaceHolders(properties);
      ServiceRegistry reg =
          new ServiceRegistryBuilder().applySettings(properties).buildServiceRegistry();

      DbOpenHelper openHelper =
          new DbOpenHelper(reg) {

            @Override
            public void onCreate() throws Exception {
              executeAllScript(0);
            }

            @Override
            public void onUpgrade(int oldVersion, int newVersion) throws Exception {
              // TODO Auto-generated method stub
            }
          };
      openHelper.open();

      emfInstance =
          Persistence.createEntityManagerFactory(
              "transactions-optional", getEntityManagerProperties());

    } catch (Throwable t) {
      log.error("Error creating EMF", t);
    }
  }
 public static ServiceRegistryImpl buildServiceRegistry(Map serviceRegistryConfig) {
   Properties properties = new Properties();
   properties.putAll(serviceRegistryConfig);
   Environment.verifyProperties(properties);
   ConfigurationHelper.resolvePlaceHolders(properties);
   return new ServiceRegistryImpl(properties);
 }
 public void setSqlOrderBy(OrderBy orderByAnn) {
   if (orderByAnn != null) {
     if (Environment.jvmSupportsLinkedHashCollections()) {
       super.setSqlOrderBy(orderByAnn);
     } else {
       log.warn("Attribute \"order-by\" ignored in JDK1.3 or less");
     }
   }
 }
 private static Properties createProperties() {
   final Properties properties = new Properties();
   // If configured in the environment, add configuration file name to properties.
   final String cfgFileName =
       (String)
           Environment.getProperties()
               .get(InfinispanRegionFactory.INFINISPAN_CONFIG_RESOURCE_PROP);
   if (cfgFileName != null) {
     properties.put(InfinispanRegionFactory.INFINISPAN_CONFIG_RESOURCE_PROP, cfgFileName);
   }
   return properties;
 }
  protected StandardServiceRegistryImpl buildServiceRegistry(Configuration configuration) {
    Properties properties = new Properties();
    properties.putAll(configuration.getProperties());
    Environment.verifyProperties(properties);
    ConfigurationHelper.resolvePlaceHolders(properties);

    final BootstrapServiceRegistry bootstrapServiceRegistry = generateBootstrapRegistry(properties);
    ServiceRegistryBuilder registryBuilder =
        new ServiceRegistryBuilder(bootstrapServiceRegistry).applySettings(properties);
    prepareBasicRegistryBuilder(registryBuilder);
    return (StandardServiceRegistryImpl) registryBuilder.buildServiceRegistry();
  }
  private SessionFactory buildSessionFactory() {
    // Extra options located in src/test/resources/hibernate.properties
    Properties envProps = Environment.getProperties();
    envProps.setProperty(Environment.DIALECT, "HSQL");
    envProps.setProperty(Environment.HBM2DDL_AUTO, "create-drop");
    envProps.setProperty(
        Environment.CONNECTION_PROVIDER, JtaAwareConnectionProviderImpl.class.getName());
    envProps.setProperty(Environment.JNDI_CLASS, "org.jnp.interfaces.NamingContextFactory");
    envProps.setProperty(Environment.TRANSACTION_STRATEGY, "jta");
    envProps.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS, "jta");
    envProps.setProperty(Environment.RELEASE_CONNECTIONS, "auto");
    envProps.setProperty(Environment.USE_SECOND_LEVEL_CACHE, "true");
    envProps.setProperty(Environment.USE_QUERY_CACHE, "true");
    envProps.put(AvailableSettings.JTA_PLATFORM, new JBossStandAloneJtaPlatform());
    envProps.setProperty(
        Environment.CACHE_REGION_FACTORY,
        "org.hibernate.test.cache.infinispan.functional.SingleNodeTestCase$TestInfinispanRegionFactory");
    serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(envProps);

    MetadataSources sources = new MetadataSources(serviceRegistry);

    String[] mappings =
        new String[] {"org/hibernate/test/cache/infinispan/functional/Item.hbm.xml"};
    for (String mapping : mappings) {
      sources.addResource(mapping);
    }
    Metadata metadata = sources.buildMetadata();
    Iterator<EntityBinding> entityIter = metadata.getEntityBindings().iterator();
    while (entityIter.hasNext()) {
      EntityBinding binding = entityIter.next();
      binding.getHierarchyDetails().getCaching().setAccessType(AccessType.TRANSACTIONAL);
      binding.getHierarchyDetails().getCaching().setRequested(TruthValue.TRUE);
      binding.getHierarchyDetails().getCaching().setRegion(binding.getEntityName());
      binding.getHierarchyDetails().getCaching().setCacheLazyProperties(true);
    }
    Iterator<PluralAttributeBinding> collectionIter = metadata.getCollectionBindings().iterator();
    while (collectionIter.hasNext()) {
      PluralAttributeBinding binding = collectionIter.next();
      binding.getCaching().setAccessType(AccessType.TRANSACTIONAL);
      binding.getCaching().setRequested(TruthValue.TRUE);
      binding
          .getCaching()
          .setRegion(
              StringHelper.qualify(
                  binding.getContainer().seekEntityBinding().getEntityName(),
                  binding.getAttribute().getName()));
      binding.getCaching().setCacheLazyProperties(true);
    }
    return metadata.buildSessionFactory();
  }
  public SchemaFilterTest() {
    Map settings = new HashMap();
    settings.putAll(Environment.getProperties());
    settings.put(AvailableSettings.DIALECT, SQLServerDialect.class.getName());

    this.serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(settings);

    MetadataSources ms = new MetadataSources(serviceRegistry);
    ms.addAnnotatedClass(SchemaNoneEntity0.class);
    ms.addAnnotatedClass(Schema1Entity1.class);
    ms.addAnnotatedClass(Schema1Entity2.class);
    ms.addAnnotatedClass(Schema2Entity3.class);
    ms.addAnnotatedClass(Schema2Entity4.class);
    this.metadata = ms.buildMetadata();
  }
  @Override
  public boolean areEqual(Date one, Date another) {
    if (one == another) {
      return true;
    }
    if (one == null || another == null) {
      return false;
    }

    long t1 = one.getTime();
    long t2 = another.getTime();

    boolean oneIsTimestamp = Timestamp.class.isInstance(one);
    boolean anotherIsTimestamp = Timestamp.class.isInstance(another);

    int n1 = oneIsTimestamp ? ((Timestamp) one).getNanos() : 0;
    int n2 = anotherIsTimestamp ? ((Timestamp) another).getNanos() : 0;

    if (!Environment.jvmHasJDK14Timestamp()) {
      t1 += n1 / 1000000;
      t2 += n2 / 1000000;
    }

    if (t1 != t2) {
      return false;
    }

    if (oneIsTimestamp && anotherIsTimestamp) {
      // both are Timestamps
      int nn1 = n1 % 1000000;
      int nn2 = n2 % 1000000;
      return nn1 == nn2;
    } else {
      // at least one is a plain old Date
      return true;
    }
  }
 protected void setUp() {
   serviceRegistryHolder = new ServiceRegistryHolder(Environment.getProperties());
 }
  public EntityMetamodel(
      PersistentClass persistentClass,
      AbstractEntityPersister persister,
      SessionFactoryImplementor sessionFactory) {
    this.sessionFactory = sessionFactory;
    this.persister = persister;

    name = persistentClass.getEntityName();
    rootName = persistentClass.getRootClass().getEntityName();
    entityType = sessionFactory.getTypeResolver().getTypeFactory().manyToOne(name);

    identifierAttribute =
        PropertyFactory.buildIdentifierAttribute(
            persistentClass, sessionFactory.getIdentifierGenerator(rootName));

    versioned = persistentClass.isVersioned();

    instrumentationMetadata =
        persistentClass.hasPojoRepresentation()
            ? Environment.getBytecodeProvider()
                .getEntityInstrumentationMetadata(persistentClass.getMappedClass())
            : new NonPojoInstrumentationMetadata(persistentClass.getEntityName());

    boolean hasLazy = false;

    propertySpan = persistentClass.getPropertyClosureSpan();
    properties = new NonIdentifierAttribute[propertySpan];
    List<Integer> naturalIdNumbers = new ArrayList<Integer>();
    // temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    propertyNames = new String[propertySpan];
    propertyTypes = new Type[propertySpan];
    propertyUpdateability = new boolean[propertySpan];
    propertyInsertability = new boolean[propertySpan];
    nonlazyPropertyUpdateability = new boolean[propertySpan];
    propertyCheckability = new boolean[propertySpan];
    propertyNullability = new boolean[propertySpan];
    propertyVersionability = new boolean[propertySpan];
    propertyLaziness = new boolean[propertySpan];
    cascadeStyles = new CascadeStyle[propertySpan];
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // generated value strategies
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    this.inMemoryValueGenerationStrategies = new InMemoryValueGenerationStrategy[propertySpan];
    this.inDatabaseValueGenerationStrategies = new InDatabaseValueGenerationStrategy[propertySpan];

    boolean foundPreInsertGeneratedValues = false;
    boolean foundPreUpdateGeneratedValues = false;
    boolean foundPostInsertGeneratedValues = false;
    boolean foundPostUpdateGeneratedValues = false;
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Iterator iter = persistentClass.getPropertyClosureIterator();
    int i = 0;
    int tempVersionProperty = NO_VERSION_INDX;
    boolean foundCascade = false;
    boolean foundCollection = false;
    boolean foundMutable = false;
    boolean foundNonIdentifierPropertyNamedId = false;
    boolean foundInsertGeneratedValue = false;
    boolean foundUpdateGeneratedValue = false;
    boolean foundUpdateableNaturalIdProperty = false;

    while (iter.hasNext()) {
      Property prop = (Property) iter.next();

      if (prop == persistentClass.getVersion()) {
        tempVersionProperty = i;
        properties[i] =
            PropertyFactory.buildVersionProperty(
                persister, sessionFactory, i, prop, instrumentationMetadata.isInstrumented());
      } else {
        properties[i] =
            PropertyFactory.buildEntityBasedAttribute(
                persister, sessionFactory, i, prop, instrumentationMetadata.isInstrumented());
      }

      if (prop.isNaturalIdentifier()) {
        naturalIdNumbers.add(i);
        if (prop.isUpdateable()) {
          foundUpdateableNaturalIdProperty = true;
        }
      }

      if ("id".equals(prop.getName())) {
        foundNonIdentifierPropertyNamedId = true;
      }

      // temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      boolean lazy = prop.isLazy() && instrumentationMetadata.isInstrumented();
      if (lazy) hasLazy = true;
      propertyLaziness[i] = lazy;

      propertyNames[i] = properties[i].getName();
      propertyTypes[i] = properties[i].getType();
      propertyNullability[i] = properties[i].isNullable();
      propertyUpdateability[i] = properties[i].isUpdateable();
      propertyInsertability[i] = properties[i].isInsertable();
      propertyVersionability[i] = properties[i].isVersionable();
      nonlazyPropertyUpdateability[i] = properties[i].isUpdateable() && !lazy;
      propertyCheckability[i] =
          propertyUpdateability[i]
              || (propertyTypes[i].isAssociationType()
                  && ((AssociationType) propertyTypes[i]).isAlwaysDirtyChecked());

      cascadeStyles[i] = properties[i].getCascadeStyle();
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      // generated value strategies
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      GenerationStrategyPair pair = buildGenerationStrategyPair(sessionFactory, prop);
      inMemoryValueGenerationStrategies[i] = pair.getInMemoryStrategy();
      inDatabaseValueGenerationStrategies[i] = pair.getInDatabaseStrategy();

      if (pair.getInMemoryStrategy() != null) {
        final GenerationTiming timing = pair.getInMemoryStrategy().getGenerationTiming();
        if (timing != GenerationTiming.NEVER) {
          final ValueGenerator generator = pair.getInMemoryStrategy().getValueGenerator();
          if (generator != null) {
            // we have some level of generation indicated
            if (timing == GenerationTiming.INSERT) {
              foundPreInsertGeneratedValues = true;
            } else if (timing == GenerationTiming.ALWAYS) {
              foundPreInsertGeneratedValues = true;
              foundPreUpdateGeneratedValues = true;
            }
          }
        }
      }
      if (pair.getInDatabaseStrategy() != null) {
        final GenerationTiming timing = pair.getInDatabaseStrategy().getGenerationTiming();
        if (timing == GenerationTiming.INSERT) {
          foundPostInsertGeneratedValues = true;
        } else if (timing == GenerationTiming.ALWAYS) {
          foundPostInsertGeneratedValues = true;
          foundPostUpdateGeneratedValues = true;
        }
      }
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      if (properties[i].isLazy()) {
        hasLazy = true;
      }

      if (properties[i].getCascadeStyle() != CascadeStyles.NONE) {
        foundCascade = true;
      }

      if (indicatesCollection(properties[i].getType())) {
        foundCollection = true;
      }

      if (propertyTypes[i].isMutable() && propertyCheckability[i]) {
        foundMutable = true;
      }

      mapPropertyToIndex(prop, i);
      i++;
    }

    if (naturalIdNumbers.size() == 0) {
      naturalIdPropertyNumbers = null;
      hasImmutableNaturalId = false;
      hasCacheableNaturalId = false;
    } else {
      naturalIdPropertyNumbers = ArrayHelper.toIntArray(naturalIdNumbers);
      hasImmutableNaturalId = !foundUpdateableNaturalIdProperty;
      hasCacheableNaturalId = persistentClass.getNaturalIdCacheRegionName() != null;
    }

    this.hasPreInsertGeneratedValues = foundPreInsertGeneratedValues;
    this.hasPreUpdateGeneratedValues = foundPreUpdateGeneratedValues;
    this.hasInsertGeneratedValues = foundPostInsertGeneratedValues;
    this.hasUpdateGeneratedValues = foundPostUpdateGeneratedValues;

    hasCascades = foundCascade;
    hasNonIdentifierPropertyNamedId = foundNonIdentifierPropertyNamedId;
    versionPropertyIndex = tempVersionProperty;
    hasLazyProperties = hasLazy;
    if (hasLazyProperties) LOG.lazyPropertyFetchingAvailable(name);

    lazy =
        persistentClass.isLazy()
            && (
            // TODO: this disables laziness even in non-pojo entity modes:
            !persistentClass.hasPojoRepresentation()
                || !ReflectHelper.isFinalClass(persistentClass.getProxyInterface()));
    mutable = persistentClass.isMutable();
    if (persistentClass.isAbstract() == null) {
      // legacy behavior (with no abstract attribute specified)
      isAbstract =
          persistentClass.hasPojoRepresentation()
              && ReflectHelper.isAbstractClass(persistentClass.getMappedClass());
    } else {
      isAbstract = persistentClass.isAbstract().booleanValue();
      if (!isAbstract
          && persistentClass.hasPojoRepresentation()
          && ReflectHelper.isAbstractClass(persistentClass.getMappedClass())) {
        LOG.entityMappedAsNonAbstract(name);
      }
    }
    selectBeforeUpdate = persistentClass.hasSelectBeforeUpdate();
    dynamicUpdate = persistentClass.useDynamicUpdate();
    dynamicInsert = persistentClass.useDynamicInsert();

    polymorphic = persistentClass.isPolymorphic();
    explicitPolymorphism = persistentClass.isExplicitPolymorphism();
    inherited = persistentClass.isInherited();
    superclass = inherited ? persistentClass.getSuperclass().getEntityName() : null;
    hasSubclasses = persistentClass.hasSubclasses();

    optimisticLockStyle = persistentClass.getOptimisticLockStyle();
    final boolean isAllOrDirty =
        optimisticLockStyle == OptimisticLockStyle.ALL
            || optimisticLockStyle == OptimisticLockStyle.DIRTY;
    if (isAllOrDirty && !dynamicUpdate) {
      throw new MappingException(
          "optimistic-lock=all|dirty requires dynamic-update=\"true\": " + name);
    }
    if (versionPropertyIndex != NO_VERSION_INDX && isAllOrDirty) {
      throw new MappingException(
          "version and optimistic-lock=all|dirty are not a valid combination : " + name);
    }

    hasCollections = foundCollection;
    hasMutableProperties = foundMutable;

    iter = persistentClass.getSubclassIterator();
    while (iter.hasNext()) {
      subclassEntityNames.add(((PersistentClass) iter.next()).getEntityName());
    }
    subclassEntityNames.add(name);

    if (persistentClass.hasPojoRepresentation()) {
      entityNameByInheritenceClassMap.put(
          persistentClass.getMappedClass(), persistentClass.getEntityName());
      iter = persistentClass.getSubclassIterator();
      while (iter.hasNext()) {
        final PersistentClass pc = (PersistentClass) iter.next();
        entityNameByInheritenceClassMap.put(pc.getMappedClass(), pc.getEntityName());
      }
    }

    entityMode = persistentClass.hasPojoRepresentation() ? EntityMode.POJO : EntityMode.MAP;
    final EntityTuplizerFactory entityTuplizerFactory =
        sessionFactory.getSettings().getEntityTuplizerFactory();
    final String tuplizerClassName = persistentClass.getTuplizerImplClassName(entityMode);
    if (tuplizerClassName == null) {
      entityTuplizer =
          entityTuplizerFactory.constructDefaultTuplizer(entityMode, this, persistentClass);
    } else {
      entityTuplizer =
          entityTuplizerFactory.constructTuplizer(tuplizerClassName, this, persistentClass);
    }
  }
Пример #12
0
 /**
  * Discription:[已过时]
  *
  * @return
  * @author:[代超]
  * @update:[日期YYYY-MM-DD] [更改人姓名][变更描述]
  */
 public static Properties getHibernateProperties() {
   return Environment.getProperties();
 }
 public String getDialect() {
   return Environment.getProperties().getProperty(Environment.DIALECT);
 }
 @Before
 public void setUp() {
   serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(Environment.getProperties());
 }
Пример #15
0
 private static StandardServiceRegistryImpl createServiceRegistry(Properties properties) {
   Environment.verifyProperties(properties);
   ConfigurationHelper.resolvePlaceHolders(properties);
   return (StandardServiceRegistryImpl)
       new ServiceRegistryBuilder().applySettings(properties).buildServiceRegistry();
 }
Пример #16
0
  public EntityMetamodel(EntityBinding entityBinding, SessionFactoryImplementor sessionFactory) {
    this.sessionFactory = sessionFactory;

    name = entityBinding.getEntity().getName();

    rootName = entityBinding.getHierarchyDetails().getRootEntityBinding().getEntity().getName();
    entityType = sessionFactory.getTypeResolver().getTypeFactory().manyToOne(name);

    identifierProperty =
        PropertyFactory.buildIdentifierProperty(
            entityBinding, sessionFactory.getIdentifierGenerator(rootName));

    versioned = entityBinding.isVersioned();

    boolean hasPojoRepresentation = false;
    Class<?> mappedClass = null;
    Class<?> proxyInterfaceClass = null;
    if (entityBinding.getEntity().getClassReferenceUnresolved() != null) {
      hasPojoRepresentation = true;
      mappedClass = entityBinding.getEntity().getClassReference();
      proxyInterfaceClass = entityBinding.getProxyInterfaceType().getValue();
    }
    instrumentationMetadata =
        Environment.getBytecodeProvider().getEntityInstrumentationMetadata(mappedClass);

    boolean hasLazy = false;

    // TODO: Fix after HHH-6337 is fixed; for now assume entityBinding is the root binding
    BasicAttributeBinding rootEntityIdentifier =
        entityBinding.getHierarchyDetails().getEntityIdentifier().getValueBinding();
    // entityBinding.getAttributeClosureSpan() includes the identifier binding;
    // "properties" here excludes the ID, so subtract 1 if the identifier binding is non-null
    propertySpan =
        rootEntityIdentifier == null
            ? entityBinding.getAttributeBindingClosureSpan()
            : entityBinding.getAttributeBindingClosureSpan() - 1;

    properties = new StandardProperty[propertySpan];
    List naturalIdNumbers = new ArrayList();
    // temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    propertyNames = new String[propertySpan];
    propertyTypes = new Type[propertySpan];
    propertyUpdateability = new boolean[propertySpan];
    propertyInsertability = new boolean[propertySpan];
    insertInclusions = new ValueInclusion[propertySpan];
    updateInclusions = new ValueInclusion[propertySpan];
    nonlazyPropertyUpdateability = new boolean[propertySpan];
    propertyCheckability = new boolean[propertySpan];
    propertyNullability = new boolean[propertySpan];
    propertyVersionability = new boolean[propertySpan];
    propertyLaziness = new boolean[propertySpan];
    cascadeStyles = new CascadeStyle[propertySpan];
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    int i = 0;
    int tempVersionProperty = NO_VERSION_INDX;
    boolean foundCascade = false;
    boolean foundCollection = false;
    boolean foundMutable = false;
    boolean foundNonIdentifierPropertyNamedId = false;
    boolean foundInsertGeneratedValue = false;
    boolean foundUpdateGeneratedValue = false;
    boolean foundUpdateableNaturalIdProperty = false;

    for (AttributeBinding attributeBinding : entityBinding.getAttributeBindingClosure()) {
      if (attributeBinding == rootEntityIdentifier) {
        // skip the identifier attribute binding
        continue;
      }

      if (attributeBinding == entityBinding.getHierarchyDetails().getVersioningAttributeBinding()) {
        tempVersionProperty = i;
        properties[i] =
            PropertyFactory.buildVersionProperty(
                entityBinding.getHierarchyDetails().getVersioningAttributeBinding(),
                instrumentationMetadata.isInstrumented());
      } else {
        properties[i] =
            PropertyFactory.buildStandardProperty(
                attributeBinding, instrumentationMetadata.isInstrumented());
      }

      // TODO: fix when natural IDs are added (HHH-6354)
      // if ( attributeBinding.isNaturalIdentifier() ) {
      //	naturalIdNumbers.add( i );
      //	if ( attributeBinding.isUpdateable() ) {
      //		foundUpdateableNaturalIdProperty = true;
      //	}
      // }

      if ("id".equals(attributeBinding.getAttribute().getName())) {
        foundNonIdentifierPropertyNamedId = true;
      }

      // temporary ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      boolean lazy = attributeBinding.isLazy() && instrumentationMetadata.isInstrumented();
      if (lazy) hasLazy = true;
      propertyLaziness[i] = lazy;

      propertyNames[i] = properties[i].getName();
      propertyTypes[i] = properties[i].getType();
      propertyNullability[i] = properties[i].isNullable();
      propertyUpdateability[i] = properties[i].isUpdateable();
      propertyInsertability[i] = properties[i].isInsertable();
      insertInclusions[i] = determineInsertValueGenerationType(attributeBinding, properties[i]);
      updateInclusions[i] = determineUpdateValueGenerationType(attributeBinding, properties[i]);
      propertyVersionability[i] = properties[i].isVersionable();
      nonlazyPropertyUpdateability[i] = properties[i].isUpdateable() && !lazy;
      propertyCheckability[i] =
          propertyUpdateability[i]
              || (propertyTypes[i].isAssociationType()
                  && ((AssociationType) propertyTypes[i]).isAlwaysDirtyChecked());

      cascadeStyles[i] = properties[i].getCascadeStyle();
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      if (properties[i].isLazy()) {
        hasLazy = true;
      }

      if (properties[i].getCascadeStyle() != CascadeStyles.NONE) {
        foundCascade = true;
      }

      if (indicatesCollection(properties[i].getType())) {
        foundCollection = true;
      }

      if (propertyTypes[i].isMutable() && propertyCheckability[i]) {
        foundMutable = true;
      }

      if (insertInclusions[i] != ValueInclusion.NONE) {
        foundInsertGeneratedValue = true;
      }

      if (updateInclusions[i] != ValueInclusion.NONE) {
        foundUpdateGeneratedValue = true;
      }

      mapPropertyToIndex(attributeBinding.getAttribute(), i);
      i++;
    }

    if (naturalIdNumbers.size() == 0) {
      naturalIdPropertyNumbers = null;
      hasImmutableNaturalId = false;
      hasCacheableNaturalId = false;
    } else {
      naturalIdPropertyNumbers = ArrayHelper.toIntArray(naturalIdNumbers);
      hasImmutableNaturalId = !foundUpdateableNaturalIdProperty;
      hasCacheableNaturalId = false; // See previous TODO and HHH-6354
    }

    hasInsertGeneratedValues = foundInsertGeneratedValue;
    hasUpdateGeneratedValues = foundUpdateGeneratedValue;

    hasCascades = foundCascade;
    hasNonIdentifierPropertyNamedId = foundNonIdentifierPropertyNamedId;
    versionPropertyIndex = tempVersionProperty;
    hasLazyProperties = hasLazy;
    if (hasLazyProperties) {
      LOG.lazyPropertyFetchingAvailable(name);
    }

    lazy =
        entityBinding.isLazy()
            && (
            // TODO: this disables laziness even in non-pojo entity modes:
            !hasPojoRepresentation || !ReflectHelper.isFinalClass(proxyInterfaceClass));
    mutable = entityBinding.isMutable();
    if (entityBinding.isAbstract() == null) {
      // legacy behavior (with no abstract attribute specified)
      isAbstract = hasPojoRepresentation && ReflectHelper.isAbstractClass(mappedClass);
    } else {
      isAbstract = entityBinding.isAbstract().booleanValue();
      if (!isAbstract && hasPojoRepresentation && ReflectHelper.isAbstractClass(mappedClass)) {
        LOG.entityMappedAsNonAbstract(name);
      }
    }
    selectBeforeUpdate = entityBinding.isSelectBeforeUpdate();
    dynamicUpdate = entityBinding.isDynamicUpdate();
    dynamicInsert = entityBinding.isDynamicInsert();

    hasSubclasses = entityBinding.hasSubEntityBindings();
    polymorphic = entityBinding.isPolymorphic();

    explicitPolymorphism = entityBinding.getHierarchyDetails().isExplicitPolymorphism();
    inherited = !entityBinding.isRoot();
    superclass = inherited ? entityBinding.getEntity().getSuperType().getName() : null;

    optimisticLockStyle = entityBinding.getHierarchyDetails().getOptimisticLockStyle();
    final boolean isAllOrDirty =
        optimisticLockStyle == OptimisticLockStyle.ALL
            || optimisticLockStyle == OptimisticLockStyle.DIRTY;
    if (isAllOrDirty && !dynamicUpdate) {
      throw new MappingException(
          "optimistic-lock=all|dirty requires dynamic-update=\"true\": " + name);
    }
    if (versionPropertyIndex != NO_VERSION_INDX && isAllOrDirty) {
      throw new MappingException(
          "version and optimistic-lock=all|dirty are not a valid combination : " + name);
    }

    hasCollections = foundCollection;
    hasMutableProperties = foundMutable;

    for (EntityBinding subEntityBinding : entityBinding.getPostOrderSubEntityBindingClosure()) {
      subclassEntityNames.add(subEntityBinding.getEntity().getName());
      if (subEntityBinding.getEntity().getClassReference() != null) {
        entityNameByInheritenceClassMap.put(
            subEntityBinding.getEntity().getClassReference(),
            subEntityBinding.getEntity().getName());
      }
    }
    subclassEntityNames.add(name);
    if (mappedClass != null) {
      entityNameByInheritenceClassMap.put(mappedClass, name);
    }

    entityMode = hasPojoRepresentation ? EntityMode.POJO : EntityMode.MAP;
    final EntityTuplizerFactory entityTuplizerFactory =
        sessionFactory.getSettings().getEntityTuplizerFactory();
    Class<? extends EntityTuplizer> tuplizerClass = entityBinding.getCustomEntityTuplizerClass();

    if (tuplizerClass == null) {
      entityTuplizer =
          entityTuplizerFactory.constructDefaultTuplizer(entityMode, this, entityBinding);
    } else {
      entityTuplizer = entityTuplizerFactory.constructTuplizer(tuplizerClass, this, entityBinding);
    }
  }
Пример #17
0
 protected void setUp() {
   serviceRegistry = ServiceRegistryBuilder.buildServiceRegistry(Environment.getProperties());
 }