//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected AutoCloseable query(org.neo4j.storageengine.api.schema.SimpleNodeValueClient client, org.neo4j.internal.kernel.api.IndexOrder order, org.neo4j.internal.kernel.api.IndexQuery... predicates) throws Exception
protected internal virtual AutoCloseable Query(SimpleNodeValueClient client, IndexOrder order, params IndexQuery[] predicates)
{
IndexReader reader = Accessor.newReader();
reader.Query(client, order, false, predicates);
return(reader);
}
/// <summary>
/// 操作得分
/// </summary>
/// <param name="starttime"></param>
/// <param name="endtime"></param>
/// <param name="DBName"></param>
/// <returns></returns>
public IList OQIAnalysis_score(String id, String starttime, String endtime, String DBName)
{
IList list = new ArrayList();
IDao dao = new Dao(DBName);
if (null != starttime && null != endtime)
{
string strSQL;
strSQL = "exec procOperateQualitySearch_Score '" + starttime + "','" + endtime + "',0";
DataSet ds = dao.executeProcDS(strSQL, "procOperateQualitySearch_Score");
if (ds != null)
{
int i = ds.Tables.Count;
try
{
int flag = int.Parse(id);
for (int di = 0; di < ds.Tables[flag - 1].Rows.Count; di++)
{
IndexOrder compAnaly = new IndexOrder();
compAnaly.name = ds.Tables[flag - 1].Rows[di]["DistributeName"].ToString();
compAnaly.value = float.Parse(ds.Tables[flag - 1].Rows[di]["Score"].ToString());
list.Add(compAnaly);
}
}
catch (Exception e)
{
string str = e.Message;
}
}
}
dao.closeConn();
return(list);
}
internal override void ValidateQuery(IndexOrder indexOrder, IndexQuery[] predicates)
{
if (predicates.Length != 1)
{
throw new System.NotSupportedException("Spatial index doesn't handle composite queries");
}
CapabilityValidator.ValidateQuery(SpatialIndexProvider.Capability, indexOrder, predicates);
}
private DynamicTest RangeTest(ReadableTransactionState state, IndexOrder indexOrder, Value lo, bool includeLo, Value hi, bool includeHi, params NodeWithPropertyValues[] expected)
{
return(DynamicTest.dynamicTest(string.Format("range seek: lo={0} (incl: {1}), hi={2} (incl: {3})", lo, includeLo, hi, includeHi), () =>
{
// Internal production code relies on null for unbounded, and cannot cope with NO_VALUE in this case
Debug.Assert(lo != NO_VALUE);
Debug.Assert(hi != NO_VALUE);
AddedAndRemoved changes = indexUpdatesForRangeSeek(state, _index, IndexQuery.range(-1, lo, includeLo, hi, includeHi), indexOrder);
AddedWithValuesAndRemoved changesWithValues = indexUpdatesWithValuesForRangeSeek(state, _index, IndexQuery.range(-1, lo, includeLo, hi, includeHi), indexOrder);
AssertContains(indexOrder, changes, changesWithValues, expected);
}));
}
internal virtual void AssertRangeSeekByPrefixForOrder(IndexOrder indexOrder)
{
// GIVEN
ReadableTransactionState state = (new TxStateBuilder()).WithAdded(40L, "Aaron").withAdded(41L, "Agatha").withAdded(42L, "Andreas").withAdded(43L, "Barbarella").withAdded(44L, "Andrea").withAdded(45L, "Aristotle").withAdded(46L, "Barbara").withAdded(47L, "Andy").withAdded(48L, "Cinderella").withAdded(49L, "Andromeda").build();
// WHEN
AddedAndRemoved changes = indexUpdatesForRangeSeekByPrefix(state, outerInstance.index, stringValue("And"), indexOrder);
AddedWithValuesAndRemoved changesWithValues = indexUpdatesWithValuesForRangeSeekByPrefix(state, outerInstance.index, stringValue("And"), indexOrder);
NodeWithPropertyValues[] expected = new NodeWithPropertyValues[] { NodeWithPropertyValues(44L, "Andrea"), NodeWithPropertyValues(42L, "Andreas"), NodeWithPropertyValues(49L, "Andromeda"), NodeWithPropertyValues(47L, "Andy") };
// THEN
outerInstance.AssertContains(indexOrder, changes, changesWithValues, expected);
}
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] query, IndexOrder indexOrder, bool needsValues)
{
Debug.Assert(query != null);
base.Initialize(progressor);
_sortedMergeJoin.initialize(indexOrder);
this._indexOrder = indexOrder;
this._needsValues = needsValues;
this._query = query;
if (_read.hasTxStateWithChanges() && query.Length > 0)
{
IndexQuery firstPredicate = query[0];
switch (firstPredicate.Type())
{
case exact:
// No need to order, all values are the same
this._indexOrder = IndexOrder.NONE;
SeekQuery(descriptor, query);
break;
case exists:
SetNeedsValuesIfRequiresOrder();
ScanQuery(descriptor);
break;
case range:
Debug.Assert(query.Length == 1);
SetNeedsValuesIfRequiresOrder();
RangeQuery(descriptor, (IndexQuery.RangePredicate)firstPredicate);
break;
case stringPrefix:
Debug.Assert(query.Length == 1);
SetNeedsValuesIfRequiresOrder();
PrefixQuery(descriptor, (IndexQuery.StringPrefixPredicate)firstPredicate);
break;
case stringSuffix:
case stringContains:
Debug.Assert(query.Length == 1);
SuffixOrContainsQuery(descriptor, firstPredicate);
break;
default:
throw new System.NotSupportedException("Query not supported: " + Arrays.ToString(query));
}
}
}
internal virtual void AssertRangeSeekByContainsForOrder(IndexOrder indexOrder)
{
// GIVEN
ReadableTransactionState state = (new TxStateBuilder()).WithAdded(40L, "Smashing").withAdded(41L, "Bashley").withAdded(42L, "Crasch").withAdded(43L, "Mayonnaise").withAdded(44L, "Seashell").withAdded(45L, "Ton").withAdded(46L, "The Flash").withAdded(47L, "Strayhound").withAdded(48L, "Trashy").withAdded(49L, "Andromeda").build();
// WHEN
IndexQuery indexQuery = IndexQuery.stringContains(outerInstance.index.Schema().PropertyId, stringValue("ash"));
AddedAndRemoved changes = indexUpdatesForSuffixOrContains(state, outerInstance.index, indexQuery, indexOrder);
AddedWithValuesAndRemoved changesWithValues = indexUpdatesWithValuesForSuffixOrContains(state, outerInstance.index, indexQuery, indexOrder);
NodeWithPropertyValues[] expected = new NodeWithPropertyValues[] { NodeWithPropertyValues(41L, "Bashley"), NodeWithPropertyValues(44L, "Seashell"), NodeWithPropertyValues(40L, "Smashing"), NodeWithPropertyValues(46L, "The Flash"), NodeWithPropertyValues(48L, "Trashy") };
// THEN
outerInstance.AssertContains(indexOrder, changes, changesWithValues, expected);
}
public IndexServices()
{
database = new Database(Settings.ProtocolConfiguration.ChainFolderName);
OwnerIndex = new IndexOwner(database);
TokenIndex = new IndexToken(database);
string nativeTokenSymbol = null;
if (TokenIndex.GetNative() != null)
{
nativeTokenSymbol = TokenIndex.GetNative().Symbol;
}
BalanceIndex = new IndexBalance(database, nativeTokenSymbol);
OrderIndex = new IndexOrder(database);
}
private void AssertScanWithOrder(IndexOrder indexOrder)
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.storageengine.api.txstate.ReadableTransactionState state = new TxStateBuilder().withAdded(40L, "Aaron").withAdded(41L, "Agatha").withAdded(42L, "Andreas").withAdded(43L, "Barbarella").withAdded(44L, "Andrea").withAdded(45L, "Aristotle").withAdded(46L, "Barbara").withAdded(47L, "Cinderella").build();
ReadableTransactionState state = (new TxStateBuilder()).WithAdded(40L, "Aaron").withAdded(41L, "Agatha").withAdded(42L, "Andreas").withAdded(43L, "Barbarella").withAdded(44L, "Andrea").withAdded(45L, "Aristotle").withAdded(46L, "Barbara").withAdded(47L, "Cinderella").build();
// WHEN
AddedAndRemoved changes = indexUpdatesForScan(state, _index, indexOrder);
AddedWithValuesAndRemoved changesWithValues = indexUpdatesWithValuesForScan(state, _index, indexOrder);
NodeWithPropertyValues[] expectedNodesWithValues = new NodeWithPropertyValues[] { NodeWithPropertyValues(40L, "Aaron"), NodeWithPropertyValues(41L, "Agatha"), NodeWithPropertyValues(44L, "Andrea"), NodeWithPropertyValues(42L, "Andreas"), NodeWithPropertyValues(45L, "Aristotle"), NodeWithPropertyValues(46L, "Barbara"), NodeWithPropertyValues(43L, "Barbarella"), NodeWithPropertyValues(47L, "Cinderella") };
// THEN
AssertContains(indexOrder, changes, changesWithValues, expectedNodesWithValues);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: java.util.List<long> assertInOrder(org.neo4j.internal.kernel.api.IndexOrder order, org.neo4j.internal.kernel.api.IndexQuery... predicates) throws Exception
internal virtual IList <long> AssertInOrder(IndexOrder order, params IndexQuery[] predicates)
{
IList <long> actualIds;
if (order == IndexOrder.NONE)
{
actualIds = Query(predicates);
}
else
{
SimpleNodeValueClient client = new SimpleNodeValueClient();
using (AutoCloseable ignore = Query(client, order, predicates))
{
actualIds = AssertClientReturnValuesInOrder(client, order);
}
}
return(actualIds);
}
private void AssertContains(IndexOrder indexOrder, AddedAndRemoved changes, AddedWithValuesAndRemoved changesWithValues, NodeWithPropertyValues[] expected)
{
if (indexOrder == IndexOrder.DESCENDING)
{
ArrayUtils.reverse(expected);
}
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
long[] expectedNodeIds = java.util.expected.Select(NodeWithPropertyValues::getNodeId).ToArray();
if (indexOrder == IndexOrder.NONE)
{
AssertContains(changes.Added, expectedNodeIds);
AssertContains(changesWithValues.Added, expected);
}
else
{
AssertContainsInOrder(changes.Added, expectedNodeIds);
AssertContainsInOrder(changesWithValues.Added, expected);
}
}
public override void NodeIndexScan(IndexReference index, NodeValueIndexCursor cursor, IndexOrder indexOrder, bool needsValues)
{
throw new System.NotSupportedException();
}
public override void NodeIndexSeek(IndexReference index, NodeValueIndexCursor cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] query)
{
throw new System.NotSupportedException();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void query(org.neo4j.storageengine.api.schema.IndexProgressor_NodeValueClient cursor, org.neo4j.internal.kernel.api.IndexOrder indexOrder, boolean needsValues, org.neo4j.internal.kernel.api.IndexQuery... predicates) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException
public override void Query(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] predicates)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
IndexSlot slot = SlotSelector.selectSlot(predicates, IndexQuery::valueGroup);
if (slot != null)
{
InstanceSelector.select(slot).query(cursor, indexOrder, needsValues, predicates);
}
else
{
if (indexOrder != IndexOrder.NONE)
{
throw new System.NotSupportedException(format("Tried to query index with unsupported order %s. Supported orders for query %s are %s.", indexOrder, Arrays.ToString(predicates), IndexOrder.NONE));
}
BridgingIndexProgressor multiProgressor = new BridgingIndexProgressor(cursor, _descriptor.schema().PropertyIds);
cursor.Initialize(_descriptor, multiProgressor, predicates, indexOrder, needsValues);
try
{
InstanceSelector.forAll(reader =>
{
try
{
reader.query(multiProgressor, indexOrder, needsValues, predicates);
}
catch (IndexNotApplicableKernelException e)
{
throw new InnerException(e);
}
});
}
catch (InnerException e)
{
throw e.InnerException;
}
}
}
public ICursor Sort(string field, IndexOrder order)
{
return this.Sort(new Document().Append(field, order));
}
public override void Query(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] predicates)
{
ValidateQuery(indexOrder, predicates);
KEY treeKeyFrom = Layout.newKey();
KEY treeKeyTo = Layout.newKey();
InitializeFromToKeys(treeKeyFrom, treeKeyTo);
bool needFilter = InitializeRangeForQuery(treeKeyFrom, treeKeyTo, predicates);
StartSeekForInitializedRange(cursor, treeKeyFrom, treeKeyTo, predicates, indexOrder, needFilter, needsValues);
}
/// <summary>
/// Sorts the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="order">The order.</param>
/// <returns></returns>
public ICursor Sort(string field, IndexOrder order)
{
_cursor.Sort(field, order);
return(this);
}
/// <summary>
/// Evaluates the function on a vector argument.
/// </summary>
/// <param name="Arguments">Function arguments.</param>
/// <param name="Variables">Variables collection.</param>
/// <returns>Function result.</returns>
public override IElement Evaluate(IElement[] Arguments, Variables Variables)
{
int c = Arguments.Length;
if (!(Arguments[0] is IVector Vector))
{
throw new ScriptRuntimeException("First argument muts be a vector.", this);
}
ICollection <IElement> Temp = Vector.VectorElements;
IElement[] Elements;
int i;
if (Temp is IElement[] V)
{
Elements = (IElement[])V.Clone();
}
else
{
Elements = new IElement[Temp.Count];
i = 0;
foreach (IElement E in Temp)
{
Elements[i++] = E;
}
}
if (c == 1)
{
Array.Sort <IElement>(Elements, new ElementOrder(this));
}
else
{
IComparer <IElement>[] Comparers = new IComparer <IElement> [c];
IElement Element;
for (i = 1; i < c; i++)
{
Element = Arguments[i];
if (Element is DoubleNumber N)
{
double d = N.Value;
int Sign = 1;
if (d < 0)
{
Sign = -1;
d = -d;
}
if (d == 0 || d > int.MaxValue || d != Math.Truncate(d))
{
throw new ScriptRuntimeException("Index values must be non-zero integers.", this);
}
Comparers[i - 1] = new IndexOrder(this, (int)(d - 1), Sign);
}
else if (Element is StringValue S)
{
string s = S.Value;
int Sign = 1;
if (s.StartsWith("-"))
{
s = s.Substring(1);
Sign = -1;
}
Comparers[i - 1] = new PropertyOrder(this, s, Sign);
}
else if (Element is ILambdaExpression Lambda)
{
if (Lambda.NrArguments != 2)
{
throw new ScriptRuntimeException("Lambda expressions must take exactly two parameters.", this);
}
Comparers[i - 1] = new LambdaOrder(Lambda, Variables);
}
else
{
throw new ScriptRuntimeException("Order parameters must be either lambda expressions, " +
"string values representing field names or numeric index values.", this);
}
}
Comparers[c - 1] = new ElementOrder(this);
Array.Sort(Elements, new CompoundOrder(Comparers));
}
return(Vector.Encapsulate(Elements, this));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void query(org.neo4j.storageengine.api.schema.IndexProgressor_NodeValueClient client, org.neo4j.internal.kernel.api.IndexOrder indexOrder, boolean needsValues, org.neo4j.internal.kernel.api.IndexQuery... predicates) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException
public override void Query(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, IndexOrder indexOrder, bool needsValues, params IndexQuery[] predicates)
{
Query query = ToLuceneQuery(predicates);
client.Initialize(_descriptor, Search(query).getIndexProgressor(NODE_ID_KEY, client), predicates, indexOrder, needsValues);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: org.neo4j.cursor.RawCursor<org.neo4j.index.internal.gbptree.Hit<KEY,VALUE>,java.io.IOException> makeIndexSeeker(KEY treeKeyFrom, KEY treeKeyTo, org.neo4j.internal.kernel.api.IndexOrder indexOrder) throws java.io.IOException
internal virtual RawCursor <Hit <KEY, VALUE>, IOException> MakeIndexSeeker(KEY treeKeyFrom, KEY treeKeyTo, IndexOrder indexOrder)
{
if (indexOrder == IndexOrder.DESCENDING)
{
KEY tmpKey = treeKeyFrom;
treeKeyFrom = treeKeyTo;
treeKeyTo = tmpKey;
}
RawCursor <Hit <KEY, VALUE>, IOException> seeker = Tree.seek(treeKeyFrom, treeKeyTo);
OpenSeekers.Add(seeker);
return(seeker);
}
internal virtual void StartSeekForInitializedRange(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, KEY treeKeyFrom, KEY treeKeyTo, IndexQuery[] query, IndexOrder indexOrder, bool needFilter, bool needsValues)
{
if (IsEmptyRange(treeKeyFrom, treeKeyTo))
{
client.Initialize(Descriptor, IndexProgressor.EMPTY, query, indexOrder, needsValues);
return;
}
try
{
RawCursor <Hit <KEY, VALUE>, IOException> seeker = MakeIndexSeeker(treeKeyFrom, treeKeyTo, indexOrder);
IndexProgressor hitProgressor = GetIndexProgressor(seeker, client, needFilter, query);
client.Initialize(Descriptor, hitProgressor, query, indexOrder, needsValues);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
internal abstract void ValidateQuery(IndexOrder indexOrder, IndexQuery[] predicates);
public ICursor Sort(string field, IndexOrder order)
{
return(this.Sort(new Document().Append(field, order)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public final void nodeIndexScan(org.neo4j.internal.kernel.api.IndexReference index, org.neo4j.internal.kernel.api.NodeValueIndexCursor cursor, org.neo4j.internal.kernel.api.IndexOrder indexOrder, boolean needsValues) throws org.neo4j.internal.kernel.api.exceptions.KernelException
public override void NodeIndexScan(IndexReference index, NodeValueIndexCursor cursor, IndexOrder indexOrder, bool needsValues)
{
Ktx.assertOpen();
if (HasForbiddenProperties(index))
{
cursor.Close();
return;
}
// for a scan, we simply query for existence of the first property, which covers all entries in an index
int firstProperty = index.Properties()[0];
DefaultNodeValueIndexCursor cursorImpl = ( DefaultNodeValueIndexCursor )cursor;
cursorImpl.Read = this;
IndexReader(index, false).query(cursorImpl, indexOrder, needsValues, IndexQuery.exists(firstProperty));
}
/// <summary>
/// Sorts the specified field.
/// </summary>
/// <param name = "field">The field.</param>
/// <param name = "order">The order.</param>
/// <returns></returns>
public ICursor <T> Sort(string field, IndexOrder order)
{
return(Sort(new Document().Add(field, order)));
}
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] queries, IndexOrder indexOrder, bool needsValues)
{
_events.Add(new Event.Initialize(progressor, descriptor.Schema().PropertyIds));
}
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] query, IndexOrder indexOrder, bool needsValues)
{
this._progressor = progressor;
_target.initialize(descriptor, this, query, indexOrder, needsValues);
}
/// <summary>
/// Sorts the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="order">The order.</param>
/// <returns></returns>
public ICursor Sort(string field, IndexOrder order){
_cursor.Sort(field, order);
return this;
}
public abstract void NodeIndexSeek(IndexReference index, NodeValueIndexCursor cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] query);
private IList <long> ExpectedIdsInOrder(NodeValueTuple from, bool fromInclusive, NodeValueTuple to, bool toInclusive, IndexOrder indexOrder)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
IList <long> expectedIdsInOrder = _singlePropValues.subSet(from, fromInclusive, to, toInclusive).Select(NodeValueTuple::nodeId).ToList();
if (indexOrder == IndexOrder.DESCENDING)
{
expectedIdsInOrder.Reverse();
}
return(expectedIdsInOrder);
}
public override void Query(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] predicates)
{
if (predicates.Length != 1)
{
throw new System.ArgumentException("Only single property temporal indexes are supported.");
}
IndexQuery predicate = predicates[0];
if (predicate is IndexQuery.ExistsPredicate)
{
LoadAll();
BridgingIndexProgressor multiProgressor = new BridgingIndexProgressor(cursor, _descriptor.schema().PropertyIds);
cursor.Initialize(_descriptor, multiProgressor, predicates, indexOrder, needsValues);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (NativeIndexReader<?,NativeIndexValue> reader : this)
foreach (NativeIndexReader <object, NativeIndexValue> reader in this)
{
reader.Query(multiProgressor, indexOrder, needsValues, predicates);
}
}
else
{
if (ValidPredicate(predicate))
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: NativeIndexReader<?,NativeIndexValue> part = uncheckedSelect(predicate.valueGroup());
NativeIndexReader <object, NativeIndexValue> part = UncheckedSelect(predicate.ValueGroup());
if (part != null)
{
part.Query(cursor, indexOrder, needsValues, predicates);
}
else
{
cursor.Initialize(_descriptor, IndexProgressor.EMPTY, predicates, indexOrder, needsValues);
}
}
else
{
cursor.Initialize(_descriptor, IndexProgressor.EMPTY, predicates, indexOrder, needsValues);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public final void nodeIndexSeek(org.neo4j.internal.kernel.api.IndexReference index, org.neo4j.internal.kernel.api.NodeValueIndexCursor cursor, org.neo4j.internal.kernel.api.IndexOrder indexOrder, boolean needsValues, org.neo4j.internal.kernel.api.IndexQuery... query) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException, org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override void NodeIndexSeek(IndexReference index, NodeValueIndexCursor cursor, IndexOrder indexOrder, bool needsValues, params IndexQuery[] query)
{
Ktx.assertOpen();
if (HasForbiddenProperties(index))
{
cursor.Close();
return;
}
DefaultNodeValueIndexCursor cursorImpl = ( DefaultNodeValueIndexCursor )cursor;
IndexReader reader = IndexReader(index, false);
cursorImpl.Read = this;
Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient withFullPrecision = InjectFullValuePrecision(cursorImpl, query, reader);
reader.Query(withFullPrecision, indexOrder, needsValues, query);
}
