//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.storageengine.api.schema.IndexReader getFreshIndexReader(org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override IndexReader GetFreshIndexReader(IndexDescriptor descriptor)
{
return(IndexReaderFactory().newUnCachedReader(descriptor));
}
internal NativeIndexReader(GBPTree <KEY, VALUE> tree, IndexLayout <KEY, VALUE> layout, IndexDescriptor descriptor)
{
this.Tree = tree;
this.Layout = layout;
this.Descriptor = descriptor;
this.OpenSeekers = new HashSet <RawCursor <Hit <KEY, VALUE>, IOException> >();
}
public override bool IndexDoUnRemove(IndexDescriptor descriptor)
{
return(IndexChangesDiffSets().unRemove(descriptor));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.internal.kernel.api.IndexReference indexReference(org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override IndexReference IndexReference(IndexDescriptor descriptor)
{
IndexProxy indexProxy = _indexService.getIndexProxy(descriptor.Schema());
return(indexProxy.Descriptor);
}
protected internal AbstractLuceneIndexAccessor(INDEX luceneIndex, IndexDescriptor descriptor)
{
this.Writer = luceneIndex.ReadOnly ? null : luceneIndex.IndexWriter;
this.LuceneIndex = luceneIndex;
this.Descriptor = descriptor;
}
protected virtual IndexDescriptor <T> BuildQuery(IndexDescriptor <T> descriptor)
{
return(descriptor);
}
internal PartAccessor(PageCache pageCache, FileSystemAbstraction fs, TemporalIndexFiles.FileLayout <KEY> fileLayout, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, bool readOnly) : base(pageCache, fs, fileLayout.IndexFile, fileLayout.Layout, monitor, descriptor, NO_HEADER_WRITER, readOnly)
{
this.Layout = fileLayout.Layout;
this.Descriptor = descriptor;
instantiateTree(recoveryCleanupWorkCollector, headerWriter);
}
protected IIndexRequest <Project> CreateFluent(string id, IndexDescriptor <Project> d) => d.Id(id);
internal static AddedWithValuesAndRemoved IndexUpdatesWithValuesForSuffixOrContains(ReadableTransactionState txState, IndexDescriptor descriptor, IndexQuery query, IndexOrder indexOrder)
{
if (descriptor.Schema().PropertyIds.Length != 1)
{
throw new System.InvalidOperationException("Suffix and contains queries are only supported for single property queries");
}
return(IndexUpdatesWithValuesScanAndFilter(txState, descriptor, query, indexOrder));
}
// SEEK
internal static AddedAndRemoved IndexUpdatesForSeek(ReadableTransactionState txState, IndexDescriptor descriptor, ValueTuple values)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.eclipse.collections.impl.UnmodifiableMap<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> updates = txState.getIndexUpdates(descriptor.schema());
UnmodifiableMap <ValueTuple, ? extends LongDiffSets> updates = txState.GetIndexUpdates(descriptor.Schema());
if (updates != null)
{
LongDiffSets indexUpdatesForSeek = updates.get(values);
return(indexUpdatesForSeek == null ? _emptyAddedAndRemoved : new AddedAndRemoved(LongLists.mutable.ofAll(indexUpdatesForSeek.Added), indexUpdatesForSeek.Removed));
}
return(_emptyAddedAndRemoved);
}
internal static AddedWithValuesAndRemoved IndexUpdatesWithValuesForScan(ReadableTransactionState txState, IndexDescriptor descriptor, IndexOrder indexOrder)
{
return(IndexUpdatesWithValuesScanAndFilter(txState, descriptor, null, indexOrder));
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private static java.util.Map<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> getUpdates(org.neo4j.storageengine.api.txstate.ReadableTransactionState txState, org.neo4j.storageengine.api.schema.IndexDescriptor descriptor, org.neo4j.internal.kernel.api.IndexOrder indexOrder)
private static IDictionary <ValueTuple, ? extends LongDiffSets> GetUpdates(ReadableTransactionState txState, IndexDescriptor descriptor, IndexOrder indexOrder)
{
return(indexOrder == IndexOrder.NONE ? txState.GetIndexUpdates(descriptor.Schema()) : txState.GetSortedIndexUpdates(descriptor.Schema()));
}
private static AddedWithValuesAndRemoved IndexUpdatesWithValuesScanAndFilter(ReadableTransactionState txState, IndexDescriptor descriptor, IndexQuery filter, IndexOrder indexOrder)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> updates = getUpdates(txState, descriptor, indexOrder);
IDictionary <ValueTuple, ? extends LongDiffSets> updates = GetUpdates(txState, descriptor, indexOrder);
if (updates == null)
{
return(_emptyAddedAndRemovedWithValues);
}
MutableList <NodeWithPropertyValues> added = Lists.mutable.empty();
MutableLongSet removed = LongSets.mutable.empty();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.Map.Entry<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> entry : updates.entrySet())
foreach (KeyValuePair <ValueTuple, ? extends LongDiffSets> entry in updates.SetOfKeyValuePairs())
{
ValueTuple key = entry.Key;
if (filter == null || filter.AcceptsValue(key.OnlyValue))
{
Value[] values = key.Values;
LongDiffSets diffSet = entry.Value;
diffSet.Added.each(nodeId => added.add(new NodeWithPropertyValues(nodeId, values)));
removed.addAll(diffSet.Removed);
}
}
return(new AddedWithValuesAndRemoved(indexOrder == IndexOrder.DESCENDING ? added.asReversed() : added, removed));
}
internal static AddedWithValuesAndRemoved IndexUpdatesWithValuesForRangeSeekByPrefix(ReadableTransactionState txState, IndexDescriptor descriptor, TextValue prefix, IndexOrder indexOrder)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.NavigableMap<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> sortedUpdates = txState.getSortedIndexUpdates(descriptor.schema());
NavigableMap <ValueTuple, ? extends LongDiffSets> sortedUpdates = txState.GetSortedIndexUpdates(descriptor.Schema());
if (sortedUpdates == null)
{
return(_emptyAddedAndRemovedWithValues);
}
ValueTuple floor = ValueTuple.of(prefix);
MutableList <NodeWithPropertyValues> added = Lists.mutable.empty();
MutableLongSet removed = LongSets.mutable.empty();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.Map.Entry<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> entry : sortedUpdates.tailMap(floor).entrySet())
foreach (KeyValuePair <ValueTuple, ? extends LongDiffSets> entry in sortedUpdates.tailMap(floor).entrySet())
{
ValueTuple key = entry.Key;
if ((( TextValue )key.OnlyValue).startsWith(prefix))
{
LongDiffSets diffSets = entry.Value;
Value[] values = key.Values;
diffSets.Added.each(nodeId => added.add(new NodeWithPropertyValues(nodeId, values)));
removed.addAll(diffSets.Removed);
}
else
{
break;
}
}
return(new AddedWithValuesAndRemoved(indexOrder == IndexOrder.DESCENDING ? added.asReversed() : added, removed));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: TemporalIndexAccessor(org.neo4j.storageengine.api.schema.StoreIndexDescriptor descriptor, org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig samplingConfig, org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, org.neo4j.kernel.api.index.IndexProvider.Monitor monitor, TemporalIndexFiles temporalIndexFiles, boolean readOnly) throws java.io.IOException
internal TemporalIndexAccessor(StoreIndexDescriptor descriptor, IndexSamplingConfig samplingConfig, PageCache pageCache, FileSystemAbstraction fs, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, TemporalIndexFiles temporalIndexFiles, bool readOnly) : base(new PartFactory(pageCache, fs, recoveryCleanupWorkCollector, monitor, descriptor, samplingConfig, temporalIndexFiles, readOnly))
{
this._descriptor = descriptor;
temporalIndexFiles.LoadExistingIndexes(this);
}
public IndexAccessorCompatibility(IndexProviderCompatibilityTestSuite testSuite, IndexDescriptor descriptor) : base(testSuite, descriptor)
{
}
internal GenericNativeIndexReader(GBPTree <GenericKey, NativeIndexValue> tree, IndexLayout <GenericKey, NativeIndexValue> layout, IndexDescriptor descriptor, IndexSpecificSpaceFillingCurveSettingsCache spaceFillingCurveSettings, SpaceFillingCurveConfiguration configuration) : base(tree, layout, descriptor)
{
this._spaceFillingCurveSettings = spaceFillingCurveSettings;
this._configuration = configuration;
}
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] query, IndexOrder indexOrder, bool needsValues)
{
this._progressor = progressor;
_target.initialize(descriptor, this, query, indexOrder, needsValues);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.internal.kernel.api.InternalIndexState indexGetState(org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override InternalIndexState IndexGetState(IndexDescriptor descriptor)
{
return(_reader.indexGetState(descriptor));
}
protected virtual IndexDescriptor <T> BuildQueryCore(IndexDescriptor <T> descriptor, Refresh refreshOnSave)
{
return(BuildQuery(descriptor)
.Type <T>()
.Refresh(refreshOnSave));
}
public override void Initialize(IndexDescriptor descriptor, IndexProgressor progressor, IndexQuery[] queries, IndexOrder indexOrder, bool needsValues)
{
AssertKeysAlign(descriptor.Schema().PropertyIds);
_progressors.AddLast(progressor);
}
public override void IndexDoDrop(IndexDescriptor descriptor)
{
IndexChangesDiffSets().remove(descriptor);
Changed();
}
internal static IndexDescriptor <T> Refresh <T>(this IndexDescriptor <T> descriptor, bool refresh = true) where T : class
{
return(descriptor.Refresh(refresh ? Elasticsearch.Net.Refresh.True : Elasticsearch.Net.Refresh.False));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.internal.kernel.api.InternalIndexState indexGetState(org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override InternalIndexState IndexGetState(IndexDescriptor descriptor)
{
return(_indexService.getIndexProxy(descriptor.Schema()).State);
}
public override PropertyDescriptor GetOwnProperty(string propertyName)
{
PropertyDescriptor x;
if (Properties.TryGetValue(propertyName, out x))
{
return(x);
}
// look for a property
var property = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.Where(p => EqualsIgnoreCasing(p.Name, propertyName))
.Where(p => !isInterface || IsJsInterface(p))
.FirstOrDefault();
if (property != null)
{
var descriptor = new PropertyInfoDescriptor(Engine, property, Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// look for a field
var field = type.GetFields(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.Where(f => EqualsIgnoreCasing(f.Name, propertyName))
.Where(f => !isInterface || IsJsInterface(f))
.FirstOrDefault();
if (field != null)
{
var descriptor = new FieldInfoDescriptor(Engine, field, Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// if no properties were found then look for a method
var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)
.Where(m => EqualsIgnoreCasing(m.Name, propertyName))
.Where(m => !isInterface || IsJsInterface(m))
.ToArray();
if (methods.Any())
{
var descriptor = new PropertyDescriptor(new MethodInfoFunctionInstance(Engine, methods), false, true, false);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// if no methods are found check if target implemented indexing
var indexes = type.GetProperties().Where(p => p.GetIndexParameters().Length == 1).Where(p => !isInterface || IsJsInterface(p));
if (indexes.FirstOrDefault() != null)
{
var descriptor = IndexDescriptor.Create(Engine, propertyName, Target);
if (descriptor != null)
{
Properties.Add(propertyName, descriptor);
return(descriptor);
}
}
var interfaces = type.GetInterfaces();
// try to find a single explicit property implementation
var explicitProperties = (from iface in interfaces
from iprop in iface.GetProperties()
where EqualsIgnoreCasing(iprop.Name, propertyName)
where !isInterface || IsJsInterface(iprop)
select iprop).ToArray();
if (explicitProperties.Length == 1)
{
var descriptor = new PropertyInfoDescriptor(Engine, explicitProperties[0], Target);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// try to find explicit method implementations
var explicitMethods = (from iface in interfaces
from imethod in iface.GetMethods()
where EqualsIgnoreCasing(imethod.Name, propertyName)
where !isInterface || IsJsInterface(imethod)
select imethod).ToArray();
if (explicitMethods.Length > 0)
{
var descriptor = new PropertyDescriptor(new MethodInfoFunctionInstance(Engine, explicitMethods), false, true, false);
Properties.Add(propertyName, descriptor);
return(descriptor);
}
// try to find explicit indexer implementations
var explicitIndexers =
(from iface in interfaces
from iprop in iface.GetProperties()
where iprop.GetIndexParameters().Length != 0
where !isInterface || IsJsInterface(iprop)
select iprop).ToArray();
if (explicitIndexers.Length == 1)
{
var descriptor = IndexDescriptor.Create(Engine, explicitIndexers[0].DeclaringType, propertyName, Target);
if (descriptor != null)
{
Properties.Add(propertyName, descriptor);
return(descriptor);
}
}
return(PropertyDescriptor.Undefined);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.storageengine.api.schema.IndexReader getIndexReader(org.neo4j.storageengine.api.schema.IndexDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override IndexReader GetIndexReader(IndexDescriptor descriptor)
{
return(IndexReaderFactory().newReader(descriptor));
}
public override void VisitAddedIndex(IndexDescriptor index)
{
StoreIndexDescriptor rule = index.WithId(_schemaStorage.newRuleId());
_recordState.createSchemaRule(rule);
}
public ReadOnlyDatabaseSchemaIndex(PartitionedIndexStorage indexStorage, IndexDescriptor descriptor, IndexSamplingConfig samplingConfig, ReadOnlyIndexPartitionFactory readOnlyIndexPartitionFactory) : base(new LuceneSchemaIndex(indexStorage, descriptor, samplingConfig, readOnlyIndexPartitionFactory))
{
}
internal SpatialIndexPartReader(GBPTree <SpatialIndexKey, VALUE> tree, IndexLayout <SpatialIndexKey, VALUE> layout, IndexDescriptor descriptor, SpaceFillingCurveConfiguration configuration) : base(tree, layout, descriptor)
{
_spatial = ( SpatialLayout )layout;
this._configuration = configuration;
}
private IndexDescriptor<JObject> ConfigureItem(IndexDescriptor<JObject> idx, IHit<JObject> hit, string targetIndex) {
idx.Index(targetIndex);
idx.Type(hit.Type);
idx.Id(hit.Id);
if (!String.IsNullOrEmpty(hit.Version)) {
long version;
if (!Int64.TryParse(hit.Version, out version))
version = 1;
idx.Version(version);
}
if (hit.Fields?.FieldValuesDictionary != null && hit.Fields.FieldValuesDictionary.ContainsKey("_parent"))
idx.Parent(hit.Fields.FieldValuesDictionary["_parent"].ToString());
return idx;
}
internal static AddedWithValuesAndRemoved IndexUpdatesWithValuesForRangeSeek <T1>(ReadableTransactionState txState, IndexDescriptor descriptor, IndexQuery.RangePredicate <T1> predicate, IndexOrder indexOrder)
{
Value lower = predicate.FromValue();
Value upper = predicate.ToValue();
if (lower == null || upper == null)
{
throw new System.InvalidOperationException("Use Values.NO_VALUE to encode the lack of a bound");
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.NavigableMap<org.neo4j.values.storable.ValueTuple, ? extends org.neo4j.storageengine.api.txstate.LongDiffSets> sortedUpdates = txState.getSortedIndexUpdates(descriptor.schema());
NavigableMap <ValueTuple, ? extends LongDiffSets> sortedUpdates = txState.GetSortedIndexUpdates(descriptor.Schema());
if (sortedUpdates == null)
{
return(_emptyAddedAndRemovedWithValues);
}
ValueTuple selectedLower;
bool selectedIncludeLower;
ValueTuple selectedUpper;
bool selectedIncludeUpper;
if (lower == NO_VALUE)
{
selectedLower = ValueTuple.of(Values.minValue(predicate.ValueGroup(), upper));
selectedIncludeLower = true;
}
else
{
selectedLower = ValueTuple.of(lower);
selectedIncludeLower = predicate.FromInclusive();
}
if (upper == NO_VALUE)
{
selectedUpper = ValueTuple.of(Values.maxValue(predicate.ValueGroup(), lower));
selectedIncludeUpper = false;
}
else
{
selectedUpper = ValueTuple.of(upper);
selectedIncludeUpper = predicate.ToInclusive();
}
MutableList <NodeWithPropertyValues> added = Lists.mutable.empty();
MutableLongSet removed = LongSets.mutable.empty();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> inRange = sortedUpdates.subMap(selectedLower, selectedIncludeLower, selectedUpper, selectedIncludeUpper);
IDictionary <ValueTuple, ? extends LongDiffSets> inRange = sortedUpdates.subMap(selectedLower, selectedIncludeLower, selectedUpper, selectedIncludeUpper);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.Map.Entry<org.neo4j.values.storable.ValueTuple,? extends org.neo4j.storageengine.api.txstate.LongDiffSets> entry : inRange.entrySet())
foreach (KeyValuePair <ValueTuple, ? extends LongDiffSets> entry in inRange.SetOfKeyValuePairs())
{
ValueTuple values = entry.Key;
Value[] valuesArray = values.Values;
LongDiffSets diffForSpecificValue = entry.Value;
// The TreeMap cannot perfectly order multi-dimensional types (spatial) and need additional filtering out false positives
// TODO: If the composite index starts to be able to handle spatial types the line below needs enhancement
if (predicate.RegularOrder || predicate.AcceptsValue(values.OnlyValue))
{
diffForSpecificValue.Added.each(nodeId => added.add(new NodeWithPropertyValues(nodeId, valuesArray)));
removed.addAll(diffForSpecificValue.Removed);
}
}
return(new AddedWithValuesAndRemoved(indexOrder == IndexOrder.DESCENDING ? added.asReversed() : added, removed));
}
