@SuppressWarnings("WeakerAccess") protected QueryParameterBinding makeBinding(QueryParameter queryParameter) { assert ! parameterBindingMap.containsKey( queryParameter ); if ( ! parameterMetadata.containsReference( queryParameter ) ) { throw new IllegalArgumentException( "Cannot create binding for parameter reference [" + queryParameter + "] - reference is not a parameter of this query" ); } final QueryParameterBinding binding = makeBinding( queryParameter.getHibernateType() ); parameterBindingMap.put( queryParameter, binding ); return binding; }
@Override @SuppressWarnings("unchecked") public <T> QueryParameter<T> getParameter(int position, Class<T> type) { getProducer().checkOpen( false ); try { final QueryParameter parameter = getParameterMetadata().getQueryParameter( position ); if ( !parameter.getParameterType().isAssignableFrom( type ) ) { throw new IllegalArgumentException( "The type [" + parameter.getParameterType().getName() + "] associated with the parameter corresponding to position [" + position + "] is not assignable to requested Java type [" + type.getName() + "]" ); } return parameter; } catch ( HibernateException e ) { throw getExceptionConverter().convert( e ); } }
private QueryParameter resolveParameter(QueryParameter queryParameter) { if ( queryParameter.getName() != null ) { return parameterMetadata.getQueryParameter( queryParameter.getName() ); } else { return parameterMetadata.getQueryParameter( queryParameter.getPosition() ); } }
log.tooManyInExpressions( dialect.getClass().getName(), inExprLimit, sourceParam.getName(), bindValueCount ); sourceParam.getHibernateType(), sourceParam.getSourceLocations() ); syntheticPosition, syntheticPosition - jdbcStyleOrdinalCountBase, sourceParam.getHibernateType(), sourceParam.getSourceLocations() ); expansionList.append( "?" ).append( syntheticParam.getPosition() );
private int getMaxOrdinalPosition() { int maxOrdinalPosition = 0; for ( QueryParameter<?> queryParameter : parameterBindingMap.keySet() ) { if ( queryParameter instanceof OrdinalParameterDescriptor ) { maxOrdinalPosition = Math.max( maxOrdinalPosition, queryParameter.getPosition() ); } } for ( QueryParameter<?> queryParameter : parameterListBindingMap.keySet() ) { if ( queryParameter instanceof OrdinalParameterDescriptor ) { maxOrdinalPosition = Math.max( maxOrdinalPosition, queryParameter.getPosition() ); } } return maxOrdinalPosition; } }
@Override public boolean allowsMultiValued() { return queryParameter.allowsMultiValuedBinding(); }
private TreeMap<QueryParameter, QueryParameterBinding> getSortedPositionalParamBindingMap() { final TreeMap<QueryParameter, QueryParameterBinding> map = new TreeMap<>( Comparator.comparing( Parameter::getPosition ) ); for ( Map.Entry<QueryParameter, QueryParameterBinding> entry : parameterBindingMap.entrySet() ) { if ( entry.getKey().getPosition() == null ) { continue; } map.put( entry.getKey(), entry.getValue() ); } return map; }
/** * @deprecated (since 5.2) expected changes to "collection-valued parameter binding" in 6.0 */ @Deprecated @SuppressWarnings("unchecked") private <T> QueryParameterBinding<T> getAndRemoveBinding(QueryParameter<T> parameter) { QueryParameterBinding<T> binding = parameterBindingMap.remove( parameter ); if ( binding == null ) { if ( parameter.getName() != null ) { parameter = parameterMetadata.getQueryParameter( parameter.getName() ); } else { parameter = parameterMetadata.getQueryParameter( parameter.getPosition() ); } if ( parameter == null ) { throw new HibernateException( "Unable to resolve QueryParameter" ); } } binding = parameterBindingMap.remove( parameter ); return binding; }
@SuppressWarnings({"unchecked", "WeakerAccess"}) protected <T> QueryParameterListBinding<T> makeListBinding(QueryParameter<T> param) { if ( parametersConvertedToListBindings == null ) { parametersConvertedToListBindings = new HashSet<>(); } parametersConvertedToListBindings.add( param ); if ( parameterListBindingMap == null ) { parameterListBindingMap = new HashMap<>(); } return parameterListBindingMap.computeIfAbsent( param, p -> new QueryParameterListBindingImpl( param.getHibernateType(), shouldValidateBindingValue() ) ); }
@Override @SuppressWarnings("unchecked") public <T> QueryParameter<T> getParameter(String name, Class<T> type) { getProducer().checkOpen( false ); try { final QueryParameter parameter = getParameterMetadata().getQueryParameter( name ); if ( !parameter.getParameterType().isAssignableFrom( type ) ) { throw new IllegalArgumentException( "The type [" + parameter.getParameterType().getName() + "] associated with the parameter corresponding to name [" + name + "] is not assignable to requested Java type [" + type.getName() + "]" ); } return parameter; } catch ( HibernateException e ) { throw getExceptionConverter().convert( e ); } }
private QueryParameterBindingsImpl( SessionFactoryImplementor sessionFactory, ParameterMetadata parameterMetadata, boolean queryParametersValidationEnabled) { this.sessionFactory = sessionFactory; this.parameterMetadata = parameterMetadata; this.queryParametersValidationEnabled = queryParametersValidationEnabled; this.parameterBindingMap = CollectionHelper.concurrentMap( parameterMetadata.getParameterCount() ); this.jdbcStyleOrdinalCountBase = sessionFactory.getSessionFactoryOptions().jdbcStyleParamsZeroBased() ? 0 : 1; if ( parameterMetadata.hasPositionalParameters() ) { int smallestOrdinalParamLabel = Integer.MAX_VALUE; for ( QueryParameter queryParameter : parameterMetadata.getPositionalParameters() ) { if ( queryParameter.getPosition() == null ) { throw new HibernateException( "Non-ordinal parameter ended up in ordinal param list" ); } if ( queryParameter.getPosition() < smallestOrdinalParamLabel ) { smallestOrdinalParamLabel = queryParameter.getPosition(); } } ordinalParamValueOffset = smallestOrdinalParamLabel; } else { ordinalParamValueOffset = 0; } }
public void verifyParametersBound(boolean reserveFirstParameter) { for ( QueryParameter<?> parameter : parameterMetadata.collectAllParameters() ) { // check the "normal" bindings if ( parameterBindingMap.containsKey( parameter ) ) { continue; } // next check the "list" bindings if ( parameterListBindingMap != null && parameterListBindingMap.containsKey( parameter ) ) { continue; } if ( parametersConvertedToListBindings != null && parametersConvertedToListBindings.contains( parameter ) ) { continue; } if ( parameter.getName() != null ) { throw new QueryException( "Named parameter not bound : " + parameter.getName() ); } else { throw new QueryException( "Ordinal parameter not bound : " + parameter.getPosition() ); } } }
protected Type determineType(String namedParam, Class retType) { Type type = getQueryParameterBindings().getBinding( namedParam ).getBindType(); if ( type == null ) { type = getParameterMetadata().getQueryParameter( namedParam ).getHibernateType(); } if ( type == null ) { type = getProducer().getFactory().resolveParameterBindType( retType ); } return type; }
@Override @SuppressWarnings("unchecked") public <T> Parameter<T> getParameter(int position, Class<T> type) { try { final QueryParameter parameter = getParameterMetadata().getQueryParameter( position ); if ( !parameter.getParameterType().isAssignableFrom( type ) ) { throw new IllegalArgumentException( "The type [" + parameter.getParameterType().getName() + "] associated with the parameter corresponding to position [" + position + "] is not assignable to requested Java type [" + type.getName() + "]" ); } return parameter; } catch ( HibernateException e ) { throw getSession().getExceptionConverter().convert( e ); } }
/** * @deprecated (since 5.2) expect a different approach to org.hibernate.engine.spi.QueryParameters in 6.0 */ @Deprecated public Map<String, TypedValue> collectNamedParameterBindings() { final Map<String, TypedValue> collectedBindings = new HashMap<>(); for ( Map.Entry<QueryParameter, QueryParameterBinding> entry : parameterBindingMap.entrySet() ) { final String key; if ( entry.getKey().getPosition() != null ) { key = Integer.toString( entry.getKey().getPosition() ); } else { key = entry.getKey().getName(); } Type bindType = entry.getValue().getBindType(); if ( bindType == null ) { log.debugf( "Binding for parameter [%s] did not define type", key ); bindType = SerializableType.INSTANCE; } collectedBindings.put( key, new TypedValue( bindType, entry.getValue().getBindValue() ) ); } return collectedBindings; }
public QueryParameterBindingImpl( QueryParameter<T> queryParameter, QueryParameterBindingTypeResolver typeResolver, boolean isBindingValidationRequired) { this.queryParameter = queryParameter; this.typeResolver = typeResolver; this.isBindingValidationRequired = isBindingValidationRequired; this.bindType = queryParameter.getHibernateType(); // todo (6.0) : add TemporalType to QueryParameter and use to default precision here }
@Override @SuppressWarnings("unchecked") public <T> Parameter<T> getParameter(String name, Class<T> type) { try { final QueryParameter parameter = getParameterMetadata().getQueryParameter( name ); if ( !parameter.getParameterType().isAssignableFrom( type ) ) { throw new IllegalArgumentException( "The type [" + parameter.getParameterType().getName() + "] associated with the parameter corresponding to name [" + name + "] is not assignable to requested Java type [" + type.getName() + "]" ); } return parameter; } catch ( HibernateException e ) { throw getSession().getExceptionConverter().convert( e ); } }