-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
IndexReader.java
130 lines (116 loc) · 5.15 KB
/
IndexReader.java
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
/*
* Copyright (c) 2002-2019 "Neo4j,"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.storageengine.api.schema;
import org.neo4j.collection.PrimitiveLongResourceCollections;
import org.neo4j.collection.PrimitiveLongResourceIterator;
import org.neo4j.graphdb.Resource;
import org.neo4j.internal.kernel.api.IndexOrder;
import org.neo4j.internal.kernel.api.IndexQuery;
import org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException;
import org.neo4j.storageengine.api.NodePropertyAccessor;
import org.neo4j.values.storable.Value;
/**
* Reader for an index. Must honor repeatable reads, which means that if a lookup is executed multiple times the
* same result set must be returned.
*/
public interface IndexReader extends Resource
{
/**
* @param nodeId node id to match.
* @param propertyKeyIds the property key ids that correspond to each of the property values.
* @param propertyValues property values to match.
* @return number of index entries for the given {@code nodeId} and {@code propertyValues}.
*/
long countIndexedNodes( long nodeId, int[] propertyKeyIds, Value... propertyValues );
IndexSampler createSampler();
/**
* Queries the index for the given {@link IndexQuery} predicates.
*
* @param predicates the predicates to query for.
* @return the matching entity IDs.
*/
PrimitiveLongResourceIterator query( IndexQuery... predicates ) throws IndexNotApplicableKernelException;
/**
* Queries the index for the given {@link IndexQuery} predicates.
* @param client the client which will control the progression though query results.
* @param needsValues if the index should fetch property values together with node ids for index queries
* @param query the query so serve.
*/
void query( IndexProgressor.NodeValueClient client, IndexOrder indexOrder, boolean needsValues, IndexQuery... query )
throws IndexNotApplicableKernelException;
/**
* @param predicates query to determine whether or not index has full value precision for.
* @return whether or not this reader will only return 100% matching results from {@link #query(IndexQuery...)}.
* If {@code false} is returned this means that the caller of {@link #query(IndexQuery...)} will have to
* do additional filtering, double-checking of actual property values, externally.
*/
boolean hasFullValuePrecision( IndexQuery... predicates );
/**
* Initializes {@code client} to be able to progress through all distinct values in this index. {@link IndexProgressor.NodeValueClient}
* is used because it has a perfect method signature, even if the {@code reference} argument will instead be used
* as number of index entries for the specific indexed value.
*
* {@link IndexProgressor.NodeValueClient#needsValues()} decides whether or not values will be materialized and given to the client.
* The use-case for setting this to {@code false} is to have a more efficient counting of distinct values in an index,
* regardless of the actual values.
*
* @param client {@link IndexProgressor.NodeValueClient} to get initialized with this progression.
* @param propertyAccessor used for distinguishing between lossy indexed values.
*/
void distinctValues( IndexProgressor.NodeValueClient client, NodePropertyAccessor propertyAccessor );
IndexReader EMPTY = new IndexReader()
{
// Used for checking index correctness
@Override
public long countIndexedNodes( long nodeId, int[] propertyKeyIds, Value... propertyValues )
{
return 0;
}
@Override
public IndexSampler createSampler()
{
return IndexSampler.EMPTY;
}
@Override
public PrimitiveLongResourceIterator query( IndexQuery[] predicates )
{
return PrimitiveLongResourceCollections.emptyIterator();
}
@Override
public void query( IndexProgressor.NodeValueClient client, IndexOrder indexOrder, boolean needsValues, IndexQuery... query )
{
// do nothing
}
@Override
public void close()
{
}
@Override
public boolean hasFullValuePrecision( IndexQuery... predicates )
{
return true;
}
@Override
public void distinctValues( IndexProgressor.NodeValueClient client, NodePropertyAccessor propertyAccessor )
{
// do nothing
}
};
}