private void ShowRelCounts(KernelTransaction ktx, DbStructureVisitor visitor)
{
// all wildcards
NoSide(ktx, visitor, _wildcardRelType, ANY_RELATIONSHIP_TYPE);
TokenRead tokenRead = ktx.TokenRead();
// one label only
foreach (Label label in _db.AllLabels)
{
int labelId = tokenRead.NodeLabel(label.Name());
LeftSide(ktx, visitor, label, labelId, _wildcardRelType, ANY_RELATIONSHIP_TYPE);
RightSide(ktx, visitor, label, labelId, _wildcardRelType, ANY_RELATIONSHIP_TYPE);
}
// fixed rel type
foreach (RelationshipType relType in _db.AllRelationshipTypes)
{
int relTypeId = tokenRead.RelationshipType(relType.Name());
NoSide(ktx, visitor, relType, relTypeId);
foreach (Label label in _db.AllLabels)
{
int labelId = tokenRead.NodeLabel(label.Name());
// wildcard on right
LeftSide(ktx, visitor, label, labelId, relType, relTypeId);
// wildcard on left
RightSide(ktx, visitor, label, labelId, relType, relTypeId);
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void batchInserterShouldUseConfiguredIndexProvider() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void BatchInserterShouldUseConfiguredIndexProvider()
{
Config config = Config.defaults(stringMap(default_schema_provider.name(), _schemaIndex.providerName()));
BatchInserter inserter = NewBatchInserter(config);
inserter.CreateDeferredSchemaIndex(TestLabels.LABEL_ONE).on("key").create();
inserter.Shutdown();
GraphDatabaseService db = GraphDatabaseService(config);
AwaitIndexesOnline(db);
try
{
using (Transaction tx = Db.beginTx())
{
DependencyResolver dependencyResolver = (( GraphDatabaseAPI )db).DependencyResolver;
ThreadToStatementContextBridge threadToStatementContextBridge = dependencyResolver.ResolveDependency(typeof(ThreadToStatementContextBridge));
KernelTransaction kernelTransaction = threadToStatementContextBridge.GetKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = kernelTransaction.TokenRead();
SchemaRead schemaRead = kernelTransaction.SchemaRead();
int labelId = tokenRead.NodeLabel(TestLabels.LABEL_ONE.name());
int propertyId = tokenRead.PropertyKey("key");
IndexReference index = schemaRead.Index(labelId, propertyId);
assertTrue(UnexpectedIndexProviderMessage(index), _schemaIndex.providerName().contains(index.ProviderKey()));
assertTrue(UnexpectedIndexProviderMessage(index), _schemaIndex.providerName().contains(index.ProviderVersion()));
tx.Success();
}
}
finally
{
Db.shutdown();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static java.util.List<java.util.Map<String,Object>> indexes(org.neo4j.internal.kernel.api.TokenRead tokens, org.neo4j.internal.kernel.api.SchemaRead schemaRead, Anonymizer anonymizer) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
private static IList <IDictionary <string, object> > Indexes(TokenRead tokens, SchemaRead schemaRead, Anonymizer anonymizer)
{
IList <IDictionary <string, object> > indexes = new List <IDictionary <string, object> >();
SilentTokenNameLookup tokenLookup = new SilentTokenNameLookup(tokens);
IEnumerator <IndexReference> iterator = schemaRead.IndexesGetAll();
while (iterator.MoveNext())
{
IndexReference index = iterator.Current;
IDictionary <string, object> data = new Dictionary <string, object>();
data["labels"] = Map(index.Schema().EntityTokenIds, id => anonymizer.Label(tokenLookup.LabelGetName(id), id));
data["properties"] = Map(index.Schema().PropertyIds, id => anonymizer.PropertyKey(tokenLookup.PropertyKeyGetName(id), id));
Org.Neo4j.Register.Register_DoubleLongRegister register = Registers.newDoubleLongRegister();
schemaRead.IndexUpdatesAndSize(index, register);
data["totalSize"] = register.ReadSecond();
data["updatesSinceEstimation"] = register.ReadFirst();
schemaRead.IndexSample(index, register);
data["estimatedUniqueSize"] = register.ReadFirst();
indexes.Add(data);
}
return(indexes);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private org.neo4j.graphdb.schema.IndexDefinition descriptorToDefinition(final org.neo4j.internal.kernel.api.TokenRead tokenRead, org.neo4j.internal.kernel.api.IndexReference index)
private IndexDefinition DescriptorToDefinition(TokenRead tokenRead, IndexReference index)
{
try
{
SchemaDescriptor schema = index.Schema();
int[] entityTokenIds = Schema.EntityTokenIds;
bool constraintIndex = index.Unique;
string[] propertyNames = PropertyNameUtils.GetPropertyKeys(tokenRead, index.Properties());
switch (Schema.entityType())
{
case NODE:
Label[] labels = new Label[entityTokenIds.Length];
for (int i = 0; i < labels.Length; i++)
{
labels[i] = label(tokenRead.NodeLabelName(entityTokenIds[i]));
}
return(new IndexDefinitionImpl(_actions, index, labels, propertyNames, constraintIndex));
case RELATIONSHIP:
RelationshipType[] relTypes = new RelationshipType[entityTokenIds.Length];
for (int i = 0; i < relTypes.Length; i++)
{
relTypes[i] = withName(tokenRead.RelationshipTypeName(entityTokenIds[i]));
}
return(new IndexDefinitionImpl(_actions, index, relTypes, propertyNames, constraintIndex));
default:
throw new System.ArgumentException("Cannot create IndexDefinition for " + Schema.entityType() + " entity-typed schema.");
}
}
catch (KernelException e)
{
throw new Exception(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void addingANodeWithPropertyShouldGetIndexed() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AddingANodeWithPropertyShouldGetIndexed()
{
// Given
string indexProperty = "indexProperty";
GatheringIndexWriter writer = NewWriter();
createIndex(_db, _myLabel, indexProperty);
// When
int value1 = 12;
string otherProperty = "otherProperty";
int otherValue = 17;
Node node = CreateNode(map(indexProperty, value1, otherProperty, otherValue), _myLabel);
// Then, for now, this should trigger two NodePropertyUpdates
using (Transaction tx = _db.beginTx())
{
KernelTransaction ktx = _ctxSupplier.getKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = ktx.TokenRead();
int propertyKey1 = tokenRead.PropertyKey(indexProperty);
int label = tokenRead.NodeLabel(_myLabel.name());
LabelSchemaDescriptor descriptor = SchemaDescriptorFactory.forLabel(label, propertyKey1);
assertThat(writer.UpdatesCommitted, equalTo(asSet(IndexEntryUpdate.add(node.Id, descriptor, Values.of(value1)))));
tx.Success();
}
// We get two updates because we both add a label and a property to be indexed
// in the same transaction, in the future, we should optimize this down to
// one NodePropertyUpdate.
}
private void OnTokenRead(uint tokenId)
{
lock (this.syncLock)
{
var invocationTime = DateTime.Now;
try
{
if ((invocationTime - lastPublishTime) >= this.deadPeriod)
{
var tokenIdHash = hasher.ComputeHash(BitConverter.GetBytes(tokenId));
var formattedTokenIdHash = BitConverter.ToString(tokenIdHash).Replace("-", String.Empty);
this.logger.Debug($"Relaying token {tokenId} as {formattedTokenIdHash}.");
var message = new TokenRead(formattedTokenIdHash);
var forget = this.messagingClient.Publish(message);
lastPublishTime = invocationTime;
}
}
catch (Exception ex)
{
this.logger.Error(ex);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static String[] getPropertyKeys(org.neo4j.internal.kernel.api.TokenRead tokenRead, int...properties) throws org.neo4j.internal.kernel.api.exceptions.PropertyKeyIdNotFoundKernelException
public static string[] GetPropertyKeys(TokenRead tokenRead, params int[] properties)
{
string[] propertyKeys = new string[properties.Length];
for (int i = 0; i < properties.Length; i++)
{
propertyKeys[i] = tokenRead.PropertyKeyName(properties[i]);
}
return(propertyKeys);
}
internal SchemaCalculator(Transaction ktx)
{
this._dataRead = ktx.DataRead();
this._tokenRead = ktx.TokenRead();
this._cursors = ktx.Cursors();
// the only one that is common for both nodes and rels so thats why we can do it here
_propertyIdToPropertyNameMapping = new Dictionary <int, string>(_tokenRead.propertyKeyCount());
AddNamesToCollection(_tokenRead.propertyKeyGetAllTokens(), _propertyIdToPropertyNameMapping);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.internal.kernel.api.IndexReference getIndexReference(org.neo4j.internal.kernel.api.SchemaRead schemaRead, org.neo4j.internal.kernel.api.TokenRead tokenRead, IndexDefinitionImpl index) throws org.neo4j.kernel.api.exceptions.schema.SchemaRuleNotFoundException
private static IndexReference GetIndexReference(SchemaRead schemaRead, TokenRead tokenRead, IndexDefinitionImpl index)
{
// Use the precise embedded index reference when available.
IndexReference reference = index.IndexReference;
if (reference != null)
{
return(reference);
}
// Otherwise attempt to reverse engineer the schema that will let us look up the real IndexReference.
int[] propertyKeyIds = ResolveAndValidatePropertyKeys(tokenRead, index.PropertyKeysArrayShared);
SchemaDescriptor schema;
if (index.NodeIndex)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
int[] labelIds = ResolveAndValidateTokens("Label", index.LabelArrayShared, Label::name, tokenRead.nodeLabel);
if (index.MultiTokenIndex)
{
schema = multiToken(labelIds, EntityType.NODE, propertyKeyIds);
}
else
{
schema = forLabel(labelIds[0], propertyKeyIds);
}
}
else if (index.RelationshipIndex)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
int[] relTypes = ResolveAndValidateTokens("Relationship type", index.RelationshipTypesArrayShared, RelationshipType::name, tokenRead.relationshipType);
if (index.MultiTokenIndex)
{
schema = multiToken(relTypes, EntityType.RELATIONSHIP, propertyKeyIds);
}
else
{
schema = forRelType(relTypes[0], propertyKeyIds);
}
}
else
{
throw new System.ArgumentException("The given index is neither a node index, nor a relationship index: " + index + ".");
}
reference = schemaRead.Index(schema);
if (reference == IndexReference.NO_INDEX)
{
throw new SchemaRuleNotFoundException(Org.Neo4j.Storageengine.Api.schema.SchemaRule_Kind.IndexRule, schema);
}
return(reference);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static void putTokenCounts(java.util.Map<String,Object> metaData, org.neo4j.internal.kernel.api.Kernel kernel) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException
internal static void PutTokenCounts(IDictionary <string, object> metaData, Kernel kernel)
{
using (Transaction tx = kernel.BeginTransaction([email protected]_Type.Explicit, LoginContext.AUTH_DISABLED))
{
TokenRead tokens = tx.TokenRead();
metaData["labelCount"] = tokens.LabelCount();
metaData["relationshipTypeCount"] = tokens.RelationshipTypeCount();
metaData["propertyKeyCount"] = tokens.PropertyKeyCount();
tx.Success();
}
}
private void AssertCorrectProvider(GraphDatabaseAPI db, Label label, string property)
{
KernelTransaction kernelTransaction = Db.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(false);
TokenRead tokenRead = kernelTransaction.TokenRead();
int labelId = tokenRead.NodeLabel(label.Name());
int propId = tokenRead.PropertyKey(property);
SchemaRead schemaRead = kernelTransaction.SchemaRead();
IndexReference index = schemaRead.Index(labelId, propId);
assertEquals("correct provider key", "lucene+native", index.ProviderKey());
assertEquals("correct provider version", "1.0", index.ProviderVersion());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void Setup()
{
_transaction = mock(typeof(KernelTransaction));
_tokenRead = mock(typeof(TokenRead));
_schemaRead = mock(typeof(SchemaRead));
_procedure = new IndexProcedures(_transaction, null);
_descriptor = SchemaDescriptorFactory.forLabel(123, 456);
_anyDescriptor = SchemaDescriptorFactory.forLabel(0, 0);
_anyIndex = forSchema(_anyDescriptor);
when(_transaction.tokenRead()).thenReturn(_tokenRead);
when(_transaction.schemaRead()).thenReturn(_schemaRead);
}
private void RelayTokenReadMessage(Object sender, TokenRead message)
{
try
{
this.logger.Debug($"Relaying {nameof(TokenRead)} message: {message.Id}");
this.callBack?.OnTokenReadPublished(message);
}
catch (Exception exception)
{
this.logger.Error(exception);
}
}
public override IDictionary <string, object> GetProperties(params string[] keys)
{
Objects.requireNonNull(keys, "Properties keys should be not null array.");
if (keys.Length == 0)
{
return(Collections.emptyMap());
}
KernelTransaction transaction = SafeAcquireTransaction();
int itemsToReturn = keys.Length;
IDictionary <string, object> properties = new Dictionary <string, object>(itemsToReturn);
TokenRead token = transaction.TokenRead();
//Find ids, note we are betting on that the number of keys
//is small enough not to use a set here.
int[] propertyIds = new int[itemsToReturn];
for (int i = 0; i < itemsToReturn; i++)
{
string key = keys[i];
if (string.ReferenceEquals(key, null))
{
throw new System.NullReferenceException(string.Format("Key {0:D} was null", i));
}
propertyIds[i] = token.PropertyKey(key);
}
NodeCursor nodes = transaction.AmbientNodeCursor();
PropertyCursor propertyCursor = transaction.AmbientPropertyCursor();
SingleNode(transaction, nodes);
nodes.Properties(propertyCursor);
int propertiesToFind = itemsToReturn;
while (propertiesToFind > 0 && propertyCursor.Next())
{
//Do a linear check if this is a property we are interested in.
int currentKey = propertyCursor.PropertyKey();
for (int i = 0; i < itemsToReturn; i++)
{
if (propertyIds[i] == currentKey)
{
properties[keys[i]] = propertyCursor.PropertyValue().asObjectCopy();
propertiesToFind--;
break;
}
}
}
return(properties);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static java.util.stream.Stream<RetrieveResult> retrieve(org.neo4j.internal.kernel.api.Kernel kernel, Anonymizer anonymizer) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException, org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
internal static Stream <RetrieveResult> Retrieve(Kernel kernel, Anonymizer anonymizer)
{
using (Transaction tx = kernel.BeginTransaction([email protected]_Type.Explicit, LoginContext.AUTH_DISABLED))
{
TokenRead tokens = tx.TokenRead();
Read read = tx.DataRead();
IDictionary <string, object> data = new Dictionary <string, object>();
data["nodes"] = NodeCounts(tokens, read, anonymizer);
data["relationships"] = RelationshipCounts(tokens, read, anonymizer);
data["indexes"] = Indexes(tokens, tx.SchemaRead(), anonymizer);
data["constraints"] = Constraints(tokens, tx.SchemaRead(), anonymizer);
return(Stream.of(new RetrieveResult(Sections.GRAPH_COUNTS, data)));
}
}
private IDictionary <string, int> GetLabelIdsByName(params string[] names)
{
ThreadToStatementContextBridge transactionStatementContextBridge = TransactionStatementContextBridge;
IDictionary <string, int> labelNameIdMap = new Dictionary <string, int>();
KernelTransaction ktx = transactionStatementContextBridge.GetKernelTransactionBoundToThisThread(true);
using (Statement ignore = ktx.AcquireStatement())
{
TokenRead tokenRead = ktx.TokenRead();
foreach (string name in names)
{
labelNameIdMap[name] = tokenRead.NodeLabel(name);
}
}
return(labelNameIdMap);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertIndexProvider(org.neo4j.graphdb.GraphDatabaseService db, String expectedProviderIdentifier) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
private void AssertIndexProvider(GraphDatabaseService db, string expectedProviderIdentifier)
{
GraphDatabaseAPI graphDatabaseAPI = ( GraphDatabaseAPI )db;
using (Transaction tx = graphDatabaseAPI.BeginTx())
{
KernelTransaction ktx = graphDatabaseAPI.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = ktx.TokenRead();
int labelId = tokenRead.NodeLabel(LABEL.name());
int propertyId = tokenRead.PropertyKey(KEY);
IndexReference index = ktx.SchemaRead().index(labelId, propertyId);
assertEquals("expected IndexProvider.Descriptor", expectedProviderIdentifier, (new IndexProviderDescriptor(index.ProviderKey(), index.ProviderVersion())).name());
tx.Success();
}
}
public virtual IEnumerable <ConstraintDefinition> getConstraints(RelationshipType type)
{
KernelTransaction transaction = SafeAcquireTransaction(_transactionSupplier);
using (Statement ignore = transaction.AcquireStatement())
{
TokenRead tokenRead = transaction.TokenRead();
SchemaRead schemaRead = transaction.SchemaRead();
int typeId = tokenRead.RelationshipType(type.Name());
if (typeId == [email protected]_Fields.NO_TOKEN)
{
return(emptyList());
}
return(AsConstraintDefinitions(schemaRead.ConstraintsGetForRelationshipType(typeId), tokenRead));
}
}
private static IList <IDictionary <string, object> > NodeCounts(TokenRead tokens, Read read, Anonymizer anonymizer)
{
IList <IDictionary <string, object> > nodeCounts = new List <IDictionary <string, object> >();
IDictionary <string, object> nodeCount = new Dictionary <string, object>();
nodeCount["count"] = read.CountsForNodeWithoutTxState(-1);
nodeCounts.Add(nodeCount);
tokens.LabelsGetAllTokens().forEachRemaining(t =>
{
long count = read.CountsForNodeWithoutTxState(t.id());
IDictionary <string, object> labelCount = new Dictionary <string, object>();
labelCount.put("label", anonymizer.Label(t.name(), t.id()));
labelCount.put("count", count);
nodeCounts.Add(labelCount);
});
return(nodeCounts);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public Iterable<org.neo4j.graphdb.schema.IndexDefinition> getIndexes(final org.neo4j.graphdb.Label label)
public override IEnumerable <IndexDefinition> GetIndexes(Label label)
{
KernelTransaction transaction = _transactionSupplier.get();
using (Statement ignore = transaction.AcquireStatement())
{
TokenRead tokenRead = transaction.TokenRead();
SchemaRead schemaRead = transaction.SchemaRead();
IList <IndexDefinition> definitions = new List <IndexDefinition>();
int labelId = tokenRead.NodeLabel(label.Name());
if (labelId == [email protected]_Fields.NO_TOKEN)
{
return(emptyList());
}
IEnumerator <IndexReference> indexes = schemaRead.IndexesGetForLabel(labelId);
AddDefinitions(definitions, tokenRead, IndexReference.sortByType(indexes));
return(definitions);
}
}
private static IList <IDictionary <string, object> > RelationshipCounts(TokenRead tokens, Read read, Anonymizer anonymizer)
{
IList <IDictionary <string, object> > relationshipCounts = new List <IDictionary <string, object> >();
IDictionary <string, object> relationshipCount = new Dictionary <string, object>();
relationshipCount["count"] = read.CountsForRelationshipWithoutTxState(-1, -1, -1);
relationshipCounts.Add(relationshipCount);
IList <NamedToken> labels = Iterators.asList(tokens.LabelsGetAllTokens());
tokens.RelationshipTypesGetAllTokens().forEachRemaining(t =>
{
long count = read.CountsForRelationshipWithoutTxState(-1, t.id(), -1);
IDictionary <string, object> relationshipTypeCount = new Dictionary <string, object>();
relationshipTypeCount.put("relationshipType", anonymizer.RelationshipType(t.name(), t.id()));
relationshipTypeCount.put("count", count);
relationshipCounts.Add(relationshipTypeCount);
foreach (NamedToken label in labels)
{
long startCount = read.CountsForRelationshipWithoutTxState(label.id(), t.id(), -1);
if (startCount > 0)
{
IDictionary <string, object> x = new Dictionary <string, object>();
x.put("relationshipType", anonymizer.RelationshipType(t.name(), t.id()));
x.put("startLabel", anonymizer.Label(label.name(), label.id()));
x.put("count", startCount);
relationshipCounts.Add(x);
}
long endCount = read.CountsForRelationshipWithoutTxState(-1, t.id(), label.id());
if (endCount > 0)
{
IDictionary <string, object> x = new Dictionary <string, object>();
x.put("relationshipType", anonymizer.RelationshipType(t.name(), t.id()));
x.put("endLabel", anonymizer.Label(label.name(), label.id()));
x.put("count", endCount);
relationshipCounts.Add(x);
}
}
});
return(relationshipCounts);
}
private int[] RelTypeIds(RelationshipType[] types, TokenRead token)
{
int[] ids = new int[types.Length];
int outIndex = 0;
foreach (RelationshipType type in types)
{
int id = token.RelationshipType(type.Name());
if (id != NO_SUCH_RELATIONSHIP_TYPE)
{
ids[outIndex++] = id;
}
}
if (outIndex != ids.Length)
{
// One or more relationship types do not exist, so we can exclude them right away.
ids = Arrays.copyOf(ids, outIndex);
}
return(ids);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static java.util.stream.Stream<RetrieveResult> retrieve(org.neo4j.internal.kernel.api.Kernel kernel) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException
internal static Stream <RetrieveResult> Retrieve(Kernel kernel)
{
using (Transaction tx = kernel.BeginTransaction([email protected]_Type.Explicit, LoginContext.AUTH_DISABLED))
{
TokenRead tokens = tx.TokenRead();
IList <string> labels = new List <string>(tokens.LabelCount());
tokens.LabelsGetAllTokens().forEachRemaining(t => labels.Add(t.name()));
IList <string> relationshipTypes = new List <string>(tokens.RelationshipTypeCount());
tokens.RelationshipTypesGetAllTokens().forEachRemaining(t => relationshipTypes.Add(t.name()));
IList <string> propertyKeys = new List <string>(tokens.PropertyKeyCount());
tokens.PropertyKeyGetAllTokens().forEachRemaining(t => propertyKeys.Add(t.name()));
IDictionary <string, object> data = new Dictionary <string, object>();
data["labels"] = labels;
data["relationshipTypes"] = relationshipTypes;
data["propertyKeys"] = propertyKeys;
return(Stream.of(new RetrieveResult(Sections.TOKENS, data)));
}
}
public async void Handle(TokenRead message)
{
// TODO: Play success beep
try
{
if (this.navigationService.CurrentSourcePageType != typeof(StartView))
{
this.toastService.Show("A fob was read and ignored.", "To sign-in with it go BACK to the first screen and try again.");
}
else
{
var tokenHolder = await this.tokenHolderService.GetTokenHolderByTokenId(message.Id);
if (tokenHolder == null)
{
this.navigationService.NavigateToViewModel <NameEntryViewModel>(message.Id);
}
else
{
SignedInRecord signedInRecord;
if (this.signInService.TryGetSignedInRecord(tokenHolder.TokenId, out signedInRecord))
{
await this.signInService.RequestSignOut(signedInRecord);
}
else
{
await this.signInService.RequestSignIn(tokenHolder);
}
}
}
}
catch (Exception e)
{
// TODO: log error
this.toastService.ShowGenericError();
}
}
public override void DropNodePropertyExistenceConstraint(Label label, string[] properties)
{
KernelTransaction transaction = SafeAcquireTransaction(TransactionSupplier);
using (Statement ignore = transaction.AcquireStatement())
{
try
{
TokenRead tokenRead = transaction.TokenRead();
int labelId = tokenRead.NodeLabel(label.Name());
int[] propertyKeyIds = ResolveAndValidatePropertyKeys(tokenRead, properties);
transaction.SchemaWrite().constraintDrop(ConstraintDescriptorFactory.existsForLabel(labelId, propertyKeyIds));
}
catch (DropConstraintFailureException e)
{
throw new ConstraintViolationException(e.GetUserMessage(new SilentTokenNameLookup(transaction.TokenRead())), e);
}
catch (Exception e) when(e is InvalidTransactionTypeKernelException || e is SchemaKernelException)
{
throw new ConstraintViolationException(e.Message, e);
}
}
}
private static IList <IDictionary <string, object> > Constraints(TokenRead tokens, SchemaRead schemaRead, Anonymizer anonymizer)
{
IList <IDictionary <string, object> > constraints = new List <IDictionary <string, object> >();
SilentTokenNameLookup tokenLookup = new SilentTokenNameLookup(tokens);
IEnumerator <ConstraintDescriptor> iterator = schemaRead.ConstraintsGetAll();
while (iterator.MoveNext())
{
ConstraintDescriptor constraint = iterator.Current;
EntityType entityType = constraint.Schema().entityType();
IDictionary <string, object> data = new Dictionary <string, object>();
data["properties"] = Map(constraint.Schema().PropertyIds, id => anonymizer.PropertyKey(tokenLookup.PropertyKeyGetName(id), id));
data["type"] = ConstraintType(constraint);
int entityTokenId = constraint.Schema().EntityTokenIds[0];
switch (entityType.innerEnumValue)
{
case EntityType.InnerEnum.NODE:
data["label"] = anonymizer.Label(tokenLookup.LabelGetName(entityTokenId), entityTokenId);
constraints.Add(data);
break;
case EntityType.InnerEnum.RELATIONSHIP:
data["relationshipType"] = anonymizer.RelationshipType(tokenLookup.RelationshipTypeGetName(entityTokenId), entityTokenId);
constraints.Add(data);
break;
default:
break;
}
}
return(constraints);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void addingALabelToPreExistingNodeShouldGetIndexed() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AddingALabelToPreExistingNodeShouldGetIndexed()
{
// GIVEN
string indexProperty = "indexProperty";
GatheringIndexWriter writer = NewWriter();
createIndex(_db, _myLabel, indexProperty);
// WHEN
string otherProperty = "otherProperty";
int value = 12;
int otherValue = 17;
Node node = CreateNode(map(indexProperty, value, otherProperty, otherValue));
// THEN
assertThat(writer.UpdatesCommitted.Count, equalTo(0));
// AND WHEN
using (Transaction tx = _db.beginTx())
{
node.AddLabel(_myLabel);
tx.Success();
}
// THEN
using (Transaction tx = _db.beginTx())
{
KernelTransaction ktx = _ctxSupplier.getKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = ktx.TokenRead();
int propertyKey1 = tokenRead.PropertyKey(indexProperty);
int label = tokenRead.NodeLabel(_myLabel.name());
LabelSchemaDescriptor descriptor = SchemaDescriptorFactory.forLabel(label, propertyKey1);
assertThat(writer.UpdatesCommitted, equalTo(asSet(IndexEntryUpdate.add(node.Id, descriptor, Values.of(value)))));
tx.Success();
}
}
public override void DropRelationshipPropertyExistenceConstraint(RelationshipType type, string propertyKey)
{
KernelTransaction transaction = SafeAcquireTransaction(TransactionSupplier);
using (Statement ignore = transaction.AcquireStatement())
{
try
{
TokenRead tokenRead = transaction.TokenRead();
int typeId = tokenRead.RelationshipType(type.Name());
int propertyKeyId = tokenRead.PropertyKey(propertyKey);
transaction.SchemaWrite().constraintDrop(ConstraintDescriptorFactory.existsForRelType(typeId, propertyKeyId));
}
catch (DropConstraintFailureException e)
{
throw new ConstraintViolationException(e.GetUserMessage(new SilentTokenNameLookup(transaction.TokenRead())), e);
}
catch (Exception e) when(e is InvalidTransactionTypeKernelException || e is SchemaKernelException)
{
throw new ConstraintViolationException(e.Message, e);
}
}
}
public async void OnTokenReadPublished(TokenRead message)
{
await this.eventAggregator.PublishOnUIThreadAsync(message);
}
private ConstraintDefinition AsConstraintDefinition(ConstraintDescriptor constraint, TokenRead tokenRead)
{
// This was turned inside out. Previously a low-level constraint object would reference a public enum type
// which made it impossible to break out the low-level component from kernel. There could be a lower level
// constraint type introduced to mimic the public ConstraintType, but that would be a duplicate of it
// essentially. Checking instanceof here is OKish since the objects it checks here are part of the
// internal storage engine API.
SilentTokenNameLookup lookup = new SilentTokenNameLookup(tokenRead);
if (constraint is NodeExistenceConstraintDescriptor || constraint is NodeKeyConstraintDescriptor || constraint is UniquenessConstraintDescriptor)
{
SchemaDescriptor schemaDescriptor = constraint.Schema();
int[] entityTokenIds = schemaDescriptor.EntityTokenIds;
Label[] labels = new Label[entityTokenIds.Length];
for (int i = 0; i < entityTokenIds.Length; i++)
{
labels[i] = label(lookup.LabelGetName(entityTokenIds[i]));
}
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
string[] propertyKeys = Arrays.stream(schemaDescriptor.PropertyIds).mapToObj(lookup.propertyKeyGetName).toArray(string[] ::new);
if (constraint is NodeExistenceConstraintDescriptor)
{
return(new NodePropertyExistenceConstraintDefinition(_actions, labels[0], propertyKeys));
}
else if (constraint is UniquenessConstraintDescriptor)
{
return(new UniquenessConstraintDefinition(_actions, new IndexDefinitionImpl(_actions, null, labels, propertyKeys, true)));
}
else
{
return(new NodeKeyConstraintDefinition(_actions, new IndexDefinitionImpl(_actions, null, labels, propertyKeys, true)));
}
}
else if (constraint is RelExistenceConstraintDescriptor)
{
RelationTypeSchemaDescriptor descriptor = ( RelationTypeSchemaDescriptor )constraint.Schema();
return(new RelationshipPropertyExistenceConstraintDefinition(_actions, withName(lookup.RelationshipTypeGetName(descriptor.RelTypeId)), lookup.PropertyKeyGetName(descriptor.PropertyId)));
}
throw new System.ArgumentException("Unknown constraint " + constraint);
}
