Java Code Examples for org.hibernate.engine.spi.SessionFactoryImplementor

@Override
public String render(Type firstArgumentType, List arguments, SessionFactoryImplementor sessionFactory) {
	final boolean hasArgs = !arguments.isEmpty();
	final StringBuilder buf = new StringBuilder( getName() );
	if ( hasArgs ) {
		buf.append( "(" );
		for ( int i = 0; i < arguments.size(); i++ ) {
			buf.append( arguments.get( i ) );
			if ( i < arguments.size() - 1 ) {
				buf.append( ", " );
			}
		}
		buf.append( ")" );
	}
	return buf.toString();
}
 

@Override
public long getNumberOfAssociations(SessionFactory sessionFactory) {
	int associationCount = 0;
	IgniteDatastoreProvider datastoreProvider = getProvider( sessionFactory );
	for ( CollectionPersister collectionPersister : ( (SessionFactoryImplementor) sessionFactory ).getCollectionPersisters().values() ) {
		AssociationKeyMetadata associationKeyMetadata = ( (OgmCollectionPersister) collectionPersister ).getAssociationKeyMetadata();
		if ( associationKeyMetadata.getAssociationKind() == AssociationKind.ASSOCIATION ) {
			IgniteCache<Object, BinaryObject> associationCache = getAssociationCache( sessionFactory, associationKeyMetadata );
			StringBuilder query = new StringBuilder( "SELECT " )
										.append( StringHelper.realColumnName( associationKeyMetadata.getColumnNames()[0] ) )
										.append( " FROM " ).append( associationKeyMetadata.getTable() );
			SqlFieldsQuery sqlQuery = datastoreProvider.createSqlFieldsQueryWithLog( query.toString(), null );
			Iterable<List<?>> queryResult = associationCache.query( sqlQuery );
			Set<Object> uniqs = new HashSet<>();
			for ( List<?> row : queryResult ) {
				Object value = row.get( 0 );
				if ( value != null ) {
					uniqs.add( value );
				}
			}
			associationCount += uniqs.size();
		}
	}
	return associationCount;
}
 

private void addAssociationsToTheSetForOneProperty(String name, Type type, String prefix, SessionFactoryImplementor factory) {

		if ( type.isCollectionType() ) {
			CollectionType collType = (CollectionType) type;
			Type assocType = collType.getElementType( factory );
			addAssociationsToTheSetForOneProperty(name, assocType, prefix, factory);
		}
		//ToOne association
		else if ( type.isEntityType() || type.isAnyType() ) {
			associations.add( prefix + name );
		} else if ( type.isComponentType() ) {
			CompositeType componentType = (CompositeType) type;
			addAssociationsToTheSetForAllProperties(
					componentType.getPropertyNames(),
					componentType.getSubtypes(),
					(prefix.equals( "" ) ? name : prefix + name) + ".",
					factory);
		}
	}
 

@Override
public String getAssociatedEntityName(SessionFactoryImplementor factory)
		throws MappingException {
	try {
		
		QueryableCollection collectionPersister = (QueryableCollection) factory
				.getCollectionPersister( role );
		
		if ( !collectionPersister.getElementType().isEntityType() ) {
			throw new MappingException( 
					"collection was not an association: " + 
					collectionPersister.getRole() 
				);
		}
		
		return collectionPersister.getElementPersister().getEntityName();
		
	}
	catch (ClassCastException cce) {
		throw new MappingException( "collection role is not queryable " + role );
	}
}
 

@Override
public String toLoggableString(Object value, SessionFactoryImplementor factory)
		throws HibernateException {
	if ( value == null ) {
		return "null";
	}

	if ( entityMode == null ) {
		throw new ClassCastException( value.getClass().getName() );
	}
	Map<String,String> result = new HashMap<String, String>();
	Object[] values = getPropertyValues( value, entityMode );
	for ( int i = 0; i < propertyTypes.length; i++ ) {
		result.put( propertyNames[i], propertyTypes[i].toLoggableString( values[i], factory ) );
	}
	return StringHelper.unqualify( getName() ) + result.toString();
}
 

