コード例 #1
0
  private void prepareTestData(Session session) throws HibernateException {
    try {
      IdentifierGenerator stockIdGen =
          ((SessionFactoryImplementor) session.getSessionFactory())
              .getIdentifierGenerator(Stock.class.getName());
      IdentifierGenerator valIdGen =
          ((SessionFactoryImplementor) session.getSessionFactory())
              .getIdentifierGenerator(Valuation.class.getName());

      stockId = (Long) stockIdGen.generate((SessionImpl) session, null);
      valId = (Long) valIdGen.generate((SessionImpl) session, null);

      Connection conn = session.connection();
      PreparedStatement ps = conn.prepareStatement("INSERT INTO STOCK VALUES (?,?,?)");
      ps.setLong(1, stockId.longValue());
      ps.setString(2, "JBOSS");
      ps.setNull(3, Types.BIGINT);
      ps.executeUpdate();
      ps.close();

      ps = conn.prepareStatement("INSERT INTO STOCK_VAL VALUES (?,?,?,?)");
      ps.setLong(1, valId.longValue());
      ps.setLong(2, stockId.longValue());
      ps.setDate(3, new Date(new java.util.Date().getTime()));
      ps.setDouble(4, 200.0);
      ps.executeUpdate();
      ps.close();

      ps = conn.prepareStatement("UPDATE STOCK SET CURR_VAL_ID = ? WHERE STOCK_ID = ?");
      ps.setLong(1, valId.longValue());
      ps.setLong(2, stockId.longValue());
      ps.executeUpdate();
      ps.close();
    } catch (SQLException e) {
      System.err.println("Error : " + e);
      e.printStackTrace();
      throw new HibernateException("Unable to generate test data", e);
    }
  }
コード例 #2
0
  public EntityManagerFactoryImpl(
      String persistenceUnitName,
      SessionFactoryImplementor sessionFactory,
      SettingsImpl settings,
      Map<?, ?> configurationValues,
      Configuration cfg) {
    this.sessionFactory = (SessionFactoryImpl) sessionFactory;
    this.transactionType = settings.getTransactionType();
    this.discardOnClose = settings.isReleaseResourcesOnCloseEnabled();
    this.sessionInterceptorClass = settings.getSessionInterceptorClass();

    final JpaMetaModelPopulationSetting jpaMetaModelPopulationSetting =
        determineJpaMetaModelPopulationSetting(cfg);
    if (JpaMetaModelPopulationSetting.DISABLED == jpaMetaModelPopulationSetting) {
      this.metamodel = null;
    } else {
      this.metamodel =
          MetamodelImpl.buildMetamodel(
              cfg.getClassMappings(),
              cfg.getMappedSuperclassMappingsCopy(),
              sessionFactory,
              JpaMetaModelPopulationSetting.IGNORE_UNSUPPORTED == jpaMetaModelPopulationSetting);
    }
    this.criteriaBuilder = new CriteriaBuilderImpl(this);
    this.util = new HibernatePersistenceUnitUtil(this);

    HashMap<String, Object> props = new HashMap<String, Object>();
    addAll(props, sessionFactory.getProperties());
    addAll(props, cfg.getProperties());
    addAll(props, configurationValues);
    maskOutSensitiveInformation(props);
    this.properties = Collections.unmodifiableMap(props);
    String entityManagerFactoryName =
        (String) this.properties.get(AvailableSettings.ENTITY_MANAGER_FACTORY_NAME);
    if (entityManagerFactoryName == null) {
      entityManagerFactoryName = persistenceUnitName;
    }
    if (entityManagerFactoryName == null) {
      entityManagerFactoryName = (String) UUID_GENERATOR.generate(null, null);
    }
    this.entityManagerFactoryName = entityManagerFactoryName;

    applyNamedEntityGraphs(cfg.getNamedEntityGraphs());

    EntityManagerFactoryRegistry.INSTANCE.addEntityManagerFactory(entityManagerFactoryName, this);
  }
