@Override public SessionFactoryImplementor getFactory() { return delegate.getFactory(); }
@Override public EntityManagerFactory getEntityManagerFactory() { return delegate.getFactory(); }
public String getCastType(Class javaType) { SessionFactoryImplementor factory = entityManager.getFactory(); Type hibernateType = factory.getTypeResolver().heuristicType( javaType.getName() ); if ( hibernateType == null ) { throw new IllegalArgumentException( "Could not convert java type [" + javaType.getName() + "] to Hibernate type" ); } return hibernateType.getName(); }
private boolean isOrderUpdatesEnabled() { return session.getFactory().getSessionFactoryOptions().isOrderUpdatesEnabled(); }
private static int bindPositionalParameters( final PreparedStatement st, final Object[] values, final Type[] types, final int start, final SessionImplementor session) throws SQLException, HibernateException { int span = 0; for ( int i = 0; i < values.length; i++ ) { types[i].nullSafeSet( st, values[i], start + span, session ); span += types[i].getColumnSpan( session.getFactory() ); } return span; }
private Queryable getQueryable(String entityName, SessionImplementor sessionImplementor) { return (Queryable) sessionImplementor.getFactory().getMetamodel().entityPersister( entityName ); }
private boolean isOrderInsertsEnabled() { return session.getFactory().getSessionFactoryOptions().isOrderInsertsEnabled(); }
/** * @return Java class mapped to specified entity name. */ public static Class getEntityClass(SessionImplementor sessionImplementor, String entityName) { final EntityPersister entityPersister = sessionImplementor.getFactory().getMetamodel().entityPersister( entityName ); return entityPersister.getMappedClass(); } }
/** * Obtain a lob creator for the given session. * * @param session The session for which to obtain a lob creator * * @return The log creator reference */ public static LobCreator getLobCreator(SessionImplementor session) { return session.getFactory() .getServiceRegistry() .getService( JdbcServices.class ) .getLobCreator( session ); }
protected AbstractAuditQuery( EnversService enversService, AuditReaderImplementor versionsReader, Class<?> cls, String entityName) { this.enversService = enversService; this.versionsReader = versionsReader; criterions = new ArrayList<>(); entityInstantiator = new EntityInstantiator( enversService, versionsReader ); entityClassName = cls.getName(); this.entityName = entityName; versionsEntityName = enversService.getAuditEntitiesConfiguration().getAuditEntityName( entityName ); if ( !enversService.getEntitiesConfigurations().isVersioned( entityName ) ) { throw new NotAuditedException( entityName, "Entity [" + entityName + "] is not versioned" ); } aliasToEntityNameMap.put( REFERENCED_ENTITY_ALIAS, entityName ); qb = new QueryBuilder( versionsEntityName, REFERENCED_ENTITY_ALIAS, versionsReader.getSessionImplementor().getFactory() ); }
protected void performSecurityCheck( SessionImplementor session, PermissionCheckEntityInformation entityInformation, PermissibleAction action) { if ( jaccService == null ) { jaccService = session.getFactory().getServiceRegistry().getService( JaccService.class ); } jaccService.checkPermission( entityInformation, action ); } }
@Override public boolean mapToMapFromEntity( SessionImplementor session, Map<String, Object> data, Object newObj, Object oldObj) { data.put( propertyData.getName(), newObj ); boolean dbLogicallyDifferent = true; if ( (session.getFactory().getJdbcServices() .getDialect() instanceof Oracle8iDialect) && (newObj instanceof String || oldObj instanceof String) ) { // Don't generate new revision when database replaces empty string with NULL during INSERT or UPDATE statements. dbLogicallyDifferent = !(StringTools.isEmpty( newObj ) && StringTools.isEmpty( oldObj )); } return dbLogicallyDifferent && !areEqual( newObj, oldObj ); }
CriteriaImpl criteriaImpl = (CriteriaImpl)criteria; SessionImplementor session = criteriaImpl.getSession(); SessionFactoryImplementor factory = session.getFactory(); CriteriaQueryTranslator translator=new CriteriaQueryTranslator(factory,criteriaImpl,criteriaImpl.getEntityOrClassName(),CriteriaQueryTranslator.ROOT_SQL_ALIAS); String[] implementors = factory.getImplementors( criteriaImpl.getEntityOrClassName() ); CriteriaJoinWalker walker = new CriteriaJoinWalker((OuterJoinLoadable)factory.getEntityPersister(implementors[0]), translator, factory, criteriaImpl, criteriaImpl.getEntityOrClassName(), session.getLoadQueryInfluencers() ); String sql=walker.getSQLString();
public AddWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, Map<String, Object> data) { super( sessionImplementor, entityName, enversService, id, RevisionType.ADD ); this.data = data; final String[] propertyNames = sessionImplementor.getFactory().getMetamodel() .entityPersister( getEntityName() ) .getPropertyNames(); this.state = ArraysTools.mapToArray( data, propertyNames ); }
/** * This method is now called once per execution of an ExecutableList or once for execution of an Execution. * * @param spaces The spaces to invalidate */ private void invalidateSpaces(String... spaces) { if ( spaces != null && spaces.length > 0 ) { for ( Serializable s : spaces ) { if( afterTransactionProcesses == null ) { afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session ); } afterTransactionProcesses.addSpaceToInvalidate( (String) s ); } // Performance win: If we are processing an ExecutableList, this will only be called once session.getFactory().getCache().getTimestampsCache().preInvalidate( spaces, session ); } }
/** * Create Hibernate proxy or retrieve the complete object of referenced, not audited entity. According to * {@link org.hibernate.envers.Audited#targetAuditMode()}} documentation, reference shall point to current * (non-historical) version of an entity. */ private Object createNotAuditedEntityReference( AuditReaderImplementor versionsReader, Class<?> entityClass, String entityName, Serializable primaryKey) { final EntityPersister entityPersister = versionsReader.getSessionImplementor().getFactory().getMetamodel() .entityPersister( entityName ); if ( entityPersister.hasProxy() ) { // If possible create a proxy. Returning complete object may affect performance. return versionsReader.getSession().load( entityClass, primaryKey ); } else { // If proxy is not allowed (e.g. @Proxy(lazy=false)) construct the original object. return versionsReader.getSession().get( entityClass, primaryKey ); } } }
private Object[] getDatabaseSnapshot(SessionImplementor session, EntityPersister persister, Serializable id) { if ( persister.isSelectBeforeUpdateRequired() ) { Object[] snapshot = session.getPersistenceContext() .getDatabaseSnapshot( id, persister ); if ( snapshot == null ) { //do we even really need this? the update will fail anyway.... if ( session.getFactory().getStatistics().isStatisticsEnabled() ) { session.getFactory().getStatistics() .optimisticFailure( persister.getEntityName() ); } throw new StaleObjectStateException( persister.getEntityName(), id ); } return snapshot; } // TODO: optimize away this lookup for entities w/o unsaved-value="undefined" final EntityKey entityKey = session.generateEntityKey( id, persister ); return session.getPersistenceContext().getCachedDatabaseSnapshot( entityKey ); } }
private static void processNeverReferencedCollection(PersistentCollection coll, SessionImplementor session) throws HibernateException { final PersistenceContext persistenceContext = session.getPersistenceContext(); final CollectionEntry entry = persistenceContext.getCollectionEntry( coll ); if ( LOG.isDebugEnabled() ) { LOG.debugf( "Found collection with unloaded owner: %s", MessageHelper.collectionInfoString( entry.getLoadedPersister(), coll, entry.getLoadedKey(), session ) ); } entry.setCurrentPersister( entry.getLoadedPersister() ); entry.setCurrentKey( entry.getLoadedKey() ); prepareCollectionForUpdate( coll, entry, session.getFactory() ); }
private static void checkInBatchFetchQueue(long id, Session session, boolean expected) { final SessionImplementor sessionImplementor = (SessionImplementor) session; final EntityPersister persister = sessionImplementor.getFactory().getMetamodel().entityPersister( Task.class ); final BatchFetchQueue batchFetchQueue = sessionImplementor.getPersistenceContext().getBatchFetchQueue(); assertEquals( expected, batchFetchQueue.containsEntityKey( new EntityKey( id, persister ) ) ); }
private void registerCleanupActions(Executable executable) { if( executable.getBeforeTransactionCompletionProcess() != null ) { if( beforeTransactionProcesses == null ) { beforeTransactionProcesses = new BeforeTransactionCompletionProcessQueue( session ); } beforeTransactionProcesses.register( executable.getBeforeTransactionCompletionProcess() ); } if ( session.getFactory().getSessionFactoryOptions().isQueryCacheEnabled() ) { invalidateSpaces( convertTimestampSpaces( executable.getPropertySpaces() ) ); } if( executable.getAfterTransactionCompletionProcess() != null ) { if( afterTransactionProcesses == null ) { afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session ); } afterTransactionProcesses.register( executable.getAfterTransactionCompletionProcess() ); } }