Package com.evolveum.midpoint.repo.sqlbase.mapping

Class QueryModelMapping<S,​Q extends FlexibleRelationalPathBase<R>,​R>

  • Type Parameters:
    S - schema type
    Q - type of entity path
    R - row type related to the QueryModelMapping
    Direct Known Subclasses:
    QueryTableMapping
    public class QueryModelMapping<S,​Q extends FlexibleRelationalPathBase<R>,​R>
extends Object
    Common mapping functionality that covers the need for mapping from item paths to table columns, but also to nested embedded mappings (e.g. metadata). This also works as implementation for nested mappings like `metadata` that contain attributes resolved to the same query type - e.g. `metadata/createTimestamp`. While `metadata` is resolved on the master mapping (for the query type representing table) the nested `createTimestamp` is resolved by nested mapper implemented by this type. Nested mapping can still contain relations, so addRelationResolver(javax.xml.namespace.QName, com.evolveum.midpoint.repo.sqlbase.mapping.ItemRelationResolver<Q, R, ?, ?>) is available. Supertype QName type is used instead of ItemName for registration keys to support also technical paths like parent (..).

    • Field Detail

      • logger

        protected final org.slf4j.Logger logger

    • Constructor Detail

      • QueryModelMapping

        public QueryModelMapping​(@NotNull
                         @NotNull Class<S> schemaType,
                         @NotNull
                         @NotNull Class<Q> queryType)

    • Method Detail

      • schemaType

        public Class<S> schemaType()
        Returns schema type as class - refers to midPoint schema, not DB schema.

      • queryType

        public Class<Q> queryType()

      • addItemMapping

        public QueryModelMapping<S,​Q,​R> addItemMapping​(@NotNull
                                                           @NotNull QName itemName,
                                                           @NotNull
                                                           @NotNull ItemSqlMapper<Q,​R> itemMapper)
        Adds information how item (attribute) from schema type is mapped to query, especially for condition creating purposes. This is not usable for complex item path resolution, see addRelationResolver(QName, ItemRelationResolver) for that purpose. The ItemSqlMapper works as a factory for FilterProcessor that can process ObjectFilter related to the QName specified as the first parameter. It is not possible to use filter processor directly because at the time of mapping specification we don't have the actual query path representing the entity or the column. These paths are non-static properties of query class instances. The ItemSqlMapper also provides so called "primary mapping" to a column for ORDER BY part of the filter. But there can be additional column mappings specified as for some types (e.g. poly-strings) there may be other than 1-to-1 mapping. Construction of the ItemSqlMapper is typically simplified by static methods #mapper() provided on various *ItemFilterProcessor classes. This works as a "processor factory factory" and makes table mapping specification simpler.
        Parameters:
        itemName - item name from schema type (see F_* constants on schema types)
        itemMapper - mapper wrapping the information about column mappings working also as a factory for FilterProcessor

      • addRelationResolver

        public QueryModelMapping<S,​Q,​R> addRelationResolver​(@NotNull
                                                                @NotNull QName itemName,
                                                                @NotNull
                                                                @NotNull ItemRelationResolver<Q,​R,​?,​?> itemRelationResolver)
        Adds information how QName (attribute) from schema type is to be resolved when it appears as a component of a complex (non-single) ItemPath. This is in contrast with "item mapping" that is used for single (or last) component of the item path and helps with query interpretation.

      • relationResolver

        @NotNull
public final <TQ extends FlexibleRelationalPathBase<TR>,​TR> @NotNull ItemRelationResolver<Q,​R,​TQ,​TR> relationResolver​(ItemPath path)
                                                                                                                                       throws QueryException
        Returns ItemRelationResolver for the first component of the provided ItemPath or throws if the resolver is not found. Relation resolver helps with traversal over all-but-last components of item paths. ItemPath is used instead of QName to encapsulate corner cases like parent segment.
        Type Parameters:
        TQ - type of target entity path
        TR - row type related to the target entity path QueryModelMapping
        Throws:
        QueryException - if the resolver for the item is not found

      • getItemMappings

        @NotNull
public final @NotNull Map<QName,​ItemSqlMapper<Q,​R>> getItemMappings()
        Returns copy of the map of the item mappings.

      • itemDefinition

        public Object itemDefinition()