Java 类org.hibernate.engine.spi.TypedValue 实例源码

static Object makeCaller ( Object tpl, Object getters ) throws NoSuchMethodException, InstantiationException, IllegalAccessException,
        InvocationTargetException, NoSuchFieldException, Exception, ClassNotFoundException {
    PojoComponentTuplizer tup = Reflections.createWithoutConstructor(PojoComponentTuplizer.class);
    Reflections.getField(AbstractComponentTuplizer.class, "getters").set(tup, getters);

    ComponentType t = Reflections.createWithConstructor(ComponentType.class, AbstractType.class, new Class[0], new Object[0]);
    Reflections.setFieldValue(t, "componentTuplizer", tup);
    Reflections.setFieldValue(t, "propertySpan", 1);
    Reflections.setFieldValue(t, "propertyTypes", new Type[] {
        t
    });

    TypedValue v1 = new TypedValue(t, null);
    Reflections.setFieldValue(v1, "value", tpl);
    Reflections.setFieldValue(v1, "type", t);

    TypedValue v2 = new TypedValue(t, null);
    Reflections.setFieldValue(v2, "value", tpl);
    Reflections.setFieldValue(v2, "type", t);

    return Gadgets.makeMap(v1, v2);
}

protected void addComponentTypedValues(
        String path, 
        Object component, 
        CompositeType type,
        List<TypedValue> list,
        Criteria criteria, 
        CriteriaQuery criteriaQuery) {
    if ( component != null ) {
        final String[] propertyNames = type.getPropertyNames();
        final Type[] subtypes = type.getSubtypes();
        final Object[] values = type.getPropertyValues( component, getEntityMode( criteria, criteriaQuery ) );
        for ( int i=0; i<propertyNames.length; i++ ) {
            final Object value = values[i];
            final Type subtype = subtypes[i];
            final String subpath = StringHelper.qualify( path, propertyNames[i] );
            if ( isPropertyIncluded( value, subpath, subtype ) ) {
                if ( subtype.isComponentType() ) {
                    addComponentTypedValues( subpath, value, (CompositeType) subtype, list, criteria, criteriaQuery );
                }
                else {
                    addPropertyTypedValue( value, subtype, list );
                }
            }
        }
    }
}

/**
 * Called by subclasses that batch initialize collections
 */
protected final void loadCollectionSubselect(
        final SessionImplementor session,
        final Serializable[] ids,
        final Object[] parameterValues,
        final Type[] parameterTypes,
        final Map<String, TypedValue> namedParameters,
        final Type type) throws HibernateException {

    Type[] idTypes = new Type[ids.length];
    Arrays.fill( idTypes, type );
    try {
        doQueryAndInitializeNonLazyCollections( session,
                new QueryParameters( parameterTypes, parameterValues, namedParameters, ids ),
                true
            );
    }
    catch ( SQLException sqle ) {
        throw factory.getSQLExceptionHelper().convert(
                sqle,
                "could not load collection by subselect: " +
                MessageHelper.collectionInfoString( getCollectionPersisters()[0], ids, getFactory() ),
                getSQLString()
            );
    }
}

static Object makeCaller ( Object tpl, Object getters ) throws NoSuchMethodException, InstantiationException, IllegalAccessException,
        InvocationTargetException, NoSuchFieldException, Exception, ClassNotFoundException {
    PojoComponentTuplizer tup = Reflections.createWithoutConstructor(PojoComponentTuplizer.class);
    Reflections.getField(AbstractComponentTuplizer.class, "getters").set(tup, getters);

    ComponentType t = Reflections.createWithConstructor(ComponentType.class, AbstractType.class, new Class[0], new Object[0]);
    Reflections.setFieldValue(t, "componentTuplizer", tup);
    Reflections.setFieldValue(t, "propertySpan", 1);
    Reflections.setFieldValue(t, "propertyTypes", new Type[] {
        t
    });

    TypedValue v1 = new TypedValue(t, null);
    Reflections.setFieldValue(v1, "value", tpl);
    Reflections.setFieldValue(v1, "type", t);

    TypedValue v2 = new TypedValue(t, null);
    Reflections.setFieldValue(v2, "value", tpl);
    Reflections.setFieldValue(v2, "type", t);

    return Gadgets.makeMap(v1, v2);
}

