private static IndexQuery.ExactPredicate[] AssertOnlyExactPredicates(IndexQuery[] predicates)
{
IndexQuery.ExactPredicate[] exactPredicates;
if (predicates.GetType() == typeof(IndexQuery.ExactPredicate[]))
{
exactPredicates = (IndexQuery.ExactPredicate[])predicates;
}
else
{
exactPredicates = new IndexQuery.ExactPredicate[predicates.Length];
for (int i = 0; i < predicates.Length; i++)
{
if (predicates[i] is IndexQuery.ExactPredicate)
{
exactPredicates[i] = (IndexQuery.ExactPredicate)predicates[i];
}
else
{
// TODO: what to throw?
throw new System.ArgumentException("Query not supported: " + Arrays.ToString(predicates));
}
}
}
return(exactPredicates);
}
/// <summary>
/// Initializes {@code treeKeyFrom} and {@code treeKeyTo} from the <seealso cref="IndexQuery query"/>.
/// Geometry range queries makes an otherwise straight-forward key construction complex in that a geometry range internally is performed
/// by executing multiple sub-range queries to the index. Each of those sub-range queries still needs to construct the full composite key -
/// in the case of a composite index. Therefore this method can be called either with null or non-null {@code crs} and {@code range} and
/// constructing a key when coming across a <seealso cref="IndexQuery.GeometryRangePredicate"/> will use the provided crs/range instead
/// of the predicate, where the specific range is one out of many sub-ranges calculated from the <seealso cref="IndexQuery.GeometryRangePredicate"/>
/// by the caller.
/// </summary>
/// <param name="treeKeyFrom"> the "from" key to construct from the query. </param>
/// <param name="treeKeyTo"> the "to" key to construct from the query. </param>
/// <param name="query"> the query to construct keys from to later send to <seealso cref="GBPTree"/> when reading. </param>
/// <param name="crs"> <seealso cref="CoordinateReferenceSystem"/> for the specific {@code range}, if range is specified too. </param>
/// <param name="range"> sub-range of a larger <seealso cref="IndexQuery.GeometryRangePredicate"/> to use instead of <seealso cref="IndexQuery.GeometryRangePredicate"/>
/// in the query. </param>
/// <returns> {@code true} if filtering is needed for the results from the reader, otherwise {@code false}. </returns>
private bool InitializeRangeForGeometrySubQuery(GenericKey treeKeyFrom, GenericKey treeKeyTo, IndexQuery[] query, CoordinateReferenceSystem crs, SpaceFillingCurve.LongRange range)
{
bool needsFiltering = false;
for (int i = 0; i < query.Length; i++)
{
IndexQuery predicate = query[i];
switch (predicate.Type())
{
case exists:
treeKeyFrom.InitValueAsLowest(i, ValueGroup.UNKNOWN);
treeKeyTo.InitValueAsHighest(i, ValueGroup.UNKNOWN);
break;
case exact:
IndexQuery.ExactPredicate exactPredicate = (IndexQuery.ExactPredicate)predicate;
treeKeyFrom.InitFromValue(i, exactPredicate.Value(), NEUTRAL);
treeKeyTo.InitFromValue(i, exactPredicate.Value(), NEUTRAL);
break;
case range:
if (IsGeometryRangeQuery(predicate))
{
// Use the supplied SpaceFillingCurve range instead of the GeometryRangePredicate because at the time of calling this method
// the original geometry range have been split up into multiple sub-ranges and this invocation is for one of those sub-ranges.
// We can not take query inclusion / exclusion into consideration here because then we risk missing border values. Always use
// Inclusion.LOW / HIGH respectively and filter out points later on.
treeKeyFrom.StateSlot(i).writePointDerived(crs, range.Min, LOW);
treeKeyTo.StateSlot(i).writePointDerived(crs, range.Max + 1, HIGH);
}
else
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.internal.kernel.api.IndexQuery.RangePredicate<?> rangePredicate = (org.neo4j.internal.kernel.api.IndexQuery.RangePredicate<?>) predicate;
IndexQuery.RangePredicate <object> rangePredicate = (IndexQuery.RangePredicate <object>)predicate;
InitFromForRange(i, rangePredicate, treeKeyFrom);
InitToForRange(i, rangePredicate, treeKeyTo);
}
break;
case stringPrefix:
IndexQuery.StringPrefixPredicate prefixPredicate = (IndexQuery.StringPrefixPredicate)predicate;
treeKeyFrom.StateSlot(i).initAsPrefixLow(prefixPredicate.Prefix());
treeKeyTo.StateSlot(i).initAsPrefixHigh(prefixPredicate.Prefix());
break;
case stringSuffix:
case stringContains:
treeKeyFrom.InitValueAsLowest(i, ValueGroup.TEXT);
treeKeyTo.InitValueAsHighest(i, ValueGroup.TEXT);
needsFiltering = true;
break;
default:
throw new System.ArgumentException("IndexQuery of type " + predicate.Type() + " is not supported.");
}
}
return(needsFiltering);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void seekOverAllPartitions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void SeekOverAllPartitions()
{
PartitionedIndexReader indexReader = CreatePartitionedReaderFromReaders();
IndexQuery.ExactPredicate query = IndexQuery.exact(1, "Test");
when(_indexReader1.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 1));
when(_indexReader2.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 2));
when(_indexReader3.query(query)).thenReturn(PrimitiveLongResourceCollections.iterator(null, 3));
LongSet results = PrimitiveLongCollections.asSet(indexReader.Query(query));
VerifyResult(results);
}
/// <summary>
/// Performs an index seek.
/// </summary>
/// <param name="read"> The Read instance to use for seeking </param>
/// <param name="cursors"> Used for cursor allocation </param>
/// <param name="index"> A reference to an index </param>
/// <param name="value"> The value to seek for </param>
/// <returns> A cursor positioned at the data found in index. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static org.neo4j.internal.kernel.api.NodeValueIndexCursor indexSeek(org.neo4j.internal.kernel.api.Read read, org.neo4j.internal.kernel.api.CursorFactory cursors, org.neo4j.internal.kernel.api.IndexReference index, Object value) throws org.neo4j.internal.kernel.api.exceptions.KernelException
public static NodeValueIndexCursor IndexSeek(Read read, CursorFactory cursors, IndexReference index, object value)
{
Debug.Assert(index.Properties().Length == 1);
if (value == Values.NO_VALUE || value == null)
{
return([email protected]_Fields.Empty);
}
else
{
NodeValueIndexCursor cursor = cursors.AllocateNodeValueIndexCursor();
IndexQuery.ExactPredicate query = exact(index.Properties()[0], makeValueNeoSafe(value));
read.NodeIndexSeek(index, cursor, IndexOrder.NONE, false, query);
return(cursor);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void exactMatchOnAllValues(java.util.List<org.neo4j.values.storable.Value> values) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotApplicableKernelException
private void ExactMatchOnAllValues(IList <Value> values)
{
using (IndexReader indexReader = _accessor.newReader())
{
SimpleNodeValueClient client = new SimpleNodeValueClient();
foreach (Value value in values)
{
IndexQuery.ExactPredicate exact = IndexQuery.exact(_descriptor.schema().PropertyId, value);
indexReader.Query(client, IndexOrder.NONE, true, exact);
// then
assertTrue(client.Next());
assertEquals(value, client.Values[0]);
assertFalse(client.Next());
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyIndex(org.neo4j.kernel.impl.api.TransactionToApply tx) throws Exception
internal virtual void VerifyIndex(TransactionToApply tx)
{
using (IndexReader reader = Index.newReader())
{
NodeVisitor visitor = new NodeVisitor();
for (int i = 0; tx != null; i++)
{
tx.TransactionRepresentation().accept(visitor.Clear());
Value propertyValue = propertyValue(Id, Base + i);
IndexQuery.ExactPredicate query = IndexQuery.exact(outerInstance.descriptor.PropertyId, propertyValue);
LongIterator hits = reader.Query(query);
assertEquals("Index doesn't contain " + visitor.NodeId + " " + propertyValue, visitor.NodeId, hits.next());
assertFalse(hits.hasNext());
tx = tx.Next();
}
}
}
