@Override
public List listFilter(Object collection, String filter, QueryParameters queryParameters) {
	checkOpenOrWaitingForAutoClose();
	checkTransactionSynchStatus();
	FilterQueryPlan plan = getFilterQueryPlan( collection, filter, queryParameters, false );
	List results = Collections.EMPTY_LIST;

	boolean success = false;
	dontFlushFromFind++;   //stops flush being called multiple times if this method is recursively called
	try {
		results = plan.performList( queryParameters, this );
		success = true;
	}
	finally {
		dontFlushFromFind--;
		afterOperation( success );
		delayedAfterCompletion();
	}
	return results;
}
 

/**
 * Coordinates the efforts to perform an execution across all the included query translators.
 *
 * @param queryParameters The query parameters
 * @param session The session
 *
 * @return The aggregated "affected row" count
 *
 * @throws HibernateException Indicates a problem performing the execution
 */
public int performExecuteUpdate(QueryParameters queryParameters, SharedSessionContractImplementor session)
		throws HibernateException {
	if ( traceEnabled ) {
		LOG.tracev( "Execute update: {0}", getSourceQuery() );
		queryParameters.traceParameters( session.getFactory() );
	}
	if ( translators.length != 1 ) {
		LOG.splitQueries( getSourceQuery(), translators.length );
	}
	int result = 0;
	for ( QueryTranslator translator : translators ) {
		result += translator.executeUpdate( queryParameters, session );
	}
	return result;
}
 

