org.hibernate.engine.spi.FilterDefinition Java Examples

/**
 * Add a Hibernate filter for multitenancy if the persistent class is multitenant
 *
 * @param entity target persistent entity for get tenant information
 * @param persistentClass persistent class for add the filter and get tenant property info
 * @param mappings mappings to add the filter
 * @param sessionFactoryBeanName the session factory bean name
 */
protected void addMultiTenantFilterIfNecessary(
        HibernatePersistentEntity entity, PersistentClass persistentClass,
        InFlightMetadataCollector mappings, String sessionFactoryBeanName) {
    if (entity.isMultiTenant()) {
        TenantId tenantId = entity.getTenantId();

        if (tenantId != null) {
            String filterCondition = getMultiTenantFilterCondition(sessionFactoryBeanName, entity);

            persistentClass.addFilter(
                    GormProperties.TENANT_IDENTITY,
                    filterCondition,
                    true,
                    Collections.emptyMap(),
                    Collections.emptyMap()
            );

            mappings.addFilterDefinition(new FilterDefinition(
                    GormProperties.TENANT_IDENTITY,
                    filterCondition,
                    Collections.singletonMap(GormProperties.TENANT_IDENTITY, persistentClass.getProperty(tenantId.getName()).getType())
            ));
        }
    }
}
 

public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
	FilterDefinition def = filters.get( filterName );
	if ( def == null ) {
		throw new HibernateException( "No such filter configured [" + filterName + "]" );
	}
	return def;
}
 

@Override
public void addFilterDefinition(FilterDefinition filterDefinition) {
	if ( filterDefinition == null || filterDefinition.getFilterName() == null ) {
		throw new IllegalArgumentException( "Filter definition object or name is null: "  + filterDefinition );
	}
	filterDefinitionMap.put( filterDefinition.getFilterName(), filterDefinition );
}
 

/**
 * Handling for a {@code <filter-def/>} declaration.
 *
 * @param context Access to information relative to the mapping document containing this binding
 * @param jaxbFilterDefinitionMapping The {@code <filter-def/>} JAXB mapping
 */
@SuppressWarnings("unchecked")
public static void processFilterDefinition(
		HbmLocalMetadataBuildingContext context,
		JaxbHbmFilterDefinitionType jaxbFilterDefinitionMapping) {
	Map<String,Type> parameterMap = null;
	String condition = jaxbFilterDefinitionMapping.getCondition();

	for ( Serializable content : jaxbFilterDefinitionMapping.getContent() ) {
		if ( String.class.isInstance( content ) ) {
			final String contentString = content.toString().trim();
			if ( StringHelper.isNotEmpty( contentString ) ) {
				if ( condition != null ) {
					log.debugf(
							"filter-def [name=%s, origin=%s] defined multiple conditions, accepting arbitrary one",
							jaxbFilterDefinitionMapping.getName(),
							context.getOrigin().toString()
					);
				}
			}
		}
		else {
			final JaxbHbmFilterParameterType jaxbParameterMapping;
			if ( JaxbHbmFilterParameterType.class.isInstance( content ) ) {
				jaxbParameterMapping = (JaxbHbmFilterParameterType) content;
			}
			else if ( JAXBElement.class.isInstance( content ) ) {
				final JAXBElement<JaxbHbmFilterParameterType> jaxbElement = (JAXBElement<JaxbHbmFilterParameterType>) content;
				jaxbParameterMapping = jaxbElement.getValue();
			}
			else {
				throw new MappingException(
						"Unable to decipher filter-def content type [" + content.getClass().getName() + "]",
						context.getOrigin()
				);
			}

			if ( parameterMap == null ) {
				parameterMap = new HashMap<String, Type>();
			}

			parameterMap.put(
					jaxbParameterMapping.getParameterName(),
					context.getMetadataCollector().getTypeResolver().heuristicType( jaxbParameterMapping.getParameterValueTypeName() )
			);
		}
	}

	context.getMetadataCollector().addFilterDefinition(
			new FilterDefinition(
					jaxbFilterDefinitionMapping.getName(),
					condition,
					parameterMap
			)
	);

	log.debugf( "Processed filter definition : %s", jaxbFilterDefinitionMapping.getName() );
}
 

public FilterDefinition getFilterDefinition(String filterName)
        throws HibernateException {
    return sessionFactoryImplementor.getFilterDefinition(filterName);
}
 

/** {@inheritDoc} */
@Override public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
    return null;
}
 

/** {@inheritDoc} */
@Override public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
    return null;
}
 

/** {@inheritDoc} */
@Override public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
    return null;
}
 

@Override
public FilterDefinition getFilterDefinition(String name) {
	return filterDefinitionMap.get( name );
}
 

@Override
public Map<String, FilterDefinition> getFilterDefinitions() {
	return filterDefinitionMap;
}
 

