Package org.identityconnectors.framework.common.objects.filter

Class AbstractFilterTranslator<T>

    • Constructor Detail

      • AbstractFilterTranslator

        public AbstractFilterTranslator()

    • Method Detail

      • translate

        public final List<T> translate​(Filter filter)
        Main method to be called to translate a filter
        Specified by:
        translate in interface FilterTranslator<T>
        Parameters:
        filter - The filter to translate.
        Returns:
        The list of queries to be performed. The list size() may be one of the following:
        1. 0 - This signifies fetch everything. This may occur if your filter was null or one of your create* methods returned null.
        2. 1 - List contains a single query that will return the results from the filter. Note that the results may be a superset of those specified by the filter in the case that one of your create* methods returned null. That is OK from a behavior standpoint since ConnectorFacade performs a second level of filtering. However it is undesirable from a performance standpoint.
        3. >1 - List contains multiple queries that must be performed in order to meet the filter that was passed in. Note that this only occurs if your createOrExpression(T, T) method can return null. If this happens, it is the responsibility of the connector implementor to perform each query and combine the results. In order to eliminate duplicates, the connector implementation must keep an in-memory HashSet of those UID that have been visited thus far. This will not scale well if your result sets are large. Therefore it is recommended that if at all possible you implement createOrExpression(T, T)

      • createAndExpression

        protected T createAndExpression​(T leftExpression,
                                T rightExpression)
        Should be overridden by subclasses to create an AND expression if the native resource supports AND.
        Parameters:
        leftExpression - The left expression. Will never be null.
        rightExpression - The right expression. Will never be null.
        Returns:
        The AND expression. A return value of null means a native AND query cannot be created for the given expressions. In this case, the resulting query will consist of the leftExpression only.

      • createOrExpression

        protected T createOrExpression​(T leftExpression,
                               T rightExpression)
        Should be overridden by subclasses to create an OR expression if the native resource supports OR.
        Parameters:
        leftExpression - The left expression. Will never be null.
        rightExpression - The right expression. Will never be null.
        Returns:
        The OR expression. A return value of null means a native OR query cannot be created for the given expressions. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return multiple queries, each of which must be run and results combined.

      • createContainsExpression

        protected T createContainsExpression​(ContainsFilter filter,
                                     boolean not)
        Should be overridden by subclasses to create a CONTAINS expression if the native resource supports CONTAINS.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT CONTAINS
        Returns:
        The CONTAINS expression. A return value of null means a native CONTAINS query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createEndsWithExpression

        protected T createEndsWithExpression​(EndsWithFilter filter,
                                     boolean not)
        Should be overridden by subclasses to create a ENDS-WITH expression if the native resource supports ENDS-WITH.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT ENDS-WITH
        Returns:
        The ENDS-WITH expression. A return value of null means a native ENDS-WITH query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createEqualsExpression

        protected T createEqualsExpression​(EqualsFilter filter,
                                   boolean not)
        Should be overridden by subclasses to create a EQUALS expression if the native resource supports EQUALS.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT EQUALS
        Returns:
        The EQUALS expression. A return value of null means a native EQUALS query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createEqualsIgnoreCaseExpression

        protected T createEqualsIgnoreCaseExpression​(EqualsIgnoreCaseFilter filter,
                                             boolean not)
        Should be overridden by subclasses to create a EQUALSIGNORECASE expression if the native resource supports EQUALSIGNORECASE.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT EQUALSIGNORECASE
        Returns:
        The EQUALSIGNORECASE expression. A return value of null means a native EQUALSIGNORECASE query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createGreaterThanExpression

        protected T createGreaterThanExpression​(GreaterThanFilter filter,
                                        boolean not)
        Should be overridden by subclasses to create a GREATER-THAN expression if the native resource supports GREATER-THAN.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT GREATER-THAN
        Returns:
        The GREATER-THAN expression. A return value of null means a native GREATER-THAN query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createGreaterThanOrEqualExpression

        protected T createGreaterThanOrEqualExpression​(GreaterThanOrEqualFilter filter,
                                               boolean not)
        Should be overridden by subclasses to create a GREATER-THAN-EQUAL expression if the native resource supports GREATER-THAN-EQUAL.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT GREATER-THAN-EQUAL
        Returns:
        The GREATER-THAN-EQUAL expression. A return value of null means a native GREATER-THAN-EQUAL query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createLessThanExpression

        protected T createLessThanExpression​(LessThanFilter filter,
                                     boolean not)
        Should be overridden by subclasses to create a LESS-THAN expression if the native resource supports LESS-THAN.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT LESS-THAN
        Returns:
        The LESS-THAN expression. A return value of null means a native LESS-THAN query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createLessThanOrEqualExpression

        protected T createLessThanOrEqualExpression​(LessThanOrEqualFilter filter,
                                            boolean not)
        Should be overridden by subclasses to create a LESS-THAN-EQUAL expression if the native resource supports LESS-THAN-EQUAL.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT LESS-THAN-EQUAL
        Returns:
        The LESS-THAN-EQUAL expression. A return value of null means a native LESS-THAN-EQUAL query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createStartsWithExpression

        protected T createStartsWithExpression​(StartsWithFilter filter,
                                       boolean not)
        Should be overridden by subclasses to create a STARTS-WITH expression if the native resource supports STARTS-WITH.
        Parameters:
        filter - The contains filter. Will never be null.
        not - True if this should be a NOT STARTS-WITH
        Returns:
        The STARTS-WITH expression. A return value of null means a native STARTS-WITH query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.

      • createContainsAllValuesExpression

        protected T createContainsAllValuesExpression​(ContainsAllValuesFilter filter,
                                              boolean not)
        Should be overridden by subclasses to create a CONTAINS-ALL-VALUES expression if the native resource supports a contains all values.
        Parameters:
        filter - The contains all filter. Will never be null.
        not - True if this should be a NOT CONTAINS-ALL-VALUES.
        Returns:
        The CONTAINS-ALL-VALUES expression. A return value of null means a native CONTAINS-ALL-VALUES query cannot be created for the given filter. In this case, translate(org.identityconnectors.framework.common.objects.filter.Filter) may return an empty query set, meaning fetch everything. The filter will be re-applied in memory to the resulting object stream. This does not scale well, so if possible, you should implement this method.