@Override
public final String toSqlString(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
	final String entityName = criteriaQuery.getEntityName( criteria, propertyName );
	final String actualPropertyName = criteriaQuery.getPropertyName( propertyName );
	final String sqlAlias = criteriaQuery.getSQLAlias( criteria, propertyName );

	final SessionFactoryImplementor factory = criteriaQuery.getFactory();
	final QueryableCollection collectionPersister = getQueryableCollection( entityName, actualPropertyName, factory );

	final String[] collectionKeys = collectionPersister.getKeyColumnNames();
	final String[] ownerKeys = ( (Loadable) factory.getEntityPersister( entityName ) ).getIdentifierColumnNames();

	final String innerSelect = "(select 1 from " + collectionPersister.getTableName() + " where "
			+ new ConditionFragment().setTableAlias( sqlAlias ).setCondition( ownerKeys, collectionKeys ).toFragmentString()
			+ ")";

	return excludeEmpty()
			? "exists " + innerSelect
			: "not exists " + innerSelect;
}
 

@Override
public String render(Type columnType, List args, SessionFactoryImplementor factory) throws QueryException {
	if ( args.size()!=2 ) {
		throw new QueryException( "cast() requires two arguments; found : " + args.size() );
	}
	final String type = (String) args.get( 1 );
	final int[] sqlTypeCodes = factory.getTypeResolver().heuristicType( type ).sqlTypes( factory );
	if ( sqlTypeCodes.length!=1 ) {
		throw new QueryException("invalid Hibernate type for cast()");
	}
	String sqlType = factory.getDialect().getCastTypeName( sqlTypeCodes[0] );
	if ( sqlType == null ) {
		//TODO: never reached, since getExplicitHibernateTypeName() actually throws an exception!
		sqlType = type;
	}
	return "cast(" + args.get( 0 ) + " as " + sqlType + ')';
}
 

/**
 * Creates the inner query used to extract some useful information about types, since it is needed in both methods.
 *
 * @param criteriaQuery The criteria query
 * @param factory The session factory.
 */
private void createAndSetInnerQuery(CriteriaQuery criteriaQuery, SessionFactoryImplementor factory) {
	if ( innerQuery == null ) {
		//with two-deep subqueries, the same alias would get generated for
		//both using the old method (criteriaQuery.generateSQLAlias()), so
		//that is now used as a fallback if the main criteria alias isn't set
		String alias;
		if ( this.criteriaImpl.getAlias() == null ) {
			alias = criteriaQuery.generateSQLAlias();
		}
		else {
			alias = this.criteriaImpl.getAlias() + "_";
		}

		innerQuery = new CriteriaQueryTranslator(
				factory,
				criteriaImpl,
				criteriaImpl.getEntityOrClassName(),
				alias,
				criteriaQuery
			);

		params = innerQuery.getQueryParameters();
		types = innerQuery.getProjectedTypes();
	}
}
 

private void associateSubclassNamesToSubclassTableIndexes(
		PersistentClass persistentClass,
		Set<String> classNames,
		String[][] mapping,
		SessionFactoryImplementor factory) {

	final String tableName = persistentClass.getTable().getQualifiedName(
			factory.getDialect(),
			factory.getSettings().getDefaultCatalogName(),
			factory.getSettings().getDefaultSchemaName()
	);

	associateSubclassNamesToSubclassTableIndex( tableName, classNames, mapping );

	Iterator itr = persistentClass.getJoinIterator();
	while ( itr.hasNext() ) {
		final Join join = (Join) itr.next();
		final String secondaryTableName = join.getTable().getQualifiedName(
				factory.getDialect(),
				factory.getSettings().getDefaultCatalogName(),
				factory.getSettings().getDefaultSchemaName()
		);
		associateSubclassNamesToSubclassTableIndex( secondaryTableName, classNames, mapping );
	}
}
 