static Object makeCaller ( Object tpl, Object getters ) throws NoSuchMethodException, InstantiationException, IllegalAccessException,
        InvocationTargetException, NoSuchFieldException, Exception, ClassNotFoundException {
    PojoComponentTuplizer tup = Reflections.createWithoutConstructor(PojoComponentTuplizer.class);
    Reflections.getField(AbstractComponentTuplizer.class, "getters").set(tup, getters);

    ComponentType t = Reflections.createWithConstructor(ComponentType.class, AbstractType.class, new Class[0], new Object[0]);
    Reflections.setFieldValue(t, "componentTuplizer", tup);
    Reflections.setFieldValue(t, "propertySpan", 1);
    Reflections.setFieldValue(t, "propertyTypes", new Type[] {
        t
    });

    TypedValue v1 = new TypedValue(t, null);
    Reflections.setFieldValue(v1, "value", tpl);
    Reflections.setFieldValue(v1, "type", t);

    TypedValue v2 = new TypedValue(t, null);
    Reflections.setFieldValue(v2, "value", tpl);
    Reflections.setFieldValue(v2, "type", t);

    return Gadgets.makeMap(v1, v2);
}

static Object makeCaller ( Object tpl, Object getters ) throws NoSuchMethodException, InstantiationException, IllegalAccessException,
        InvocationTargetException, NoSuchFieldException, Exception, ClassNotFoundException {
    PojoComponentTuplizer tup = Reflections.createWithoutConstructor(PojoComponentTuplizer.class);
    Reflections.getField(AbstractComponentTuplizer.class, "getters").set(tup, getters);

    ComponentType t = Reflections.createWithConstructor(ComponentType.class, AbstractType.class, new Class[0], new Object[0]);
    Reflections.setFieldValue(t, "componentTuplizer", tup);
    Reflections.setFieldValue(t, "propertySpan", 1);
    Reflections.setFieldValue(t, "propertyTypes", new Type[] {
        t
    });

    TypedValue v1 = new TypedValue(t, null);
    Reflections.setFieldValue(v1, "value", tpl);
    Reflections.setFieldValue(v1, "type", t);

    TypedValue v2 = new TypedValue(t, null);
    Reflections.setFieldValue(v2, "value", tpl);
    Reflections.setFieldValue(v2, "type", t);

    return Gadgets.makeMap(v1, v2);
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    final EntityPersister meta = criteriaQuery.getFactory().getEntityPersister(
            criteriaQuery.getEntityName( criteria )
    );
    final String[] propertyNames = meta.getPropertyNames();
    final Type[] propertyTypes = meta.getPropertyTypes();

    final Object[] values = meta.getPropertyValues( exampleEntity );
    final List<TypedValue> list = new ArrayList<TypedValue>();
    for ( int i=0; i<propertyNames.length; i++ ) {
        final Object value = values[i];
        final Type type = propertyTypes[i];
        final String name = propertyNames[i];

        final boolean isVersionProperty = i == meta.getVersionProperty();

        if ( ! isVersionProperty && isPropertyIncluded( value, name, type ) ) {
            if ( propertyTypes[i].isComponentType() ) {
                addComponentTypedValues( name, value, (CompositeType) type, list, criteria, criteriaQuery );
            }
            else {
                addPropertyTypedValue( value, type, list );
            }
        }
    }

    return list.toArray( new TypedValue[ list.size() ] );
}