MetadataImpl(
		UUID uuid,
		MetadataBuildingOptions metadataBuildingOptions,
		MutableIdentifierGeneratorFactory identifierGeneratorFactory,
		Map<String, PersistentClass> entityBindingMap,
		Map<Class, MappedSuperclass> mappedSuperclassMap,
		Map<String, Collection> collectionBindingMap,
		Map<String, TypeDefinition> typeDefinitionMap,
		Map<String, FilterDefinition> filterDefinitionMap,
		Map<String, FetchProfile> fetchProfileMap,
		Map<String, String> imports,
		Map<String, IdentifierGeneratorDefinition> idGeneratorDefinitionMap,
		Map<String, NamedQueryDefinition> namedQueryMap,
		Map<String, NamedSQLQueryDefinition> namedNativeQueryMap,
		Map<String, NamedProcedureCallDefinition> namedProcedureCallMap,
		Map<String, ResultSetMappingDefinition> sqlResultSetMappingMap,
		Map<String, NamedEntityGraphDefinition> namedEntityGraphMap,
		Map<String, SQLFunction> sqlFunctionMap,
		java.util.Collection<DomainDataRegionConfigImpl.Builder> cacheRegionConfigBuilders,
		Database database,
		BootstrapContext bootstrapContext) {
	this.uuid = uuid;
	this.metadataBuildingOptions = metadataBuildingOptions;
	this.identifierGeneratorFactory = identifierGeneratorFactory;
	this.entityBindingMap = entityBindingMap;
	this.mappedSuperclassMap = mappedSuperclassMap;
	this.collectionBindingMap = collectionBindingMap;
	this.typeDefinitionMap = typeDefinitionMap;
	this.filterDefinitionMap = filterDefinitionMap;
	this.fetchProfileMap = fetchProfileMap;
	this.imports = imports;
	this.idGeneratorDefinitionMap = idGeneratorDefinitionMap;
	this.namedQueryMap = namedQueryMap;
	this.namedNativeQueryMap = namedNativeQueryMap;
	this.namedProcedureCallMap = namedProcedureCallMap;
	this.sqlResultSetMappingMap = sqlResultSetMappingMap;
	this.namedEntityGraphMap = namedEntityGraphMap;
	this.sqlFunctionMap = sqlFunctionMap;
	this.cacheRegionConfigBuilders = cacheRegionConfigBuilders;
	this.database = database;
	this.bootstrapContext = bootstrapContext;
}
 

@Override
public FilterDefinition getFilterDefinition(String name) {
	return filterDefinitionMap.get( name );
}
 

@Override
public Map<String, FilterDefinition> getFilterDefinitions() {
	return filterDefinitionMap;
}
 

@Override
public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
    return null;
}
 

@Override
public FilterDefinition getFilterDefinition(String name) {
	return delegate.getFilterDefinition( name );
}
 

@Override
public Map<String, FilterDefinition> getFilterDefinitions() {
	return delegate.getFilterDefinitions();
}
 

public FilterDefinition getFilterDefinition() {
	return definition;
}
 

private static void bindFilterDef(FilterDef defAnn, MetadataBuildingContext context) {
	Map<String, org.hibernate.type.Type> params = new HashMap<>();
	for ( ParamDef param : defAnn.parameters() ) {
		params.put( param.name(), context.getMetadataCollector().getTypeResolver().heuristicType( param.type() ) );
	}
	FilterDefinition def = new FilterDefinition( defAnn.name(), defAnn.defaultCondition(), params );
	LOG.debugf( "Binding filter definition: %s", def.getFilterName() );
	context.getMetadataCollector().addFilterDefinition( def );
}
 

@Override
public FilterDefinition getFilterDefinition(final String name) {
    return metadata.getFilterDefinition(name);
}
 

@Override
public Map<String, FilterDefinition> getFilterDefinitions() {
    return metadata.getFilterDefinitions();
}
 

/**
 * Adds a filter definition to this repository.
 *
 * @param definition The filter definition to add.
 *
 * @throws DuplicateMappingException If a FilterDefinition already exists with that name.
 */
void addFilterDefinition(FilterDefinition definition);
 

/**
 * Retrieves a filter definition by name.
 *
 * @param name The name of the filter definition to retrieve
 * .
 * @return The filter definition, or {@code null}.
 */
FilterDefinition getFilterDefinition(String name);
 

/**
 * Retrieves the complete map of filter definitions.
 *
 * Returned map is immutable
 *
 * @return The filter definition map.
 */
Map<String,FilterDefinition> getFilterDefinitions();
 

/**
 * Obtain the definition of a filter by name.
 *
 * @param filterName The name of the filter for which to obtain the definition.
 * @return The filter definition.
 * @throws HibernateException If no filter defined with the given name.
 */
FilterDefinition getFilterDefinition(String filterName) throws HibernateException;
 

/**
 * Constructs a new FilterImpl.
 *
 * @param configuration The filter's global configuration.
 */
public FilterImpl(FilterDefinition configuration) {
	this.definition = configuration;
	filterName = definition.getFilterName();
}
 

/**
 * Get the filter definition containing additional information about the
 * filter (such as default-condition and expected parameter names/types).
 *
 * @return The filter definition
 */
public FilterDefinition getFilterDefinition();