@Override
public Map<String, Object> extractEntityTuple(Session session, EntityKey key) {
	SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) session.getSessionFactory();
	IgniteCache<Object, BinaryObject> cache = getEntityCache( sessionFactory, key.getMetadata() );
	Object cacheKey = getProvider( sessionFactory ).createKeyObject( key );

	Map<String, Object> result = new HashMap<>();
	BinaryObject po = cache.get( cacheKey );

	TupleSnapshot snapshot = new IgniteTupleSnapshot( cacheKey, po, key.getMetadata() );
	for ( String fieldName : snapshot.getColumnNames() ) {
		result.put( fieldName, snapshot.get( fieldName ) );
	}

	return result;
}
 

protected BasicCollectionLoader(
		QueryableCollection collectionPersister,
		int batchSize,
		String subquery,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( collectionPersister, factory, loadQueryInfluencers );

	JoinWalker walker = new BasicCollectionJoinWalker(
			collectionPersister,
			batchSize,
			subquery,
			factory,
			loadQueryInfluencers
	);
	initFromWalker( walker );

	postInstantiate();

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Static select for collection %s: %s", collectionPersister.getRole(), getSQLString() );
	}
}
 

public JoinDefinedByMetadata createCollectionJoin(
		QuerySpace leftHandSide,
		String lhsPropertyName,
		CollectionQuerySpace rightHandSide,
		boolean rightHandSideRequired,
		CollectionType joinedPropertyType,
		SessionFactoryImplementor sessionFactory) {
	return new JoinImpl(
			leftHandSide,
			lhsPropertyName,
			rightHandSide,
			joinedPropertyType.getAssociatedJoinable( sessionFactory ).getKeyColumnNames(),
			joinedPropertyType,
			rightHandSideRequired
	);
}
 

@Override
public String render(Type firstArgumentType, List args, SessionFactoryImplementor factory) throws QueryException {
	final boolean threeArgs = args.size() > 2;
	final Object pattern = args.get( 0 );
	final Object string = args.get( 1 );
	final Object start = threeArgs ? args.get( 2 ) : null;

	final StringBuilder buf = new StringBuilder();
	if (threeArgs) {
		buf.append( '(' );
	}
	buf.append( "position(" ).append( pattern ).append( " in " );
	if (threeArgs) {
		buf.append( "substring(");
	}
	buf.append( string );
	if (threeArgs) {
		buf.append( ", " ).append( start ).append( ')' );
	}
	buf.append( ')' );
	if (threeArgs) {
		buf.append( '+' ).append( start ).append( "-1)" );
	}
	return buf.toString();
}
 

@SuppressWarnings( {"unchecked"})
public SessionFactoryServiceRegistryImpl(
		ServiceRegistryImplementor parent,
		SessionFactoryImplementor sessionFactory,
		MetadataImplementor metadata) {
	super( parent );

	this.sessionFactory = sessionFactory;
	this.configuration = null;
	this.metadata = metadata;

	// for now, just use the standard initiator list
	for ( SessionFactoryServiceInitiator initiator : StandardSessionFactoryServiceInitiators.LIST ) {
		// create the bindings up front to help identify to which registry services belong
		createServiceBinding( initiator );
	}
}
 

protected String generateLockString(int timeout) {
	final SessionFactoryImplementor factory = getLockable().getFactory();
	final LockOptions lockOptions = new LockOptions( getLockMode() );
	lockOptions.setTimeOut( timeout );
	final SimpleSelect select = new SimpleSelect( factory.getDialect() )
			.setLockOptions( lockOptions )
			.setTableName( getLockable().getRootTableName() )
			.addColumn( getLockable().getRootTableIdentifierColumnNames()[0] )
			.addCondition( getLockable().getRootTableIdentifierColumnNames(), "=?" );
	if ( getLockable().isVersioned() ) {
		select.addCondition( getLockable().getVersionColumnName(), "=?" );
	}
	if ( factory.getSettings().isCommentsEnabled() ) {
		select.setComment( getLockMode() + " lock " + getLockable().getEntityName() );
	}
	return select.toStatementString();
}
 