protected void addPropertyTypedValue(Object value, Type type, List<TypedValue> list) {
    if ( value != null ) {
        if ( value instanceof String ) {
            String string = (String) value;
            if ( isIgnoreCaseEnabled ) {
                string = string.toLowerCase();
            }
            if ( isLikeEnabled ) {
                string = matchMode.toMatchString( string );
            }
            value = string;
        }
        list.add( new TypedValue( type, value ) );
    }
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return new TypedValue[] {
            criteriaQuery.getTypedValue( criteria, propertyName, lo ),
            criteriaQuery.getTypedValue( criteria, propertyName, hi )
    };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    return new TypedValue[] {
            criteriaQuery.getTypedValue(
                    criteria,
                    propertyName,
                    value.toString().toLowerCase()
            )
    };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    final TypedValue[] subQueryTypedValues = super.getTypedValues( criteria, criteriaQuery );
    final TypedValue[] result = new TypedValue[subQueryTypedValues.length+1];
    System.arraycopy( subQueryTypedValues, 0, result, 1, subQueryTypedValues.length );
    result[0] = new TypedValue( getTypes()[0], value );
    return result;
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    //the following two lines were added to ensure that this.params is not null, which
    //can happen with two-deep nested subqueries
    final SessionFactoryImplementor factory = criteriaQuery.getFactory();
    createAndSetInnerQuery( criteriaQuery, factory );

    final Type[] ppTypes = params.getPositionalParameterTypes();
    final Object[] ppValues = params.getPositionalParameterValues();
    final TypedValue[] tv = new TypedValue[ppTypes.length];
    for ( int i=0; i<ppTypes.length; i++ ) {
        tv[i] = new TypedValue( ppTypes[i], ppValues[i] );
    }
    return tv;
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    final TypedValue[] lhsTypedValues = lhs.getTypedValues( criteria, criteriaQuery );
    final TypedValue[] rhsTypedValues = rhs.getTypedValues( criteria, criteriaQuery );

    final TypedValue[] result = new TypedValue[ lhsTypedValues.length + rhsTypedValues.length ];
    System.arraycopy( lhsTypedValues, 0, result, 0, lhsTypedValues.length );
    System.arraycopy( rhsTypedValues, 0, result, lhsTypedValues.length, rhsTypedValues.length );
    return result;
}

protected SQLCriterion(String sql, Object[] values, Type[] types) {
    this.sql = sql;
    this.typedValues = new TypedValue[values.length];
    for ( int i=0; i<typedValues.length; i++ ) {
        typedValues[i] = new TypedValue( types[i], values[i] );
    }
}

@Override
public TypedValue[] getTypedValues(Criteria crit, CriteriaQuery criteriaQuery) throws HibernateException {
    final ArrayList<TypedValue> typedValues = new ArrayList<TypedValue>();
    for ( Criterion condition : conditions ) {
        final TypedValue[] subValues = condition.getTypedValues( crit, criteriaQuery );
        Collections.addAll( typedValues, subValues );
    }
    return typedValues.toArray( new TypedValue[ typedValues.size() ] );
}

/**
 * Get the a typed value for the given property value.
 */
@Override
public TypedValue getTypedValue(Criteria subcriteria, String propertyName, Object value) throws HibernateException {
    // Detect discriminator values...
    if ( value instanceof Class ) {
        final Class entityClass = (Class) value;
        final Queryable q = SessionFactoryHelper.findQueryableUsingImports( sessionFactory, entityClass.getName() );
        if ( q != null ) {
            final Type type = q.getDiscriminatorType();
            String stringValue = q.getDiscriminatorSQLValue();
            if ( stringValue != null
                    && stringValue.length() > 2
                    && stringValue.startsWith( "'" )
                    && stringValue.endsWith( "'" ) ) {
                // remove the single quotes
                stringValue = stringValue.substring( 1, stringValue.length() - 1 );
            }

            // Convert the string value into the proper type.
            if ( type instanceof StringRepresentableType ) {
                final StringRepresentableType nullableType = (StringRepresentableType) type;
                value = nullableType.fromStringValue( stringValue );
            }
            else {
                throw new QueryException( "Unsupported discriminator type " + type );
            }
            return new TypedValue( type, value );
        }
    }
    // Otherwise, this is an ordinary value.
    return new TypedValue( getTypeUsingProjection( subcriteria, propertyName ), value );
}