コード例 #3
0
  protected void postProcessInsert(AST insert) throws SemanticException, QueryException {
    InsertStatement insertStatement = (InsertStatement) insert;
    insertStatement.validate();

    SelectClause selectClause = insertStatement.getSelectClause();
    Queryable persister = insertStatement.getIntoClause().getQueryable();

    if (!insertStatement.getIntoClause().isExplicitIdInsertion()) {
      // We need to generate ids as part of this bulk insert.
      //
      // Note that this is only supported for sequence-style generators and
      // post-insert-style generators; basically, only in-db generators
      IdentifierGenerator generator = persister.getIdentifierGenerator();
      if (!supportsIdGenWithBulkInsertion(generator)) {
        throw new QueryException(
            "can only generate ids as part of bulk insert with either sequence or post-insert style generators");
      }

      AST idSelectExprNode = null;

      if (SequenceGenerator.class.isAssignableFrom(generator.getClass())) {
        String seqName = (String) ((SequenceGenerator) generator).generatorKey();
        String nextval =
            sessionFactoryHelper.getFactory().getDialect().getSelectSequenceNextValString(seqName);
        idSelectExprNode = getASTFactory().create(HqlSqlTokenTypes.SQL_TOKEN, nextval);
      } else {
        // Don't need this, because we should never ever be selecting no columns in an insert ...
        // select...
        // and because it causes a bug on DB2
        /*String idInsertString = sessionFactoryHelper.getFactory().getDialect().getIdentityInsertString();
        if ( idInsertString != null ) {
        	idSelectExprNode = getASTFactory().create( HqlSqlTokenTypes.SQL_TOKEN, idInsertString );
        }*/
      }

      if (idSelectExprNode != null) {
        AST currentFirstSelectExprNode = selectClause.getFirstChild();
        selectClause.setFirstChild(idSelectExprNode);
        idSelectExprNode.setNextSibling(currentFirstSelectExprNode);

        insertStatement.getIntoClause().prependIdColumnSpec();
      }
    }

    final boolean includeVersionProperty =
        persister.isVersioned()
            && !insertStatement.getIntoClause().isExplicitVersionInsertion()
            && persister.isVersionPropertyInsertable();
    if (includeVersionProperty) {
      // We need to seed the version value as part of this bulk insert
      VersionType versionType = persister.getVersionType();
      AST versionValueNode = null;

      if (sessionFactoryHelper.getFactory().getDialect().supportsParametersInInsertSelect()) {
        versionValueNode = getASTFactory().create(HqlSqlTokenTypes.PARAM, "?");
        ParameterSpecification paramSpec = new VersionTypeSeedParameterSpecification(versionType);
        ((ParameterNode) versionValueNode).setHqlParameterSpecification(paramSpec);
        parameters.add(0, paramSpec);
      } else {
        if (isIntegral(versionType)) {
          try {
            Object seedValue = versionType.seed(null);
            versionValueNode =
                getASTFactory().create(HqlSqlTokenTypes.SQL_TOKEN, seedValue.toString());
          } catch (Throwable t) {
            throw new QueryException(
                "could not determine seed value for version on bulk insert [" + versionType + "]");
          }
        } else if (isDatabaseGeneratedTimestamp(versionType)) {
          String functionName =
              sessionFactoryHelper.getFactory().getDialect().getCurrentTimestampSQLFunctionName();
          versionValueNode = getASTFactory().create(HqlSqlTokenTypes.SQL_TOKEN, functionName);
        } else {
          throw new QueryException(
              "cannot handle version type ["
                  + versionType
                  + "] on bulk inserts with dialects not supporting parameters in insert-select statements");
        }
      }

      AST currentFirstSelectExprNode = selectClause.getFirstChild();
      selectClause.setFirstChild(versionValueNode);
      versionValueNode.setNextSibling(currentFirstSelectExprNode);

      insertStatement.getIntoClause().prependVersionColumnSpec();
    }

    if (insertStatement.getIntoClause().isDiscriminated()) {
      String sqlValue = insertStatement.getIntoClause().getQueryable().getDiscriminatorSQLValue();
      AST discrimValue = getASTFactory().create(HqlSqlTokenTypes.SQL_TOKEN, sqlValue);
      insertStatement.getSelectClause().addChild(discrimValue);
    }
  }
コード例 #4
0
 public static boolean supportsIdGenWithBulkInsertion(IdentifierGenerator generator) {
   return SequenceGenerator.class.isAssignableFrom(generator.getClass())
       || PostInsertIdentifierGenerator.class.isAssignableFrom(generator.getClass());
 }