private Set<String> processPersistentClassHierarchy(
		PersistentClass persistentClass,
		boolean isBase,
		SessionFactoryImplementor factory,
		String[][] mapping) {

	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// collect all the class names that indicate that the "main table" of the given PersistentClass should be
	// included when one of the collected class names is used in TREAT
	final Set<String> classNames = new HashSet<String>();

	final Iterator itr = persistentClass.getDirectSubclasses();
	while ( itr.hasNext() ) {
		final Subclass subclass = (Subclass) itr.next();
		final Set<String> subclassSubclassNames = processPersistentClassHierarchy(
				subclass,
				false,
				factory,
				mapping
		);
		classNames.addAll( subclassSubclassNames );
	}

	classNames.add( persistentClass.getEntityName() );

	if ( ! isBase ) {
		MappedSuperclass msc = persistentClass.getSuperMappedSuperclass();
		while ( msc != null ) {
			classNames.add( msc.getMappedClass().getName() );
			msc = msc.getSuperMappedSuperclass();
		}

		associateSubclassNamesToSubclassTableIndexes( persistentClass, classNames, mapping, factory );
	}

	return classNames;
}
 

public UnionSubclassEntityPersister(
		final EntityBinding entityBinding,
		final EntityRegionAccessStrategy cacheAccessStrategy,
		final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		final SessionFactoryImplementor factory,
		final Mapping mapping) throws HibernateException {
	super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
	// TODO: implement!!! initializing final fields to null to make compiler happy.
	subquery = null;
	tableName = null;
	subclassClosure = null;
	spaces = null;
	subclassSpaces = null;
	discriminatorValue = null;
	discriminatorSQLValue = null;
	constraintOrderedTableNames = null;
	constraintOrderedKeyColumnNames = null;
}
 

/**
 * Constructs a EntityLoadQueryDetails object from the given inputs.
 *
 * @param loadPlan The load plan
 * @param buildingParameters Any influencers that would affect the generated SQL (mostly we are concerned with those
 * that add additional joins here)
 * @param factory The SessionFactory
 *
 * @return The EntityLoadQueryDetails
 */
OneToManyLoadQueryDetails(
		LoadPlan loadPlan,
		AliasResolutionContextImpl aliasResolutionContext,
		CollectionReturn rootReturn,
		QueryBuildingParameters buildingParameters,
		SessionFactoryImplementor factory) {
	super(
			loadPlan,
			aliasResolutionContext,
			rootReturn,
			buildingParameters,
			factory
	);
	generate();
}
 

@Override
public void integrate(Metadata metadata, SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry) {
    EventListenerRegistry service = serviceRegistry.getService(org.hibernate.event.service.spi.EventListenerRegistry.class);

    StandardPBEStringEncryptor encrypt = new StandardPBEStringEncryptor();
    encrypt.setPassword("test_password");
    RenderedMessageEncryptEventListener encryptListener = new RenderedMessageEncryptEventListener();
    encryptListener.setStringEncryptor(encrypt);

    RenderedMessageDecryptEventListener decryptListener = new RenderedMessageDecryptEventListener();
    decryptListener.setStringEncryptor(encrypt);

    FullTextIndexEventListener fullTextListener = new FullTextIndexEventListener();

    service.appendListeners(EventType.PRE_UPDATE, encryptListener);
    service.prependListeners(EventType.POST_UPDATE, decryptListener);
    service.appendListeners(EventType.PRE_INSERT, encryptListener);
    service.prependListeners(EventType.POST_INSERT, decryptListener);
    service.appendListeners(EventType.POST_LOAD, decryptListener);
}
 