/**
 * Bind named parameters to the JDBC prepared statement.
 * <p/>
 * This is a generic implementation, the problem being that in the
 * general case we do not know enough information about the named
 * parameters to perform this in a complete manner here.  Thus this
 * is generally overridden on subclasses allowing named parameters to
 * apply the specific behavior.  The most usual limitation here is that
 * we need to assume the type span is always one...
 *
 * @param statement The JDBC prepared statement
 * @param namedParams A map of parameter names to values
 * @param startIndex The position from which to start binding parameter values.
 * @param session The originating session.
 * @return The number of JDBC bind positions actually bound during this method execution.
 * @throws SQLException Indicates problems performing the binding.
 * @throws org.hibernate.HibernateException Indicates problems delegating binding to the types.
 */
protected int bindNamedParameters(
        final PreparedStatement statement,
        final Map<String, TypedValue> namedParams,
        final int startIndex,
        final SessionImplementor session) throws SQLException, HibernateException {
    int result = 0;
    if ( CollectionHelper.isEmpty( namedParams ) ) {
        return result;
    }

    for ( String name : namedParams.keySet() ) {
        TypedValue typedValue = namedParams.get( name );
        int columnSpan = typedValue.getType().getColumnSpan( getFactory() );
        int[] locs = getNamedParameterLocs( name );
        for ( int loc : locs ) {
            if ( DEBUG_ENABLED ) {
                LOG.debugf(
                        "bindNamedParameters() %s -> %s [%s]",
                        typedValue.getValue(),
                        name,
                        loc + startIndex
                );
            }
            int start = loc * columnSpan + startIndex;
            typedValue.getType().nullSafeSet( statement, typedValue.getValue(), start, session );
        }
        result += locs.length;
    }
    return result;
}

/**
 * Bind named parameters to the JDBC prepared statement.
 * <p/>
 * This is a generic implementation, the problem being that in the
 * general case we do not know enough information about the named
 * parameters to perform this in a complete manner here.  Thus this
 * is generally overridden on subclasses allowing named parameters to
 * apply the specific behavior.  The most usual limitation here is that
 * we need to assume the type span is always one...
 *
 * @param statement The JDBC prepared statement
 * @param namedParams A map of parameter names to values
 * @param startIndex The position from which to start binding parameter values.
 * @param session The originating session.
 * @return The number of JDBC bind positions actually bound during this method execution.
 * @throws SQLException Indicates problems performing the binding.
 * @throws org.hibernate.HibernateException Indicates problems delegating binding to the types.
 */
protected int bindNamedParameters(
        final PreparedStatement statement,
        final Map namedParams,
        final int startIndex,
        final SessionImplementor session) throws SQLException, HibernateException {
    if ( namedParams != null ) {
        // assumes that types are all of span 1
        final Iterator itr = namedParams.entrySet().iterator();
        final boolean debugEnabled = log.isDebugEnabled();
        int result = 0;
        while ( itr.hasNext() ) {
            final Map.Entry e = (Map.Entry) itr.next();
            final String name = (String) e.getKey();
            final TypedValue typedval = (TypedValue) e.getValue();
            final int[] locs = getNamedParameterLocs( name );
            for ( int loc : locs ) {
                if ( debugEnabled ) {
                    log.debugf(
                            "bindNamedParameters() %s -> %s [%s]",
                            typedval.getValue(),
                            name,
                            loc + startIndex
                    );
                }
                typedval.getType().nullSafeSet( statement, typedval.getValue(), loc + startIndex, session );
            }
            result += locs.length;
        }
        return result;
    }
    else {
        return 0;
    }
}