public ReactiveSubselectOneToManyLoader(
		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 void needsLimitLoop(QueryParameters queryParameters, List<Object> combinedResults, IdentitySet distinction, AtomicInteger includedCount, List<Object> tmpList) {
	// NOTE : firstRow is zero-based
	final int first = queryParameters.getRowSelection().getFirstRow() == null ? 0 : queryParameters.getRowSelection().getFirstRow();
	final int max = queryParameters.getRowSelection().getMaxRows() == null ? -1 : queryParameters.getRowSelection().getMaxRows();
	for ( final Object result : tmpList ) {
		if ( !distinction.add( result ) ) {
			continue;
		}
		int included = includedCount.addAndGet( 1 );
		if ( included < first ) {
			continue;
		}
		combinedResults.add( result );
		if ( max >= 0 && included > max ) {
			return;
		}
	}
}
 

public CompletionStage<Integer> performExecuteReactiveUpdate(QueryParameters queryParameters, ReactiveSession session) {
	if ( log.isTraceEnabled() ) {
		log.tracev( "Execute update: {0}", getSourceQuery() );
		queryParameters.traceParameters( session.getFactory() );
	}
	QueryTranslator[] translators = getTranslators();
	if ( translators.length != 1 ) {
		log.splitQueries( getSourceQuery(), translators.length );
	}

	CompletionStage<Integer> combinedStage = CompletionStages.completedFuture(0);
	for ( QueryTranslator translator : translators ) {
		ReactiveQueryTranslatorImpl reactiveTranslator = (ReactiveQueryTranslatorImpl) translator;
		combinedStage = combinedStage
				.thenCompose(
						count -> reactiveTranslator.executeReactiveUpdate( queryParameters, session )
								.thenApply( updateCount -> count + updateCount )
				);
	}
	return combinedStage;
}
 

@Override
	public <T> CompletionStage<List<T>> reactiveList(String query, QueryParameters parameters) throws HibernateException {
		checkOpenOrWaitingForAutoClose();
		pulseTransactionCoordinator();
		parameters.validateParameters();

		HQLQueryPlan plan = parameters.getQueryPlan();
		if ( plan == null ) {
			plan = getQueryPlan( query, false );
		}
		ReactiveHQLQueryPlan reactivePlan = (ReactiveHQLQueryPlan) plan;

		return reactiveAutoFlushIfRequired( plan.getQuerySpaces() )
				// FIXME: I guess I can fix this as a separate issue
//				dontFlushFromFind++;   //stops flush being called multiple times if this method is recursively called
				.thenCompose( v -> reactivePlan.performReactiveList(parameters, this ) )
				.whenComplete( (list, x) -> {
//					dontFlushFromFind--;
					afterOperation( x == null );
					delayedAfterCompletion();
				} )
				//TODO: this typecast is rubbish
				.thenApply( list -> (List<T>) list );
	}
 

private CompletionStage<List<Object>> listReactiveCustomQuery(CustomQuery customQuery, QueryParameters parameters) {
		checkOpenOrWaitingForAutoClose();
//		checkTransactionSynchStatus();

		ReactiveCustomLoader loader = new ReactiveCustomLoader( customQuery, getFactory() );

//		autoFlushIfRequired( loader.getQuerySpaces() );

//		dontFlushFromFind++;
//		boolean success = false;
			return loader.reactiveList( this, parameters )
					.whenComplete( (r, e) -> delayedAfterCompletion() );
//			success = true;
//			dontFlushFromFind--;
//			afterOperation( success );
	}
 

@Override
public CompletionStage<Integer> executeReactiveUpdate(NativeSQLQuerySpecification specification,
													  QueryParameters parameters) {
	checkOpenOrWaitingForAutoClose();
	pulseTransactionCoordinator();
	parameters.validateParameters();

	ReactiveNativeSQLQueryPlan reactivePlan = //getNativeQueryPlan( specification );
			new ReactiveNativeSQLQueryPlan(
					specification.getQueryString(),
					new SQLCustomQuery(
							specification.getQueryString(),
							specification.getQueryReturns(),
							specification.getQuerySpaces(),
							getFactory()
					) );
	return reactiveAutoFlushIfRequired( reactivePlan.getCustomQuery().getQuerySpaces() )
			.thenCompose( v -> reactivePlan.performExecuteReactiveUpdate( parameters, this ) )
			.whenComplete( (count, x) -> {
				afterOperation( x == null );
				delayedAfterCompletion();
			} );
}
 

public CompletionStage<Integer> executeReactiveUpdate(QueryParameters queryParameters, ReactiveSession session) {
	errorIfSelect();

	// Multiple UPDATE SQL strings are not supported yet
	String sql = getSqlStatements()[0];

	Object[] parameterValues = toParameterArray(
			queryParameters,
			getCollectedParameterSpecifications( session ),
			session.getSharedContract()
	);
	return CompletionStages.completedFuture(0).thenCompose(
			count -> session.getReactiveConnection()
					.update( sql, parameterValues )
					.thenApply( updateCount -> count + updateCount )
	);
}
 

protected QueryParameters buildQueryParameters(
		Serializable id,
		Serializable[] ids,
		Object optionalObject,
		LockOptions lockOptions) {
	Type[] types = new Type[ids.length];
	Arrays.fill( types, persister().getIdentifierType() );

	QueryParameters qp = new QueryParameters();
	qp.setPositionalParameterTypes( types );
	qp.setPositionalParameterValues( ids );
	qp.setOptionalObject( optionalObject );
	qp.setOptionalEntityName( persister().getEntityName() );
	qp.setOptionalId( id );
	qp.setLockOptions( lockOptions );
	return qp;
}
 

public static Map<String, int[]> buildNamedParameterLocMap(
		QueryParameters queryParameters,
		NamedParameterContext namedParameterContext) {
	if ( queryParameters.getNamedParameters() == null || queryParameters.getNamedParameters().isEmpty() ) {
		return null;
	}

	final Map<String, int[]> namedParameterLocMap = new HashMap<>();
	for ( String name : queryParameters.getNamedParameters().keySet() ) {
		namedParameterLocMap.put(
				name,
				namedParameterContext.getNamedParameterLocations( name )
		);
	}
	return namedParameterLocMap;
}
 

@Override
public int executeNativeUpdate(
		NativeSQLQuerySpecification nativeSQLQuerySpecification,
		QueryParameters queryParameters) throws HibernateException {
	checkOpen();
	queryParameters.validateParameters();
	NativeSQLQueryPlan plan = getNativeQueryPlan( nativeSQLQuerySpecification );

	boolean success = false;
	int result = 0;
	try {
		result = plan.performExecuteUpdate( queryParameters, this );
		success = true;
	}
	finally {
		afterOperation( success );
	}
	temporaryPersistenceContext.clear();
	return result;
}
 

@Override
protected int bindParameterValues(
		PreparedStatement statement,
		QueryParameters queryParameters,
		int startIndex,
		SharedSessionContractImplementor session) throws SQLException {
	final Serializable optionalId = queryParameters.getOptionalId();
	if ( optionalId != null ) {
		paramValueBinders.get( 0 ).bind( statement, queryParameters, session, startIndex );
		return session.getFactory().getMetamodel()
				.entityPersister( queryParameters.getOptionalEntityName() )
				.getIdentifierType()
				.getColumnSpan( session.getFactory() );
	}

	int span = 0;
	for ( ParameterBinder paramValueBinder : paramValueBinders ) {
		span += paramValueBinder.bind(
				statement,
				queryParameters,
				session,
				startIndex + span
		);
	}
	return span;
}
 

private static EntityKey getOptionalObjectKey(QueryParameters queryParameters, SharedSessionContractImplementor session) {
	final Object optionalObject = queryParameters.getOptionalObject();
	final Serializable optionalId = queryParameters.getOptionalId();
	final String optionalEntityName = queryParameters.getOptionalEntityName();

	if ( optionalObject != null && optionalEntityName != null ) {
		return session.generateEntityKey(
				optionalId, session.getEntityPersister(
						optionalEntityName,
						optionalObject
				)
		);
	}
	else {
		return null;
	}

}
 

@Override
public int executeUpdate(String query, QueryParameters queryParameters) throws HibernateException {
	checkOpen();
	queryParameters.validateParameters();
	HQLQueryPlan plan = getQueryPlan( query, false );
	boolean success = false;
	int result = 0;
	try {
		result = plan.performExecuteUpdate( queryParameters, this );
		success = true;
	}
	finally {
		afterOperation( success );
	}
	temporaryPersistenceContext.clear();
	return result;
}
 

private ScrollMode getScrollMode(
		boolean scroll,
		boolean hasFirstRow,
		boolean useLimitOffSet,
		QueryParameters queryParameters) {
	final boolean canScroll = getFactory().getSessionFactoryOptions().isScrollableResultSetsEnabled();
	if ( canScroll ) {
		if ( scroll ) {
			return queryParameters.getScrollMode();
		}
		if ( hasFirstRow && !useLimitOffSet ) {
			return ScrollMode.SCROLL_INSENSITIVE;
		}
	}
	return null;
}
 

private static int bindNamedParameters(
		final PreparedStatement ps,
		final QueryParameters queryParameters,
		final int start,
		final NamedParameterSource source,
		final SessionImplementor session) throws SQLException, HibernateException {
	return bindNamedParameters( ps, queryParameters.getNamedParameters(), start, source, session );
}
 

@Override
public int bind(
		PreparedStatement statement,
		QueryParameters qp,
		SharedSessionContractImplementor session,
		int position) throws SQLException {
	final TypedValue typedValue = qp.getNamedParameters().get( name );
	typedValue.getType().nullSafeSet( statement, typedValue.getValue(), position, session );
	return typedValue.getType().getColumnSpan( session.getFactory() );
}
 

protected SqlStatementWrapper executeQueryStatement(
		String sqlStatement,
		QueryParameters queryParameters,
		boolean scroll,
		List<AfterLoadAction> afterLoadActions,
		SharedSessionContractImplementor session) throws SQLException {

	// Processing query filters.
	queryParameters.processFilters( sqlStatement, session );

	// Applying LIMIT clause.
	final LimitHandler limitHandler = getLimitHandler(
			queryParameters.getRowSelection()
	);
	String sql = limitHandler.processSql( queryParameters.getFilteredSQL(), queryParameters.getRowSelection() );

	// Adding locks and comments.
	sql = session.getJdbcServices().getJdbcEnvironment().getDialect()
			.addSqlHintOrComment(
				sql,
				queryParameters,
				session.getFactory().getSessionFactoryOptions().isCommentsEnabled()
			);

	final PreparedStatement st = prepareQueryStatement( sql, queryParameters, limitHandler, scroll, session );
	return new SqlStatementWrapper( st, getResultSet( st, queryParameters.getRowSelection(), limitHandler, queryParameters.hasAutoDiscoverScalarTypes(), session ) );
}
 

default CompletionStage<List<Object>> reactiveListIgnoreQueryCache(
		String sql, String queryIdentifier,
		SharedSessionContractImplementor session,
		QueryParameters queryParameters) {
	return doReactiveList( sql, queryIdentifier, (SessionImplementor) session, queryParameters, null )
			.thenApply( result -> getResultList( result, queryParameters.getResultTransformer() ) );
}
 

default QueryKey queryKey(String sql, SessionImplementor session, QueryParameters queryParameters) {
	return QueryKey.generateQueryKey(
			sql,
			queryParameters,
			FilterKey.createFilterKeys( session.getLoadQueryInfluencers().getEnabledFilters() ),
			session,
			cacheableResultTransformer( queryParameters )
	);
}
 

@Override
public List list(String query, QueryParameters queryParameters) throws HibernateException {
	checkOpenOrWaitingForAutoClose();
	checkTransactionSynchStatus();
	queryParameters.validateParameters();

	HQLQueryPlan plan = queryParameters.getQueryPlan();
	if ( plan == null ) {
		plan = getQueryPlan( query, false );
	}

	autoFlushIfRequired( plan.getQuerySpaces() );

	List results = Collections.EMPTY_LIST;
	boolean success = false;

	dontFlushFromFind++;   //stops flush being called multiple times if this method is recursively called
	try {
		results = plan.performList( queryParameters, this );
		success = true;
	}
	finally {
		dontFlushFromFind--;
		afterOperation( success );
		delayedAfterCompletion();
	}
	return results;
}
 

private static int bindPositionalParameters(
		final PreparedStatement st,
		final QueryParameters queryParameters,
		final int start,
		final SessionImplementor session) throws SQLException, HibernateException {
	return bindPositionalParameters(
			st,
			queryParameters.getPositionalParameterValues(),
			queryParameters.getPositionalParameterTypes(),
			start,
			session
	);
}
 

/**
 * Return the query results as an iterator
 */
@Override
public Iterator iterate(QueryParameters queryParameters, EventSource session)
		throws HibernateException {
	// Delegate to the QueryLoader...
	errorIfDML();
	return queryLoader.iterate( queryParameters, session );
}
 

protected SqlStatementWrapper executeQueryStatement(
		final QueryParameters queryParameters,
		final boolean scroll,
		List<AfterLoadAction> afterLoadActions,
		final SharedSessionContractImplementor session) throws SQLException {
	return executeQueryStatement( getStaticLoadQuery().getSqlStatement(), queryParameters, scroll, afterLoadActions, session );
}
 

public CustomLoaderExtension(
		CustomQuery customQuery,
		QueryParameters queryParameters,
		SharedSessionContractImplementor session) {
	super( customQuery, session.getFactory() );
	this.queryParameters = queryParameters;
	this.session = session;

	entityAliases = interpretEntityAliases( customQuery.getCustomQueryReturns() );
}
 

public static EntityKey getOptionalObjectKey(QueryParameters queryParameters, SharedSessionContractImplementor session) {
	final Object optionalObject = queryParameters.getOptionalObject();
	final Serializable optionalId = queryParameters.getOptionalId();
	final String optionalEntityName = queryParameters.getOptionalEntityName();

	return INSTANCE.interpretEntityKey( session, optionalEntityName, optionalId, optionalObject );
}
 

private List doList(
		final SharedSessionContractImplementor session,
		final QueryParameters queryParameters,
		final ResultTransformer forcedResultTransformer)
		throws HibernateException {

	final boolean stats = getFactory().getStatistics().isStatisticsEnabled();
	long startTime = 0;
	if ( stats ) {
		startTime = System.nanoTime();
	}

	List result;
	try {
		result = doQueryAndInitializeNonLazyCollections( session, queryParameters, true, forcedResultTransformer );
	}
	catch (SQLException sqle) {
		throw factory.getJdbcServices().getSqlExceptionHelper().convert(
				sqle,
				"could not execute query",
				getSQLString()
		);
	}

	if ( stats ) {
		final long endTime = System.nanoTime();
		final long milliseconds = TimeUnit.MILLISECONDS.convert( endTime - startTime, TimeUnit.NANOSECONDS );
		getFactory().getStatistics().queryExecuted(
				getQueryIdentifier(),
				result.size(),
				milliseconds
		);
	}

	return result;
}
 

@Override
public CompletionStage<Integer> executeReactiveUpdate(String query, QueryParameters parameters) {
	checkOpenOrWaitingForAutoClose();
	pulseTransactionCoordinator();
	parameters.validateParameters();

	ReactiveHQLQueryPlan reactivePlan = getQueryPlan( query, false );
	return reactiveAutoFlushIfRequired( reactivePlan.getQuerySpaces() )
			.thenAccept( v -> verifyImmutableEntityUpdate( reactivePlan ) )
			.thenCompose( v -> reactivePlan.performExecuteReactiveUpdate( parameters, this ) )
			.whenComplete( (count, x) -> {
				afterOperation( x == null );
				delayedAfterCompletion();
			} );
}
 

/**
 * @deprecated Use {@link #list(SharedSessionContractImplementor, QueryParameters)} instead.
 */
@Deprecated
@Override
public List<Object> list(SharedSessionContractImplementor session, QueryParameters queryParameters)
		throws HibernateException {
	throw new UnsupportedOperationException("Use #reactiveList instead");
}