public SubselectOneToManyLoader(
		QueryableCollection persister, 
		String subquery,
		Collection entityKeys,
		QueryParameters queryParameters,
		Map<String, int[]> namedParameterLocMap,
		SessionFactoryImplementor factory, 
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( persister, 1, subquery, factory, loadQueryInfluencers );

	keys = new Serializable[ entityKeys.size() ];
	Iterator iter = entityKeys.iterator();
	int i=0;
	while ( iter.hasNext() ) {
		keys[i++] = ( (EntityKey) iter.next() ).getIdentifier();
	}
	
	this.namedParameters = queryParameters.getNamedParameters();
	this.types = queryParameters.getFilteredPositionalParameterTypes();
	this.values = queryParameters.getFilteredPositionalParameterValues();
	this.namedParameterLocMap = namedParameterLocMap;
}
 

private static RedisDatastoreProvider getProvider(SessionFactory sessionFactory) {
	DatastoreProvider provider = ( (SessionFactoryImplementor) sessionFactory ).getServiceRegistry().getService(
			DatastoreProvider.class
	);
	if ( !( RedisDatastoreProvider.class.isInstance( provider ) ) ) {
		throw new RuntimeException( "Not testing with RedisDatastoreProvider, cannot extract underlying map." );
	}

	return RedisDatastoreProvider.class.cast( provider );
}
 

@Override
public void initialize() {
	// TODO : this really needs to be delayed unitl after we definitively know the operand node type;
	// where this is currently a problem is parameters for which where we cannot unequivocally
	// resolve an expected type
	Type operandType = extractDataType( getOperand() );
	if ( operandType == null ) {
		return;
	}
	SessionFactoryImplementor sessionFactory = getSessionFactoryHelper().getFactory();
	int operandColumnSpan = operandType.getColumnSpan( sessionFactory );
	if ( operandColumnSpan > 1 ) {
		mutateRowValueConstructorSyntax( operandColumnSpan );
	}
}
 

protected AbstractCompositionAttribute(
		AttributeSource source,
		SessionFactoryImplementor sessionFactory,
		int entityBasedAttributeNumber,
		String attributeName,
		CompositeType attributeType,
		int columnStartPosition,
		BaselineAttributeInformation baselineInfo) {
	super( source, sessionFactory, entityBasedAttributeNumber, attributeName, attributeType, baselineInfo );
	this.columnStartPosition = columnStartPosition;
}
 

@Override
@SuppressWarnings( {"unchecked"})
public EntityPersister createEntityPersister(
		PersistentClass metadata,
		EntityRegionAccessStrategy cacheAccessStrategy,
		NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		SessionFactoryImplementor factory,
		Mapping cfg) {
	Class<? extends EntityPersister> persisterClass = metadata.getEntityPersisterClass();
	if ( persisterClass == null ) {
		persisterClass = serviceRegistry.getService( PersisterClassResolver.class ).getEntityPersisterClass( metadata );
	}
	return create( persisterClass, ENTITY_PERSISTER_CONSTRUCTOR_ARGS, metadata, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, cfg );
}
 

@Override
public QueryParserService initiateService(
		SessionFactoryImplementor sessionFactory,
		SessionFactoryOptions sessionFactoryOptions,
		ServiceRegistryImplementor registry) {
	return IgniteQueryParserService.INSTANCE;
}
 

@Override
public String toLoggableString(Object value, SessionFactoryImplementor factory) throws HibernateException {
	//TODO: terrible implementation!
	return value == null
			? "null"
			: factory.getTypeHelper()
			.entity( HibernateProxyHelper.getClassWithoutInitializingProxy( value ) )
			.toLoggableString( value, factory );
}
 

/**
 * Generate an info message string relating to a particular entity.
 *
 * @param persister The persister for the entity
 * @param id The entity id value
 * @param factory The session factory - Could be null!
 * @return An info string, in the form [FooBar#1]
 */