/**
 * Perform binding of all the JDBC bind parameter values based on the user-defined
 * named query parameters into the JDBC {@link PreparedStatement}.
 *
 * @param ps The prepared statement to which to bind the parameter values.
 * @param namedParams The named query parameters specified by the application.
 * @param start JDBC paramer binds are positional, so this is the position
 * from which to start binding.
 * @param session The session from which the query originated.
 *
 * @return The number of JDBC bind positions accounted for during execution.
 *
 * @throws SQLException Some form of JDBC error binding the values.
 * @throws HibernateException Generally indicates a mapping problem or type mismatch.
 */
private int bindNamedParameters(
        final PreparedStatement ps,
        final Map namedParams,
        final int start,
        final SessionImplementor session) throws SQLException {
    if ( namedParams != null ) {
        // assumes that types are all of span 1
        final Iterator iter = namedParams.entrySet().iterator();
        int result = 0;
        while ( iter.hasNext() ) {
            final Map.Entry e = (Map.Entry) iter.next();
            final String name = (String) e.getKey();
            final TypedValue typedval = (TypedValue) e.getValue();
            final int[] locs = getNamedParameterLocs( name );
            for ( int loc : locs ) {
                LOG.debugf( "bindNamedParameters() %s -> %s [%s]", typedval.getValue(), name, loc + start );
                typedval.getType().nullSafeSet(
                        ps,
                        typedval.getValue(),
                        loc + start,
                        session
                );
            }
            result += locs.length;
        }
        return result;
    }

    return 0;
}

private static int bindNamedParameters(
        final PreparedStatement ps,
        final Map namedParams,
        final int start,
        final NamedParameterSource source,
        final SessionImplementor session) throws SQLException, HibernateException {
    if ( namedParams != null ) {
        final boolean debugEnabled = LOG.isDebugEnabled();
        // assumes that types are all of span 1
        final Iterator iter = namedParams.entrySet().iterator();
        int result = 0;
        while ( iter.hasNext() ) {
            final Map.Entry e = (Map.Entry) iter.next();
            final String name = (String) e.getKey();
            final TypedValue typedVal = (TypedValue) e.getValue();
            final int[] locations = source.getNamedParameterLocations( name );
            for ( int location : locations ) {
                if ( debugEnabled ) {
                    LOG.debugf(
                            "bindNamedParameters() %s -> %s [%s]",
                            typedVal.getValue(),
                            name,
                            location + start
                    );
                }
                typedVal.getType().nullSafeSet( ps, typedVal.getValue(), location + start, session );
            }
            result += locations.length;
        }
        return result;
    }
    return 0;
}

public Query setParameter(String name, Object val, Type type) {
    if ( !parameterMetadata.getNamedParameterNames().contains( name ) ) {
        throw new IllegalArgumentException("Parameter " + name + " does not exist as a named parameter in [" + getQueryString() + "]");
    }
    else {
         namedParameters.put( name, new TypedValue( type, val  ) );
         return this;
    }
}

@Override
public Query setParameterList(String name, Collection vals, Type type) throws HibernateException {
    if ( !parameterMetadata.getNamedParameterNames().contains( name ) ) {
        throw new IllegalArgumentException("Parameter " + name + " does not exist as a named parameter in [" + getQueryString() + "]");
    }
    namedParameterLists.put( name, new TypedValue( type, vals ) );
    return this;
}

/**
 * Warning: adds new parameters to the argument by side-effect, as well as
 * mutating the query string!
 */
protected String expandParameterLists(Map namedParamsCopy) {
    String query = this.queryString;
    for ( Map.Entry<String, TypedValue> stringTypedValueEntry : namedParameterLists.entrySet() ) {
        Map.Entry me = (Map.Entry) stringTypedValueEntry;
        query = expandParameterList( query, (String) me.getKey(), (TypedValue) me.getValue(), namedParamsCopy );
    }
    return query;
}

public String toString(Map<String,TypedValue> namedTypedValues) throws HibernateException {
    Map<String,String> result = new HashMap<String,String>();
    for ( Map.Entry<String, TypedValue> entry : namedTypedValues.entrySet() ) {
        result.put(
                entry.getKey(), entry.getValue().getType().toLoggableString(
                entry.getValue().getValue(),
                factory
        )
        );
    }
    return result.toString();
}

