// NOTE: This assumes anyValue is an instance of AnyValue public static AnyValue MaterializeAnyValueResult(EmbeddedProxySPI proxySpi, object anyValue) { if (anyValue is VirtualNodeValue) { if (anyValue is NodeValue) { return(( AnyValue )anyValue); } return(ValueUtils.fromNodeProxy(proxySpi.NewNodeProxy((( VirtualNodeValue )anyValue).id()))); } if (anyValue is VirtualRelationshipValue) { if (anyValue is RelationshipValue) { return(( AnyValue )anyValue); } return(ValueUtils.fromRelationshipProxy(proxySpi.NewRelationshipProxy((( VirtualRelationshipValue )anyValue).id()))); } // If it is a list or map, run it through a ValueMapper that will create proxy objects for entities if needed. // This will first do a dry run and return as it is if no conversion is needed. // If in the future we will always create proxy objects directly whenever we create values we can skip this // Doing this conversion lazily instead, by wrapping with TransformedListValue or TransformedMapValue is probably not a // good idea because of the complexities involved (see TOMBSTONE in VirtualValues about why TransformedListValue was killed). // NOTE: There is also a case where a ListValue can be storable (ArrayValueListValue) where no conversion is needed if ((anyValue is ListValue && !(( ListValue )anyValue).storable()) || anyValue is MapValue) { return(CompiledMaterializeValueMapper.MapAnyValue(proxySpi, ( AnyValue )anyValue)); } return(( AnyValue )anyValue); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private QueryStatusResult(org.neo4j.kernel.api.query.QuerySnapshot query, org.neo4j.kernel.impl.core.EmbeddedProxySPI manager, java.time.ZoneId zoneId) throws org.neo4j.kernel.api.exceptions.InvalidArgumentsException private QueryStatusResult(QuerySnapshot query, EmbeddedProxySPI manager, ZoneId zoneId) { this.QueryId = ofInternalId(query.InternalQueryId()).ToString(); this.Username = query.Username(); this.Query = query.QueryText(); this.Parameters = AsRawMap(query.QueryParameters(), new ParameterWriter(manager)); this.StartTime = formatTime(query.StartTimestampMillis(), zoneId); this.ElapsedTimeMillis = MicrosAsMillis(query.ElapsedTimeMicros()).Value; this.ElapsedTime = formatInterval(ElapsedTimeMillis); ClientConnectionInfo clientConnection = query.ClientConnection(); this.ConnectionDetails = clientConnection.AsConnectionDetails(); this.Protocol = clientConnection.Protocol(); this.ClientAddress = clientConnection.ClientAddress(); this.RequestUri = clientConnection.RequestURI(); this.MetaData = query.TransactionAnnotationData(); this.CpuTimeMillis = MicrosAsMillis(query.CpuTimeMicros()); this.Status = query.Status(); this.ResourceInformation = query.ResourceInformation(); this.ActiveLockCount = query.ActiveLockCount(); this.WaitTimeMillis = MicrosAsMillis(query.WaitTimeMicros()).Value; this.IdleTimeMillis = MicrosAsMillis(query.IdleTimeMicros()); this.Planner = query.Planner(); this.Runtime = query.Runtime(); this.Indexes = query.Indexes(); this.AllocatedBytes = query.AllocatedBytes(); this.PageHits = query.PageHits(); this.PageFaults = query.PageFaults(); this.ConnectionId = clientConnection.ConnectionId(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void start() throws Throwable public override void Start() { // When we have multiple dbs, this has to be suitably modified to get the right kernel and procedures NeoStoreDataSource dataSource = _dataSourceManager.DataSource; EmbeddedProxySPI embeddedProxySPI = dataSource.DependencyResolver.resolveDependency(typeof(EmbeddedProxySPI), Org.Neo4j.Graphdb.DependencyResolver_SelectionStrategy.ONLY); _dataCollectors.Add(DataCollectorModule.setupDataCollector(_procedures, _jobScheduler, dataSource.Kernel, _monitors, new DefaultValueMapper(embeddedProxySPI), _config)); }
public Procedures(EmbeddedProxySPI proxySPI, ThrowingConsumer <Procedures, ProcedureException> builtin, File pluginDir, Log log, ProcedureConfig config) { this._builtin = builtin; this._pluginDir = pluginDir; this._log = log; this._typeMappers = new TypeMappers(proxySPI); this._compiler = new ReflectiveProcedureCompiler(_typeMappers, _safeComponents, _allComponents, log, config); }
private TxStateTransactionDataSnapshot Snapshot() { EmbeddedProxySPI spi = mock(typeof(EmbeddedProxySPI)); when(spi.NewNodeProxy(anyLong())).thenAnswer(invocation => new NodeProxy(spi, invocation.getArgument(0))); when(spi.NewRelationshipProxy(anyLong())).thenAnswer(invocation => new RelationshipProxy(spi, invocation.getArgument(0))); when(spi.NewRelationshipProxy(anyLong(), anyLong(), anyInt(), anyLong())).thenAnswer(invocation => new RelationshipProxy(spi, invocation.getArgument(0), invocation.getArgument(1), invocation.getArgument(2), invocation.getArgument(3))); return(new TxStateTransactionDataSnapshot(_state, spi, _ops, _transaction)); }
/// <param name="proxySPI"> /// the API into the kernel. </param> /// <param name="nodes"> /// the ids of the nodes in the path, in order. </param> /// <param name="relationships"> /// the ids of the relationships in the path, in order. </param> /// <param name="directedTypes"> /// an encoding of the types and directions of the relationships. /// An entry at position {@code i} of this array should be {@code typeId} if the relationship at {@code i} /// has its start node at {@code i} and its end node at {@code i + 1}, and should be {@code ~typeId} if the /// relationship at {@code i} has its start node at {@code i + 1} and its end node at {@code i}. </param> public PathProxy(EmbeddedProxySPI proxySPI, long[] nodes, long[] relationships, int[] directedTypes) { Debug.Assert(nodes.Length == relationships.Length + 1); Debug.Assert(relationships.Length == directedTypes.Length); this._proxySPI = proxySPI; this._nodes = nodes; this._relationships = relationships; this._directedTypes = directedTypes; }
public TxStateTransactionDataSnapshot(ReadableTransactionState state, EmbeddedProxySPI proxySpi, StorageReader storageReader, KernelTransaction transaction) { this._state = state; this._proxySpi = proxySpi; this._store = storageReader; this._transaction = transaction; // Load changes that require store access eagerly, because we won't have access to the after-state // after the tx has been committed. TakeSnapshot(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAccessExampleMetaData() public virtual void ShouldAccessExampleMetaData() { EmbeddedProxySPI spi = mock(typeof(EmbeddedProxySPI)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.api.KernelTransactionImplementation transaction = mock(org.neo4j.kernel.impl.api.KernelTransactionImplementation.class); KernelTransactionImplementation transaction = mock(typeof(KernelTransactionImplementation)); when(transaction.MetaData).thenReturn(genericMap("username", "Igor")); TxStateTransactionDataSnapshot transactionDataSnapshot = new TxStateTransactionDataSnapshot(_state, spi, _ops, transaction); assertEquals(1, transactionDataSnapshot.MetaData().Count); assertThat("Expected metadata map to contain defined username", transactionDataSnapshot.MetaData(), equalTo(genericMap("username", "Igor"))); }
private void VerifyIds(EmbeddedProxySPI actions, long relationshipId, long nodeId1, int typeId, long nodeId2) { RelationshipProxy proxy = new RelationshipProxy(actions, relationshipId, nodeId1, typeId, nodeId2); assertEquals(relationshipId, proxy.Id); // our mock above is known to return RelationshipTypeToken assertEquals(nodeId1, proxy.StartNode.Id); assertEquals(nodeId1, proxy.StartNodeId); assertEquals(nodeId2, proxy.EndNode.Id); assertEquals(nodeId2, proxy.EndNodeId); assertEquals(nodeId2, proxy.GetOtherNode(NodeWithId(nodeId1)).Id); assertEquals(nodeId2, proxy.GetOtherNodeId(nodeId1)); assertEquals(nodeId1, proxy.GetOtherNode(NodeWithId(nodeId2)).Id); assertEquals(nodeId1, proxy.GetOtherNodeId(nodeId2)); }
public virtual Stream <QueryStatusResult> ListQueries() { SecurityContext.assertCredentialsNotExpired(); EmbeddedProxySPI nodeManager = Resolver.resolveDependency(typeof(EmbeddedProxySPI)); ZoneId zoneId = ConfiguredTimeZone; try { //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: return(KernelTransactions.activeTransactions().stream().flatMap(KernelTransactionHandle::executingQueries).filter(query => IsAdminOrSelf(query.username())).map(catchThrown(typeof(InvalidArgumentsException), query => new QueryStatusResult(query, nodeManager, zoneId)))); } catch (UncaughtCheckedException uncaught) { throwIfPresent(uncaught.GetCauseIfOfType(typeof(InvalidArgumentsException))); throw uncaught; } }
public static RelationshipValue MaterializeRelationshipValue(EmbeddedProxySPI proxySpi, object anyValue) { // Null check has to be done outside by the generated code if (anyValue is RelationshipValue) { return(( RelationshipValue )anyValue); } else if (anyValue is VirtualRelationshipValue) { return(ValueUtils.fromRelationshipProxy(proxySpi.NewRelationshipProxy((( VirtualRelationshipValue )anyValue).id()))); } else if (anyValue is Relationship) { return(ValueUtils.fromRelationshipProxy(( Relationship )anyValue)); } //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new System.ArgumentException("Do not know how to materialize relationship value from type " + anyValue.GetType().FullName); }
public static AnyValue MapAnyValue(EmbeddedProxySPI proxySPI, AnyValue value) { // First do a dry run to determine if any conversion will actually be needed, // because if it isn't we can just return the value as it is without having // to recursively rewrite lists and maps, which could be very expensive. // This is based on the assumption that returning full nodes and relationships is a // relatively rare use-case compared to returning a selection of their properties. // Hopefully the dry run will also heat up the caches for the real run, thus reducing its overhead. DryRunMaterializeValueMapper dryRunMapper = new DryRunMaterializeValueMapper(); value.Map(dryRunMapper); if (dryRunMapper.NeedsConversion) { WritingMaterializeValueMapper realMapper = new WritingMaterializeValueMapper(proxySPI); return(value.Map(realMapper)); } return(value); }
//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() { EmbeddedProxySPI manager = mock(typeof(EmbeddedProxySPI)); when(manager.NewNodeProxy(anyLong())).thenAnswer(invocationOnMock => { long id = invocationOnMock.getArgument(0); NodeProxy mock = mock(typeof(NodeProxy)); when(mock.Id).thenReturn(id); return(mock); }); when(manager.NewRelationshipProxy(anyLong())).thenAnswer(invocationOnMock => { long id = invocationOnMock.getArgument(0); RelationshipProxy mock = mock(typeof(RelationshipProxy)); when(mock.Id).thenReturn(id); return(mock); }); _converter = new ParameterConverter(manager); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldBeAbleToReferToIdsBeyondMaxInt() public virtual void ShouldBeAbleToReferToIdsBeyondMaxInt() { // GIVEN EmbeddedProxySPI actions = mock(typeof(EmbeddedProxySPI)); when(actions.NewNodeProxy(anyLong())).then(invocation => NodeWithId(invocation.getArgument(0))); when(actions.GetRelationshipTypeById(anyInt())).then(invocation => new NamedToken("whatever", invocation.getArgument(0))); long[] ids = new long[] { 1437589437, 2047587483, 2147496246L, 2147342921, 3276473721L, 4762746373L, 57587348738L, 59892898932L }; int[] types = new int[] { 0, 10, 101, 3024, 20123, 45008 }; // WHEN/THEN for (int i = 0; i < ids.Length - 2; i++) { long id = ids[i]; long nodeId1 = ids[i + 1]; long nodeId2 = ids[i + 2]; int type = types[i]; VerifyIds(actions, id, nodeId1, type, nodeId2); VerifyIds(actions, id, nodeId2, type, nodeId1); } }
public TypeMappers(EmbeddedProxySPI proxySPI) : base(proxySPI) { RegisterScalarsAndCollections(); }
internal WritingMaterializeValueMapper(EmbeddedProxySPI proxySpi) { this.ProxySpi = proxySpi; }
public GraphPropertiesProxy(EmbeddedProxySPI actions) { this._actions = actions; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings({"unchecked", "WeakerAccess"}) public static org.neo4j.values.AnyValue materializeAnyResult(org.neo4j.kernel.impl.core.EmbeddedProxySPI proxySpi, Object anyValue) public static AnyValue MaterializeAnyResult(EmbeddedProxySPI proxySpi, object anyValue) { if (anyValue == null || anyValue == NO_VALUE) { return(NO_VALUE); } else if (anyValue is AnyValue) { return(MaterializeAnyValueResult(proxySpi, anyValue)); } else if (anyValue is System.Collections.IList) { return(VirtualValues.fromList((IList <AnyValue>)(((System.Collections.IList)anyValue).Select(v => MaterializeAnyResult(proxySpi, v)).ToList()))); } else if (anyValue is System.Collections.IDictionary) { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<String,?> incoming = (java.util.Map<String,?>) anyValue; IDictionary <string, ?> incoming = (IDictionary <string, ?>)anyValue; MapValueBuilder builder = new MapValueBuilder(incoming.Count); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (java.util.Map.Entry<String,?> entry : incoming.entrySet()) foreach (KeyValuePair <string, ?> entry in incoming.SetOfKeyValuePairs()) { builder.Add(entry.Key, MaterializeAnyResult(proxySpi, entry.Value)); } return(builder.Build()); } else if (anyValue is PrimitiveNodeStream) { return(VirtualValues.fromList((( PrimitiveNodeStream )anyValue).LongStream().mapToObj(id => (AnyValue)ValueUtils.fromNodeProxy(proxySpi.NewNodeProxy(id))).collect(Collectors.toList()))); } else if (anyValue is PrimitiveRelationshipStream) { return(VirtualValues.fromList((( PrimitiveRelationshipStream )anyValue).LongStream().mapToObj(id => (AnyValue)ValueUtils.fromRelationshipProxy(proxySpi.NewRelationshipProxy(id))).collect(Collectors.toList()))); } else if (anyValue is LongStream) { long[] array = (( LongStream )anyValue).toArray(); return(Values.longArray(array)); } else if (anyValue is DoubleStream) { double[] array = (( DoubleStream )anyValue).toArray(); return(Values.doubleArray(array)); } else if (anyValue is IntStream) { // IntStream is only used for list of primitive booleans return(VirtualValues.fromList((( IntStream )anyValue).mapToObj(i => Values.booleanValue(i != 0)).collect(Collectors.toList()))); } else if (anyValue.GetType().IsArray) { Type componentType = anyValue.GetType().GetElementType(); int length = Array.getLength(anyValue); if (componentType.IsPrimitive) { object copy = Array.CreateInstance(componentType, length); //noinspection SuspiciousSystemArraycopy Array.Copy(anyValue, 0, copy, 0, length); return(ValueUtils.of(copy)); } else if (anyValue is string[]) { return(Values.stringArray(( string[] )anyValue)); } else { AnyValue[] copy = new AnyValue[length]; for (int i = 0; i < length; i++) { copy[i] = MaterializeAnyResult(proxySpi, Array.get(anyValue, i)); } return(VirtualValues.list(copy)); } } else { return(ValueUtils.of(anyValue)); } }
internal ParameterConverter(EmbeddedProxySPI proxySpi) { this._proxySpi = proxySpi; _stack.push(new ObjectWriter()); }
public NodeProxy(EmbeddedProxySPI spi, long nodeId) { this._nodeId = nodeId; this._spi = spi; }
internal ParameterWriter(EmbeddedProxySPI nodeManager) { this.NodeManager = nodeManager; }
public DefaultValueMapper(EmbeddedProxySPI proxySPI) { this._proxySPI = proxySPI; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: QueryStatusResult(org.neo4j.kernel.api.query.ExecutingQuery query, org.neo4j.kernel.impl.core.EmbeddedProxySPI manager, java.time.ZoneId zoneId) throws org.neo4j.kernel.api.exceptions.InvalidArgumentsException internal QueryStatusResult(ExecutingQuery query, EmbeddedProxySPI manager, ZoneId zoneId) : this(query.Snapshot(), manager, zoneId) { }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUp() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void SetUp() { _proxySPI = mock(typeof(EmbeddedProxySPI)); }
public RelationshipProxy(EmbeddedProxySPI spi, long id, long startNode, int type, long endNode) { this._spi = spi; Visit(id, type, startNode, endNode); }
public RelationshipProxy(EmbeddedProxySPI spi, long id) { this._spi = spi; this._id = id; }
public TransactionEventHandlers(EmbeddedProxySPI spi) { this._proxySpi = spi; }