public static String infoString(
		EntityPersister persister,
		Object id, 
		SessionFactoryImplementor factory) {
	StringBuilder s = new StringBuilder();
	s.append( '[' );
	Type idType;
	if( persister == null ) {
		s.append( "<null EntityPersister>" );
		idType = null;
	}
	else {
		s.append( persister.getEntityName() );
		idType = persister.getIdentifierType();
	}
	s.append( '#' );

	if ( id == null ) {
		s.append( "<null>" );
	}
	else {
		if ( idType == null ) {
			s.append( id );
		}
		else {
			if ( factory != null ) {
				s.append( idType.toLoggableString( id, factory ) );
			}
			else {
				s.append( "<not loggable>" );
			}
		}
	}
	s.append( ']' );

	return s.toString();

}
 

@Override
public void setToXMLNode(Node node, Object value, SessionFactoryImplementor factory)
		throws HibernateException {
	if ( !isEmbeddedInXML ) {
		node.detach();
	}
	else {
		replaceNode( node, (Element) value );
	}
}
 

@Override
public String getOnCondition(
		String alias,
		SessionFactoryImplementor factory,
		Map enabledFilters,
		Set<String> treatAsDeclarations) {
	throw new UnsupportedOperationException();
}
 

/**
 * The map of defined filters.  This is expected to be in format
 * where the filter names are the map keys, and the defined
 * conditions are the values.
 *
 * @param filters The map of defined filters.
 * @param factory The session factory
 */
public FilterHelper(List<FilterConfiguration> filters, SessionFactoryImplementor factory) {
	int filterCount = filters.size();
	filterNames = new String[filterCount];
	filterConditions = new String[filterCount];
	filterAutoAliasFlags = new boolean[filterCount];
	filterAliasTableMaps = new Map[filterCount];
	filterCount = 0;
	for ( final FilterConfiguration filter : filters ) {
		filterAutoAliasFlags[filterCount] = false;
		filterNames[filterCount] = filter.getName();
		filterConditions[filterCount] = filter.getCondition();
		filterAliasTableMaps[filterCount] = filter.getAliasTableMap( factory );
		if ( (filterAliasTableMaps[filterCount].isEmpty() || isTableFromPersistentClass( filterAliasTableMaps[filterCount] )) && filter
				.useAutoAliasInjection() ) {
			filterConditions[filterCount] = Template.renderWhereStringTemplate(
					filter.getCondition(),
					FilterImpl.MARKER,
					factory.getDialect(),
					factory.getSqlFunctionRegistry()
			);
			filterAutoAliasFlags[filterCount] = true;
		}
		filterConditions[filterCount] = StringHelper.replace(
				filterConditions[filterCount],
				":",
				":" + filterNames[filterCount] + "."
		);
		filterCount++;
	}
}
 

@Override
public boolean isEqual(Object x, Object y, SessionFactoryImplementor factory) {
	if ( x == y ) return true;
	if ( x == null || y == null ) return false;
	if ( x instanceof Byte[] ) {
		Object[] o1 = (Object[]) x;
		Object[] o2 = (Object[]) y;
		return ArrayHelper.isEquals( o1, o2 );
	}
	else {
		byte[] c1 = (byte[]) x;
		byte[] c2 = (byte[]) y;
		return ArrayHelper.isEquals( c1, c2 );
	}
}
 

private void integrate(SessionFactoryServiceRegistry serviceRegistry, SessionFactoryImplementor sessionFactory) {
	if ( !sessionFactory.getSettings().isAutoEvictCollectionCache() ) {
		// feature is disabled
		return;
	}
	if ( !sessionFactory.getSettings().isSecondLevelCacheEnabled() ) {
		// Nothing to do, if caching is disabled
		return;
	}
	EventListenerRegistry eventListenerRegistry = serviceRegistry.getService( EventListenerRegistry.class );
	eventListenerRegistry.appendListeners( EventType.POST_INSERT, this );
	eventListenerRegistry.appendListeners( EventType.POST_DELETE, this );
	eventListenerRegistry.appendListeners( EventType.POST_UPDATE, this );
}
 