コード例 #5
0
  public SessionFactoryImpl(
      Configuration cfg,
      Mapping mapping,
      Settings settings,
      EventListeners listeners,
      SessionFactoryObserver observer)
      throws HibernateException {
    log.info("building session factory");

    Statistics concurrentStatistics = null;
    try {
      Class concurrentStatsClass =
          ReflectHelper.classForName("org.hibernate.stat.ConcurrentStatisticsImpl");
      Constructor constructor =
          concurrentStatsClass.getConstructor(new Class[] {SessionFactoryImplementor.class});
      concurrentStatistics = (Statistics) constructor.newInstance(new Object[] {this});
      log.trace("JDK 1.5 concurrent classes present");
    } catch (NoClassDefFoundError noJava5) {
      log.trace("JDK 1.5 concurrent classes missing");
    } catch (Exception noJava5) {
      log.trace("JDK 1.5 concurrent classes missing");
    }

    if (concurrentStatistics != null) {
      this.statistics = concurrentStatistics;
    } else {
      this.statistics = new StatisticsImpl(this);
    }

    if (log.isTraceEnabled()) {
      log.trace("Statistics initialized with " + statistics.getClass().getName());
    }

    this.properties = new Properties();
    this.properties.putAll(cfg.getProperties());
    this.interceptor = cfg.getInterceptor();
    this.settings = settings;
    this.sqlFunctionRegistry =
        new SQLFunctionRegistry(settings.getDialect(), cfg.getSqlFunctions());
    this.eventListeners = listeners;
    this.observer =
        observer != null
            ? observer
            : new SessionFactoryObserver() {
              public void sessionFactoryCreated(SessionFactory factory) {}

              public void sessionFactoryClosed(SessionFactory factory) {}
            };

    this.filters = new HashMap();
    this.filters.putAll(cfg.getFilterDefinitions());

    if (log.isDebugEnabled()) {
      log.debug("Session factory constructed with filter configurations : " + filters);
    }

    if (log.isDebugEnabled()) {
      log.debug("instantiating session factory with properties: " + properties);
    }

    // Caches
    settings.getRegionFactory().start(settings, properties);

    // Generators:

    identifierGenerators = new HashMap();
    Iterator classes = cfg.getClassMappings();
    while (classes.hasNext()) {
      PersistentClass model = (PersistentClass) classes.next();
      if (!model.isInherited()) {
        IdentifierGenerator generator =
            model
                .getIdentifier()
                .createIdentifierGenerator(
                    cfg.getIdentifierGeneratorFactory(),
                    settings.getDialect(),
                    settings.getDefaultCatalogName(),
                    settings.getDefaultSchemaName(),
                    (RootClass) model);
        identifierGenerators.put(model.getEntityName(), generator);
      }
    }

    ///////////////////////////////////////////////////////////////////////
    // Prepare persisters and link them up with their cache
    // region/access-strategy

    final String cacheRegionPrefix =
        settings.getCacheRegionPrefix() == null ? "" : settings.getCacheRegionPrefix() + ".";

    entityPersisters = new HashMap();
    Map entityAccessStrategies = new HashMap();
    Map classMeta = new HashMap();
    classes = cfg.getClassMappings();
    while (classes.hasNext()) {
      final PersistentClass model = (PersistentClass) classes.next();
      model.prepareTemporaryTables(mapping, settings.getDialect());
      final String cacheRegionName = cacheRegionPrefix + model.getRootClass().getCacheRegionName();
      // cache region is defined by the root-class in the hierarchy...
      EntityRegionAccessStrategy accessStrategy =
          (EntityRegionAccessStrategy) entityAccessStrategies.get(cacheRegionName);
      if (accessStrategy == null && settings.isSecondLevelCacheEnabled()) {
        final AccessType accessType = AccessType.parse(model.getCacheConcurrencyStrategy());
        if (accessType != null) {
          log.trace("Building cache for entity data [" + model.getEntityName() + "]");
          EntityRegion entityRegion =
              settings
                  .getRegionFactory()
                  .buildEntityRegion(
                      cacheRegionName, properties, CacheDataDescriptionImpl.decode(model));
          accessStrategy = entityRegion.buildAccessStrategy(accessType);
          entityAccessStrategies.put(cacheRegionName, accessStrategy);
          allCacheRegions.put(cacheRegionName, entityRegion);
        }
      }
      EntityPersister cp =
          PersisterFactory.createClassPersister(model, accessStrategy, this, mapping);
      entityPersisters.put(model.getEntityName(), cp);
      classMeta.put(model.getEntityName(), cp.getClassMetadata());
    }
    classMetadata = Collections.unmodifiableMap(classMeta);

    Map tmpEntityToCollectionRoleMap = new HashMap();
    collectionPersisters = new HashMap();
    Iterator collections = cfg.getCollectionMappings();
    while (collections.hasNext()) {
      Collection model = (Collection) collections.next();
      final String cacheRegionName = cacheRegionPrefix + model.getCacheRegionName();
      final AccessType accessType = AccessType.parse(model.getCacheConcurrencyStrategy());
      CollectionRegionAccessStrategy accessStrategy = null;
      if (accessType != null && settings.isSecondLevelCacheEnabled()) {
        log.trace("Building cache for collection data [" + model.getRole() + "]");
        CollectionRegion collectionRegion =
            settings
                .getRegionFactory()
                .buildCollectionRegion(
                    cacheRegionName, properties, CacheDataDescriptionImpl.decode(model));
        accessStrategy = collectionRegion.buildAccessStrategy(accessType);
        entityAccessStrategies.put(cacheRegionName, accessStrategy);
        allCacheRegions.put(cacheRegionName, collectionRegion);
      }
      CollectionPersister persister =
          PersisterFactory.createCollectionPersister(cfg, model, accessStrategy, this);
      collectionPersisters.put(model.getRole(), persister.getCollectionMetadata());
      Type indexType = persister.getIndexType();
      if (indexType != null && indexType.isAssociationType() && !indexType.isAnyType()) {
        String entityName = ((AssociationType) indexType).getAssociatedEntityName(this);
        Set roles = (Set) tmpEntityToCollectionRoleMap.get(entityName);
        if (roles == null) {
          roles = new HashSet();
          tmpEntityToCollectionRoleMap.put(entityName, roles);
        }
        roles.add(persister.getRole());
      }
      Type elementType = persister.getElementType();
      if (elementType.isAssociationType() && !elementType.isAnyType()) {
        String entityName = ((AssociationType) elementType).getAssociatedEntityName(this);
        Set roles = (Set) tmpEntityToCollectionRoleMap.get(entityName);
        if (roles == null) {
          roles = new HashSet();
          tmpEntityToCollectionRoleMap.put(entityName, roles);
        }
        roles.add(persister.getRole());
      }
    }
    collectionMetadata = Collections.unmodifiableMap(collectionPersisters);
    Iterator itr = tmpEntityToCollectionRoleMap.entrySet().iterator();
    while (itr.hasNext()) {
      final Map.Entry entry = (Map.Entry) itr.next();
      entry.setValue(Collections.unmodifiableSet((Set) entry.getValue()));
    }
    collectionRolesByEntityParticipant = Collections.unmodifiableMap(tmpEntityToCollectionRoleMap);

    // Named Queries:
    namedQueries = new HashMap(cfg.getNamedQueries());
    namedSqlQueries = new HashMap(cfg.getNamedSQLQueries());
    sqlResultSetMappings = new HashMap(cfg.getSqlResultSetMappings());
    imports = new HashMap(cfg.getImports());

    // after *all* persisters and named queries are registered
    Iterator iter = entityPersisters.values().iterator();
    while (iter.hasNext()) {
      final EntityPersister persister = ((EntityPersister) iter.next());
      persister.postInstantiate();
      registerEntityNameResolvers(persister);
    }
    iter = collectionPersisters.values().iterator();
    while (iter.hasNext()) {
      final CollectionPersister persister = ((CollectionPersister) iter.next());
      persister.postInstantiate();
    }

    // JNDI + Serialization:

    name = settings.getSessionFactoryName();
    try {
      uuid = (String) UUID_GENERATOR.generate(null, null);
    } catch (Exception e) {
      throw new AssertionFailure("Could not generate UUID");
    }
    SessionFactoryObjectFactory.addInstance(uuid, name, this, properties);

    log.debug("instantiated session factory");

    if (settings.isAutoCreateSchema()) {
      new SchemaExport(cfg, settings).create(false, true);
    }
    if (settings.isAutoUpdateSchema()) {
      new SchemaUpdate(cfg, settings).execute(false, true);
    }
    if (settings.isAutoValidateSchema()) {
      new SchemaValidator(cfg, settings).validate();
    }
    if (settings.isAutoDropSchema()) {
      schemaExport = new SchemaExport(cfg, settings);
    }

    if (settings.getTransactionManagerLookup() != null) {
      log.debug("obtaining JTA TransactionManager");
      transactionManager = settings.getTransactionManagerLookup().getTransactionManager(properties);
    } else {
      if (settings.getTransactionFactory().isTransactionManagerRequired()) {
        throw new HibernateException(
            "The chosen transaction strategy requires access to the JTA TransactionManager");
      }
      transactionManager = null;
    }

    currentSessionContext = buildCurrentSessionContext();

    if (settings.isQueryCacheEnabled()) {
      updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
      queryCache =
          settings
              .getQueryCacheFactory()
              .getQueryCache(null, updateTimestampsCache, settings, properties);
      queryCaches = new HashMap();
      allCacheRegions.put(
          updateTimestampsCache.getRegion().getName(), updateTimestampsCache.getRegion());
      allCacheRegions.put(queryCache.getRegion().getName(), queryCache.getRegion());
    } else {
      updateTimestampsCache = null;
      queryCache = null;
      queryCaches = null;
    }

    // checking for named queries
    if (settings.isNamedQueryStartupCheckingEnabled()) {
      Map errors = checkNamedQueries();
      if (!errors.isEmpty()) {
        Set keys = errors.keySet();
        StringBuffer failingQueries = new StringBuffer("Errors in named queries: ");
        for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) {
          String queryName = (String) iterator.next();
          HibernateException e = (HibernateException) errors.get(queryName);
          failingQueries.append(queryName);
          if (iterator.hasNext()) {
            failingQueries.append(", ");
          }
          log.error("Error in named query: " + queryName, e);
        }
        throw new HibernateException(failingQueries.toString());
      }
    }

    // stats
    getStatistics().setStatisticsEnabled(settings.isStatisticsEnabled());

    // EntityNotFoundDelegate
    EntityNotFoundDelegate entityNotFoundDelegate = cfg.getEntityNotFoundDelegate();
    if (entityNotFoundDelegate == null) {
      entityNotFoundDelegate =
          new EntityNotFoundDelegate() {
            public void handleEntityNotFound(String entityName, Serializable id) {
              throw new ObjectNotFoundException(id, entityName);
            }

            public boolean isEntityNotFoundException(RuntimeException exception) {
              return ObjectNotFoundException.class.isInstance(exception);
            }
          };
    }
    this.entityNotFoundDelegate = entityNotFoundDelegate;

    // this needs to happen after persisters are all ready to go...
    this.fetchProfiles = new HashMap();
    itr = cfg.iterateFetchProfiles();
    while (itr.hasNext()) {
      final org.hibernate.mapping.FetchProfile mappingProfile =
          (org.hibernate.mapping.FetchProfile) itr.next();
      final FetchProfile fetchProfile = new FetchProfile(mappingProfile.getName());
      Iterator fetches = mappingProfile.getFetches().iterator();
      while (fetches.hasNext()) {
        final org.hibernate.mapping.FetchProfile.Fetch mappingFetch =
            (org.hibernate.mapping.FetchProfile.Fetch) fetches.next();
        // resolve the persister owning the fetch
        final String entityName = getImportedClassName(mappingFetch.getEntity());
        final EntityPersister owner =
            (EntityPersister) (entityName == null ? null : entityPersisters.get(entityName));
        if (owner == null) {
          throw new HibernateException(
              "Unable to resolve entity reference ["
                  + mappingFetch.getEntity()
                  + "] in fetch profile ["
                  + fetchProfile.getName()
                  + "]");
        }

        // validate the specified association fetch
        Type associationType = owner.getPropertyType(mappingFetch.getAssociation());
        if (associationType == null || !associationType.isAssociationType()) {
          throw new HibernateException(
              "Fetch profile [" + fetchProfile.getName() + "] specified an invalid association");
        }

        // resolve the style
        final Fetch.Style fetchStyle = Fetch.Style.parse(mappingFetch.getStyle());

        // then construct the fetch instance...
        fetchProfile.addFetch(new Association(owner, mappingFetch.getAssociation()), fetchStyle);
        ((Loadable) owner).registerAffectingFetchProfile(fetchProfile.getName());
      }
      fetchProfiles.put(fetchProfile.getName(), fetchProfile);
    }

    this.observer.sessionFactoryCreated(this);
  }