mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

Jean-Noel Rouvignac
20.52.2013 3398f357636254d494b38ccf7553ccad0006da3a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 */
package org.opends.server.api;
 
 
 
import java.util.Collection;
 
import org.opends.server.types.ByteSequence;
 
 
 
/**
 * A factory for creating arbitrarily complex index queries. This
 * interface is implemented by the underlying backend implementation
 * and passed to extensible matching rules so that they can construct
 * arbitrarily complex index queries.
 *
 * @param <T>
 *          The type of query created by this factory.
 */
@org.opends.server.types.PublicAPI(
    stability = org.opends.server.types.StabilityLevel.VOLATILE,
    mayInstantiate = false,
    mayExtend = true,
    mayInvoke = false)
public interface IndexQueryFactory<T>
{
 
  /**
   * Returns a query requesting an index record matching the provided
   * key.
   *
   * @param indexID
   *          An identifier of the index type.
   * @param key
   *          A byte sequence containing the key.
   * @return A query requesting the index record matching the key.
   */
  T createExactMatchQuery(String indexID, ByteSequence key);
 
 
 
  /**
   * Returns a query requesting all index records. A backend
   * implementation may choose to return all or no records as part of
   * the optimization.
   *
   * @return A query requesting all index records.
   */
  T createMatchAllQuery();
 
 
 
  /**
   * Returns a query requesting all index records in the specified
   * range.
   *
   * @param indexID
   *          An identifier of the index type.
   * @param lower
   *          The lower bound of the range. A 0 length byte array
   *          indicates no lower bound and the range will start from
   *          the smallest key.
   * @param upper
   *          The upper bound of the range. A 0 length byte array
   *          indicates no upper bound and the range will end at the
   *          largest key.
   * @param lowerIncluded
   *          true if a key exactly matching the lower bound is
   *          included in the range, false if only keys strictly
   *          greater than the lower bound are included.This value
   *          is ignored if the lower bound is not specified.
   * @param upperIncluded
   *          true if a key exactly matching the upper bound is
   *          included in the range, false if only keys strictly
   *          less than the upper bound are included. This value is
   *          ignored if the upper bound is not specified.
   * @return A query requesting all index records in the specified
   *         range.
   */
  T createRangeMatchQuery(String indexID, ByteSequence lower,
      ByteSequence upper, boolean lowerIncluded,
      boolean upperIncluded);
 
 
 
  /**
   * Returns a query which returns the intersection of a collection of
   * sub-queries.
   *
   * @param subquery
   *          A collection of sub-queries.
   * @return A query which returns the intersection of a collection of
   *         sub-queries.
   */
  T createIntersectionQuery(Collection<T> subquery);
 
 
 
  /**
   * Returns a query which combines the results of a collection of
   * sub-queries.
   *
   * @param subquery
   *          A collection of sub-queries.
   * @return A query which combines the results of a collection of
   *         sub-queries.
   */
  T createUnionQuery(Collection<T> subquery);
}