/**
 * 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
		);
}
 

public static BatchingEntityLoaderBuilder getBuilder(SessionFactoryImplementor factory) {
		switch ( factory.getSettings().getBatchFetchStyle() ) {
			case PADDED: {
				return PaddedBatchingEntityLoaderBuilder.INSTANCE;
			}
			case DYNAMIC: {
				return DynamicBatchingEntityLoaderBuilder.INSTANCE;
			}
			default: {
				return org.hibernate.loader.entity.plan.LegacyBatchingEntityLoaderBuilder.INSTANCE;
//				return LegacyBatchingEntityLoaderBuilder.INSTANCE;
			}
		}
	}
 

/**
 * Builds a batch-fetch capable loader based on the given persister, lock-mode, etc.
 *
 * @param persister The entity persister
 * @param batchSize The maximum number of ids to batch-fetch at once
 * @param lockMode The lock mode
 * @param factory The SessionFactory
 * @param influencers Any influencers that should affect the built query
 *
 * @return The loader.
 */
public UniqueEntityLoader buildLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	if ( batchSize <= 1 ) {
		// no batching
		return buildNonBatchingLoader( persister, lockMode, factory, influencers );
	}
	return buildBatchingLoader( persister, batchSize, lockMode, factory, influencers );
}
 

/**
 * @see QueryTranslatorFactory#createQueryTranslator
 */
public QueryTranslator createQueryTranslator(
		String queryIdentifier,
        String queryString,
        Map filters,
        SessionFactoryImplementor factory,
        EntityGraphQueryHint entityGraphQueryHint) {
	if (entityGraphQueryHint != null) {
		throw new QueryException( "EntityGraphs cannot be applied queries using the classic QueryTranslator!" );
	}
	return new QueryTranslatorImpl( queryIdentifier, queryString, filters, factory );
}
 

public static String renderOrderByStringTemplate(
		String orderByFragment,
		final ColumnMapper columnMapper,
		final SessionFactoryImplementor sessionFactory,
		final Dialect dialect,
		final SQLFunctionRegistry functionRegistry) {
	return translateOrderBy(
			orderByFragment,
			columnMapper,
			sessionFactory,
			dialect,
			functionRegistry
	).injectAliases( LEGACY_ORDER_BY_ALIAS_RESOLVER );
}
 

public EntityBasedAssociationAttribute(
		EntityPersister source,
		SessionFactoryImplementor sessionFactory,
		int attributeNumber,
		String attributeName,
		AssociationType attributeType,
		BaselineAttributeInformation baselineInfo) {
	super( source, sessionFactory, attributeNumber, attributeName, attributeType, baselineInfo );
}
 

@Override
public long getNumberOfEntities(SessionFactory sessionFactory) {
	int entityCount = 0;
	Set<IgniteCache<?, ?>> processedCaches = Collections.newSetFromMap( new IdentityHashMap<IgniteCache<?, ?>, Boolean>() );
	for ( EntityPersister entityPersister : ( (SessionFactoryImplementor) sessionFactory ).getEntityPersisters().values() ) {
		IgniteCache<?, ?> entityCache = getEntityCache( sessionFactory, ( (OgmEntityPersister) entityPersister ).getEntityKeyMetadata() );
		if ( !processedCaches.contains( entityCache ) ) {
			entityCount += entityCache.size( CachePeekMode.ALL );
			processedCaches.add( entityCache );
		}
	}
	return entityCount;
}
 

public EntityLoader(
		OuterJoinLoadable persister,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	this( persister, 1, lockOptions, factory, loadQueryInfluencers );
}