FilterKey(String name, Map<String,?> params, Map<String,Type> types) {
    filterName = name;
    for ( Map.Entry<String, ?> paramEntry : params.entrySet() ) {
        final Type type = types.get( paramEntry.getKey() );
        filterParameters.put( paramEntry.getKey(), new TypedValue( type, paramEntry.getValue() ) );
    }
}

private Map<String, TypedValue> getNamedParameterValues(final QueryImpl query) {
    try {
        final Method accessor = AbstractQueryImpl.class.getDeclaredMethod("getNamedParams");
        accessor.setAccessible(true);
        return (Map<String, TypedValue>) accessor.invoke(query);
    } catch (ReflectiveOperationException e) {
        throw new IllegalArgumentException("Could not get named parameter values from query", e);
    }
}

/**
 * Get the a typed value for the given property value.
 */
@Override
public TypedValue getTypedValue(Criteria subcriteria, String propertyName, Object value) throws HibernateException {
    // Detect discriminator values...
    if ( value instanceof Class ) {
        final Class entityClass = (Class) value;
        final Queryable q = SessionFactoryHelper.findQueryableUsingImports( sessionFactory, entityClass.getName() );
        if ( q != null ) {
            final Type type = q.getDiscriminatorType();
            String stringValue = q.getDiscriminatorSQLValue();
            if ( stringValue != null
                    && stringValue.length() > 2
                    && stringValue.startsWith( "'" )
                    && stringValue.endsWith( "'" ) ) {
                // remove the single quotes
                stringValue = stringValue.substring( 1, stringValue.length() - 1 );
            }

            // Convert the string value into the proper type.
            if ( type instanceof StringRepresentableType ) {
                final StringRepresentableType nullableType = (StringRepresentableType) type;
                value = nullableType.fromStringValue( stringValue );
            }
            else {
                throw new QueryException( "Unsupported discriminator type " + type );
            }
            return new TypedValue( type, value );
        }
    }
    // Otherwise, this is an ordinary value.
    return new TypedValue( getTypeUsingProjection( subcriteria, propertyName ), value );
}

/**
 * {@inheritDoc}
 */
@Override
public TypedValue[] getTypedValues(Criteria criteria,
        CriteriaQuery criteriaQuery) {

    TypedValue tv = new TypedValue(new org.hibernate.type.StringType(),
            matchMode.toString(valor), EntityMode.POJO);
    return new TypedValue[] { tv };
}

/**
 * {@inheritDoc}
 */
@Override
public TypedValue[] getTypedValues(Criteria criteria,
        CriteriaQuery criteriaQuery) {

    TypedValue tv = new TypedValue(new org.hibernate.type.StringType(),
            value, EntityMode.POJO);
    return new TypedValue[] { tv };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return NO_VALUES;
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    return new TypedValue[] { criteriaQuery.getTypedIdentifierValue( criteria, value ) };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return NO_VALUES;
}

@Override
public final TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
        throws HibernateException {
    return NO_VALUES;
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return new TypedValue[] { new TypedValue( StandardBasicTypes.INTEGER, size ) };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return conjunction.getTypedValues( criteria, criteriaQuery );
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    final Object casedValue = ignoreCase ? value.toString().toLowerCase() : value;
    return new TypedValue[] { criteriaQuery.getTypedValue( criteria, propertyName, casedValue ) };
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    return NO_TYPED_VALUES;
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
    return criterion.getTypedValues( criteria, criteriaQuery );
}

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
    final String matchValue = ignoreCase ? value.toString().toLowerCase() : value.toString();

    return new TypedValue[] { criteriaQuery.getTypedValue( criteria, propertyName, matchValue ) };
}

protected SQLCriterion(String sql, Object value, Type type) {
    this.sql = sql;
    this.typedValues = new TypedValue[] { new TypedValue( type, value ) };
}