Examples with EntityReferenceProcessingState org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState used on opensource projects

Example 1 with EntityReferenceProcessingState

use of org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState in project hibernate-orm by hibernate.

the class EntityReferenceInitializerImpl method handleMissingIdentifier.

private void handleMissingIdentifier(ResultSetProcessingContext context) {
    if (EntityFetch.class.isInstance(entityReference)) {
        final EntityFetch fetch = (EntityFetch) entityReference;
        final EntityType fetchedType = fetch.getFetchedType();
        if (!fetchedType.isOneToOne()) {
            return;
        }
        final EntityReferenceProcessingState fetchOwnerState = context.getOwnerProcessingState(fetch);
        if (fetchOwnerState == null) {
            throw new IllegalStateException("Could not locate fetch owner state");
        }
        final EntityKey ownerEntityKey = fetchOwnerState.getEntityKey();
        if (ownerEntityKey != null) {
            context.getSession().getPersistenceContext().addNullProperty(ownerEntityKey, fetchedType.getPropertyName());
        }
    }
}

Example 2 with EntityReferenceProcessingState

use of org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState in project hibernate-orm by hibernate.

the class EntityReferenceInitializerImpl method hydrateEntityState.

@Override
public void hydrateEntityState(ResultSet resultSet, ResultSetProcessingContextImpl context) {
    final EntityReferenceProcessingState processingState = context.getProcessingState(entityReference);
    // If there is no identifier for this entity reference for this row, nothing to do
    if (processingState.isMissingIdentifier()) {
        handleMissingIdentifier(context);
        return;
    }
    // make sure we have the EntityKey
    final EntityKey entityKey = processingState.getEntityKey();
    if (entityKey == null) {
        handleMissingIdentifier(context);
        return;
    }
    // Have we already hydrated this entity's state?
    if (processingState.getEntityInstance() != null) {
        return;
    }
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // In getting here, we know that:
    // 1) We need to hydrate the entity state
    // 2) We have a valid EntityKey for the entity
    // see if we have an existing entry in the session for this EntityKey
    final Object existing = context.getSession().getEntityUsingInterceptor(entityKey);
    if (existing != null) {
        // It is previously associated with the Session, perform some checks
        if (!entityReference.getEntityPersister().isInstance(existing)) {
            throw new WrongClassException("loaded object was of wrong class " + existing.getClass(), entityKey.getIdentifier(), entityReference.getEntityPersister().getEntityName());
        }
        checkVersion(resultSet, context, entityKey, existing);
        // use the existing association as the hydrated state
        processingState.registerEntityInstance(existing);
        // context.registerHydratedEntity( entityReference, entityKey, existing );
        return;
    }
    // Otherwise, we need to load it from the ResultSet...
    // determine which entity instance to use.  Either the supplied one, or instantiate one
    Object entityInstance = null;
    if (isReturn && context.shouldUseOptionalEntityInformation() && context.getQueryParameters().getOptionalObject() != null) {
        final EntityKey optionalEntityKey = ResultSetProcessorHelper.getOptionalObjectKey(context.getQueryParameters(), context.getSession());
        if (optionalEntityKey != null && optionalEntityKey.equals(entityKey)) {
            entityInstance = context.getQueryParameters().getOptionalObject();
        }
    }
    final String concreteEntityTypeName = getConcreteEntityTypeName(resultSet, context, entityKey);
    if (entityInstance == null) {
        entityInstance = context.getSession().instantiate(concreteEntityTypeName, entityKey.getIdentifier());
    }
    processingState.registerEntityInstance(entityInstance);
    // need to hydrate it.
    // grab its state from the ResultSet and keep it in the Session
    // (but don't yet initialize the object itself)
    // note that we acquire LockMode.READ even if it was not requested
    log.trace("hydrating entity state");
    final LockMode requestedLockMode = context.resolveLockMode(entityReference);
    final LockMode lockModeToAcquire = requestedLockMode == LockMode.NONE ? LockMode.READ : requestedLockMode;
    loadFromResultSet(resultSet, context, entityInstance, concreteEntityTypeName, entityKey, lockModeToAcquire);
}

Example 3 with EntityReferenceProcessingState

use of org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState in project hibernate-orm by hibernate.

the class EntityReferenceInitializerImpl method resolveEntityKey.

@Override
public void resolveEntityKey(ResultSet resultSet, ResultSetProcessingContextImpl context) {
    final EntityReferenceProcessingState processingState = context.getProcessingState(entityReference);
    // see if we already have an EntityKey associated with this EntityReference in the processing state.
    // if we do, this should have come from the optional entity identifier...
    final EntityKey entityKey = processingState.getEntityKey();
    if (entityKey != null) {
        log.debugf("On call to EntityIdentifierReaderImpl#resolve, EntityKey was already known; " + "should only happen on root returns with an optional identifier specified");
        return;
    }
    // Look for the hydrated form
    final Object identifierHydratedForm = processingState.getIdentifierHydratedForm();
    if (identifierHydratedForm == null) {
        // to resolve its EntityKey
        return;
    }
    final Type identifierType = entityReference.getEntityPersister().getIdentifierType();
    final Serializable resolvedId = (Serializable) identifierType.resolve(identifierHydratedForm, context.getSession(), null);
    if (resolvedId != null) {
        processingState.registerEntityKey(context.getSession().generateEntityKey(resolvedId, entityReference.getEntityPersister()));
    }
}

Example 4 with EntityReferenceProcessingState

use of org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState in project hibernate-orm by hibernate.

the class EntityReferenceInitializerImpl method hydrateIdentifier.

@Override
public void hydrateIdentifier(ResultSet resultSet, ResultSetProcessingContextImpl context) throws SQLException {
    final EntityReferenceProcessingState processingState = context.getProcessingState(entityReference);
    // get any previously registered identifier hydrated-state
    Object identifierHydratedForm = processingState.getIdentifierHydratedForm();
    if (identifierHydratedForm == null) {
        // if there is none, read it from the result set
        identifierHydratedForm = readIdentifierHydratedState(resultSet, context);
        // broadcast the fact that a hydrated identifier value just became associated with
        // this entity reference
        processingState.registerIdentifierHydratedForm(identifierHydratedForm);
    }
}

Example 5 with EntityReferenceProcessingState

use of org.hibernate.loader.plan.exec.process.spi.ResultSetProcessingContext.EntityReferenceProcessingState in project hibernate-orm by hibernate.

the class EntityReturnReader method read.

@Override
public Object read(ResultSet resultSet, ResultSetProcessingContext context) throws SQLException {
    final EntityReferenceProcessingState processingState = getIdentifierResolutionContext(context);
    final EntityKey entityKey = processingState.getEntityKey();
    final Object entityInstance = context.getProcessingState(entityReturn).getEntityInstance();
    if (context.shouldReturnProxies()) {
        final Object proxy = context.getSession().getPersistenceContext().proxyFor(entityReturn.getEntityPersister(), entityKey, entityInstance);
        if (proxy != entityInstance) {
            ((HibernateProxy) proxy).getHibernateLazyInitializer().setImplementation(proxy);
            return proxy;
        }
    }
    return entityInstance;
}