예제 #1
0
        public virtual Stream <NodeResult> CreateNodeWithLoop(string label, string relType)
        {
            Node node = Db.createNode(Label.label(label));

            node.CreateRelationshipTo(node, RelationshipType.withName(relType));
            return(Stream.of(new NodeResult(node)));
        }
예제 #2
0
        private void CreateSomeTransactions(GraphDatabaseService db)
        {
            Transaction tx    = Db.beginTx();
            Node        node1 = Db.createNode();
            Node        node2 = Db.createNode();

            node1.CreateRelationshipTo(node2, RelationshipType.withName("relType1"));
            tx.Success();
            tx.Close();

            tx = Db.beginTx();
            node1.Delete();
            tx.Success();
            try
            {
                // Will throw exception, causing the tx to be rolledback.
                tx.Close();
            }
            catch (Exception)
            {
                // InvalidRecordException coming, node1 has rels
            }

            /*
             *  The damage has already been done. The following just makes sure
             *  the corrupting tx is flushed to disk, since we will exit
             *  uncleanly.
             */
            tx = Db.beginTx();
            node1.SetProperty("foo", "bar");
            tx.Success();
            tx.Close();
        }
예제 #3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testRemoveRelationshipRemovesDocument()
        public virtual void TestRemoveRelationshipRemovesDocument()
        {
            NewTransaction();
            AutoIndexer <Relationship> autoIndexer = _graphDb.index().RelationshipAutoIndexer;

            autoIndexer.StartAutoIndexingProperty("foo");
            autoIndexer.Enabled = true;

            Node         node1 = _graphDb.createNode();
            Node         node2 = _graphDb.createNode();
            Relationship rel   = node1.CreateRelationshipTo(node2, RelationshipType.withName("foo"));

            rel.SetProperty("foo", "bar");

            NewTransaction();

            using (IndexHits <Relationship> relationshipIndexHits = _graphDb.index().forRelationships("relationship_auto_index").query("_id_:*"))
            {
                assertThat(relationshipIndexHits.Size(), equalTo(1));
            }

            NewTransaction();

            rel.Delete();

            NewTransaction();

            using (IndexHits <Relationship> relationshipIndexHits = _graphDb.index().forRelationships("relationship_auto_index").query("_id_:*"))
            {
                assertThat(relationshipIndexHits.Size(), equalTo(0));
            }
        }
예제 #4
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void nonRecoveredDatabase() throws java.io.IOException
        private void NonRecoveredDatabase()
        {
            File tmpLogDir = new File(_testDirectory.directory(), "logs");

            _fs.mkdir(tmpLogDir);
            File             storeDir = _testDirectory.databaseDir();
            GraphDatabaseAPI db       = ( GraphDatabaseAPI )(new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(GraphDatabaseSettings.record_format, RecordFormatName).setConfig("dbms.backup.enabled", "false").newGraphDatabase();

            RelationshipType relationshipType = RelationshipType.withName("testRelationshipType");

            using (Transaction tx = Db.beginTx())
            {
                Node node1 = set(Db.createNode());
                Node node2 = set(Db.createNode(), property("key", "value"));
                node1.CreateRelationshipTo(node2, relationshipType);
                tx.Success();
            }
            File[] txLogs = LogFilesBuilder.logFilesBasedOnlyBuilder(storeDir, _fs).build().logFiles();
            foreach (File file in txLogs)
            {
                _fs.copyToDirectory(file, tmpLogDir);
            }
            Db.shutdown();
            foreach (File txLog in txLogs)
            {
                _fs.deleteFile(txLog);
            }

            foreach (File file in LogFilesBuilder.logFilesBasedOnlyBuilder(tmpLogDir, _fs).build().logFiles())
            {
                _fs.moveToDirectory(file, storeDir);
            }
        }
예제 #5
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void startDb()
        public virtual void StartDb()
        {
            _graphDb = ( GraphDatabaseAPI )(new TestGraphDatabaseFactory()).newImpermanentDatabaseBuilder().setConfig(new Dictionary <string, string>()).newGraphDatabase();

            using (Transaction tx = _graphDb.beginTx())
            {
                // Create the node and relationship auto-indexes
                _graphDb.index().NodeAutoIndexer.Enabled = true;
                _graphDb.index().NodeAutoIndexer.startAutoIndexingProperty("nodeProp");
                _graphDb.index().RelationshipAutoIndexer.Enabled = true;
                _graphDb.index().RelationshipAutoIndexer.startAutoIndexingProperty("type");

                tx.Success();
            }

            using (Transaction tx = _graphDb.beginTx())
            {
                Node node1 = _graphDb.createNode();
                Node node2 = _graphDb.createNode();
                Node node3 = _graphDb.createNode();
                _id1 = node1.Id;
                _id2 = node2.Id;
                _id3 = node3.Id;
                Relationship rel = node1.CreateRelationshipTo(node2, RelationshipType.withName("FOO"));
                rel.SetProperty("type", "FOO");

                tx.Success();
            }
        }
예제 #6
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustBeAbleToConsistencyCheckRelationshipIndexWithMultipleRelationshipTypesAndOneProperty() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void MustBeAbleToConsistencyCheckRelationshipIndexWithMultipleRelationshipTypesAndOneProperty()
        {
            GraphDatabaseService db       = CreateDatabase();
            RelationshipType     relType1 = RelationshipType.withName("R1");
            RelationshipType     relType2 = RelationshipType.withName("R2");

            using (Transaction tx = Db.beginTx())
            {
                Db.execute(format(RELATIONSHIP_CREATE, "rels", array("R1", "R2"), array("p1"))).close();
                tx.Success();
            }
            using (Transaction tx = Db.beginTx())
            {
                Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                Node n1 = Db.createNode();
                Node n2 = Db.createNode();
                n1.CreateRelationshipTo(n1, relType1).setProperty("p1", "value");
                n1.CreateRelationshipTo(n1, relType2).setProperty("p1", "value");
                n2.CreateRelationshipTo(n2, relType1).setProperty("p1", "value");
                n2.CreateRelationshipTo(n2, relType2).setProperty("p1", "value");
                tx.Success();
            }
            Db.shutdown();
            AssertIsConsistent(CheckConsistency());
        }
예제 #7
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustBeAbleToConsistencyCheckRelationshipIndexWithOneRelationshipTypeAndMultipleProperties() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void MustBeAbleToConsistencyCheckRelationshipIndexWithOneRelationshipTypeAndMultipleProperties()
        {
            GraphDatabaseService db = CreateDatabase();
            RelationshipType     relationshipType = RelationshipType.withName("R1");

            using (Transaction tx = Db.beginTx())
            {
                Db.execute(format(RELATIONSHIP_CREATE, "rels", array("R1"), array("p1", "p2"))).close();
                tx.Success();
            }
            using (Transaction tx = Db.beginTx())
            {
                Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                Node         node = Db.createNode();
                Relationship r1   = node.CreateRelationshipTo(node, relationshipType);
                r1.SetProperty("p1", "value");
                r1.SetProperty("p2", "value");
                Relationship r2 = node.CreateRelationshipTo(node, relationshipType);                           // This relationship will have a different id value than the node.
                r2.SetProperty("p1", "value");
                r2.SetProperty("p2", "value");
                node.CreateRelationshipTo(node, relationshipType).setProperty("p1", "value");
                node.CreateRelationshipTo(node, relationshipType).setProperty("p2", "value");
                tx.Success();
            }
            Db.shutdown();
            AssertIsConsistent(CheckConsistency());
        }
예제 #8
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustBeAbleToConsistencyCheckNodeAndRelationshipIndexesAtTheSameTime() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void MustBeAbleToConsistencyCheckNodeAndRelationshipIndexesAtTheSameTime()
        {
            GraphDatabaseService db = CreateDatabase();

            using (Transaction tx = Db.beginTx())
            {
                Db.execute(format(NODE_CREATE, "nodes", array("L1", "L2", "L3"), array("p1", "p2"))).close();
                Db.execute(format(RELATIONSHIP_CREATE, "rels", array("R1", "R2"), array("p1", "p2"))).close();
                tx.Success();
            }
            using (Transaction tx = Db.beginTx())
            {
                Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                Node n1 = Db.createNode(Label.label("L1"), Label.label("L3"));
                n1.SetProperty("p1", "value");
                n1.SetProperty("p2", "value");
                n1.CreateRelationshipTo(n1, RelationshipType.withName("R2")).setProperty("p1", "value");
                Node n2 = Db.createNode(Label.label("L2"));
                n2.SetProperty("p2", "value");
                Relationship r1 = n2.CreateRelationshipTo(n2, RelationshipType.withName("R1"));
                r1.SetProperty("p1", "value");
                r1.SetProperty("p2", "value");
                tx.Success();
            }
            Db.shutdown();
            AssertIsConsistent(CheckConsistency());
        }
예제 #9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createAndQueryFulltextRelationshipIndex() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void CreateAndQueryFulltextRelationshipIndex()
        {
            FulltextIndexProvider provider = ( FulltextIndexProvider )Db.resolveDependency(typeof(IndexProviderMap)).lookup(DESCRIPTOR);
            IndexReference        indexReference;

            using (KernelTransactionImplementation transaction = KernelTransaction)
            {
                MultiTokenSchemaDescriptor multiTokenSchemaDescriptor = multiToken(new int[] { 0, 1, 2 }, EntityType.RELATIONSHIP, 0, 1, 2, 3);
                FulltextSchemaDescriptor   schema = new FulltextSchemaDescriptor(multiTokenSchemaDescriptor, new Properties());
                indexReference = transaction.SchemaWrite().indexCreate(schema, DESCRIPTOR.name(), "fulltext");
                transaction.Success();
            }
            Await(indexReference);
            long secondRelId;

            using (Transaction transaction = Db.beginTx())
            {
                Relationship ho = _node1.createRelationshipTo(_node2, RelationshipType.withName("ho"));
                secondRelId = ho.Id;
                ho.SetProperty("hej", "villa");
                ho.SetProperty("ho", "value3");
                transaction.Success();
            }
            VerifyRelationshipData(provider, secondRelId);
            Db.restartDatabase(DatabaseRule.RestartAction_Fields.EMPTY);
            provider = ( FulltextIndexProvider )Db.resolveDependency(typeof(IndexProviderMap)).lookup(DESCRIPTOR);
            VerifyRelationshipData(provider, secondRelId);
        }
예제 #10
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public static org.neo4j.graphdb.PathExpander describeRelationships(java.util.Map<String, Object> description)
        public static PathExpander DescribeRelationships(IDictionary <string, object> description)
        {
            PathExpanderBuilder expander = PathExpanderBuilder.allTypesAndDirections();

            object relationshipsDescription = description["relationships"];

            if (relationshipsDescription != null)
            {
                ICollection <object> pairDescriptions;
                if (relationshipsDescription is System.Collections.ICollection)
                {
                    pairDescriptions = (ICollection <object>)relationshipsDescription;
                }
                else
                {
                    pairDescriptions = Arrays.asList(relationshipsDescription);
                }

                foreach (object pairDescription in pairDescriptions)
                {
                    System.Collections.IDictionary map = (System.Collections.IDictionary)pairDescription;
                    string           name          = ( string )map["type"];
                    RelationshipType type          = RelationshipType.withName(name);
                    string           directionName = ( string )map["direction"];
                    expander = (string.ReferenceEquals(directionName, null)) ? expander.Add(type) : expander.Add(type, StringToEnum(directionName, typeof(RelationshipDirection), true).@internal);
                }
            }
            return(expander.Build());
        }
예제 #11
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCircularBug()
        public virtual void TestCircularBug()
        {
            const long timestamp = 3;

            using (Transaction tx = BeginTx())
            {
                GetNodeWithName("2").setProperty("timestamp", 1L);
                GetNodeWithName("3").setProperty("timestamp", 2L);
                tx.Success();
            }

            using (Transaction tx2 = BeginTx())
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.RelationshipType type = org.neo4j.graphdb.RelationshipType.withName("TO");
                RelationshipType   type  = RelationshipType.withName("TO");
                IEnumerator <Node> nodes = GraphDb.traversalDescription().depthFirst().relationships(type, Direction.OUTGOING).evaluator(path =>
                {
                    Relationship rel = path.lastRelationship();
                    bool relIsOfType = rel != null && rel.isType(type);
                    bool prune       = relIsOfType && ( long? )path.endNode().getProperty("timestamp").Value >= timestamp;
                    return(Evaluation.of(relIsOfType, !prune));
                }).traverse(Node("1")).nodes().GetEnumerator();

//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
                assertEquals("2", nodes.next().getProperty("name"));
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
                assertEquals("3", nodes.next().getProperty("name"));
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
                assertFalse(nodes.hasNext());
            }
        }
예제 #12
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUpdatePropertyToRelationshipInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldUpdatePropertyToRelationshipInTransaction()
        {
            // Given
            long   relationshipId;
            string propertyKey = "prop";

            using (Org.Neo4j.Graphdb.Transaction tx = graphDb.beginTx())
            {
                Node node1 = graphDb.createNode();
                Node node2 = graphDb.createNode();

                relationshipId = node1.CreateRelationshipTo(node2, RelationshipType.withName("R")).Id;

                tx.Success();
            }

            // When
            using (Transaction tx = beginTransaction())
            {
                int token = tx.token().propertyKeyGetOrCreateForName(propertyKey);
                assertThat(tx.dataWrite().relationshipSetProperty(relationshipId, token, stringValue("hello")), equalTo(NO_VALUE));
                assertThat(tx.dataWrite().relationshipSetProperty(relationshipId, token, stringValue("world")), equalTo(stringValue("hello")));
                assertThat(tx.dataWrite().relationshipSetProperty(relationshipId, token, intValue(1337)), equalTo(stringValue("world")));
                tx.Success();
            }

            // Then
            using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
            {
                assertThat(graphDb.getRelationshipById(relationshipId).getProperty("prop"), equalTo(1337));
            }
        }
예제 #13
0
        public virtual Path PathToReference(Node me)
        {
            PathFinder <Path> finder = GraphAlgoFactory.shortestPath(PathExpanders.allTypesAndDirections(), 6);

            using (Transaction tx = me.GraphDatabase.beginTx())
            {
                Node other;
                if (me.hasRelationship(RelationshipType.withName("friend")))
                {
                    ResourceIterable <Relationship> relationships = (ResourceIterable <Relationship>)me.getRelationships(RelationshipType.withName("friend"));
                    using (ResourceIterator <Relationship> resourceIterator = relationships.GetEnumerator())
                    {
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
                        other = resourceIterator.next().getOtherNode(me);
                    }
                }
                else
                {
                    other = me.GraphDatabase.createNode();
                }
                Path path = finder.FindSinglePath(other, me);

                tx.Success();
                return(path);
            }
        }
예제 #14
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotWriteWhenSettingPropertyToSameValue() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldNotWriteWhenSettingPropertyToSameValue()
        {
            // Given
            long   relationshipId;
            string propertyKey = "prop";
            Value  theValue    = stringValue("The Value");

            using (Org.Neo4j.Graphdb.Transaction ctx = graphDb.beginTx())
            {
                Node node1 = graphDb.createNode();
                Node node2 = graphDb.createNode();

                Relationship r = node1.CreateRelationshipTo(node2, RelationshipType.withName("R"));

                r.SetProperty(propertyKey, theValue.AsObject());
                relationshipId = r.Id;
                ctx.Success();
            }

            // When
            Transaction tx       = beginTransaction();
            int         property = tx.Token().propertyKeyGetOrCreateForName(propertyKey);

            assertThat(tx.DataWrite().relationshipSetProperty(relationshipId, property, theValue), equalTo(theValue));
            tx.Success();

            assertThat(tx.CloseTransaction(), equalTo(Transaction_Fields.READ_ONLY));
        }
예제 #15
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDeleteRelationship() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldDeleteRelationship()
        {
            long n1, r;

            using (Org.Neo4j.Graphdb.Transaction tx = graphDb.beginTx())
            {
                Node node1 = graphDb.createNode();
                Node node2 = graphDb.createNode();

                n1 = node1.Id;
                r  = node1.CreateRelationshipTo(node2, RelationshipType.withName("R")).Id;

                tx.Success();
            }

            using (Transaction tx = beginTransaction())
            {
                assertTrue("should delete relationship", tx.dataWrite().relationshipDelete(r));
                tx.Success();
            }

            using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
            {
                assertEquals(0, graphDb.getNodeById(n1).Degree);
            }
        }
예제 #16
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemovePropertyFromRelationshipTwice() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldRemovePropertyFromRelationshipTwice()
        {
            // Given
            long   relationshipId;
            string propertyKey = "prop";

            using (Org.Neo4j.Graphdb.Transaction tx = graphDb.beginTx())
            {
                Node node1 = graphDb.createNode();
                Node node2 = graphDb.createNode();

                Relationship proxy = node1.CreateRelationshipTo(node2, RelationshipType.withName("R"));
                relationshipId = proxy.Id;
                proxy.SetProperty(propertyKey, 42);
                tx.Success();
            }

            // When
            using (Transaction tx = beginTransaction())
            {
                int token = tx.token().propertyKeyGetOrCreateForName(propertyKey);
                assertThat(tx.dataWrite().relationshipRemoveProperty(relationshipId, token), equalTo(intValue(42)));
                assertThat(tx.dataWrite().relationshipRemoveProperty(relationshipId, token), equalTo(NO_VALUE));
                tx.Success();
            }

            // Then
            using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
            {
                assertFalse(graphDb.getRelationshipById(relationshipId).hasProperty("prop"));
            }
        }
예제 #17
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldGiveHelpfulExceptionWhenDeletingNodeWithRels()
        public virtual void ShouldGiveHelpfulExceptionWhenDeletingNodeWithRels()
        {
            // Given
            GraphDatabaseService db = this.Db.GraphDatabaseAPI;

            Node node;

            using (Transaction tx = Db.beginTx())
            {
                node = Db.createNode();
                node.CreateRelationshipTo(Db.createNode(), RelationshipType.withName("MAYOR_OF"));
                tx.Success();
            }

            // And given a transaction deleting just the node
            Transaction tx = Db.beginTx();

            node.Delete();
            tx.Success();

            // Expect
            Exception.expect(typeof(ConstraintViolationException));
            Exception.expectMessage("Cannot delete node<" + node.Id + ">, because it still has relationships. " + "To delete this node, you must first delete its relationships.");

            // When I commit
            tx.Close();
        }
예제 #18
0
        private void CreateDbWithExplicitIndexAt(File fromPath, int pairNumberOfNodesToCreate)
        {
            GraphDatabaseService db = CreateDatabase(fromPath, fromPath.AbsolutePath);

            Index <Node>      explicitNodeIndex;
            RelationshipIndex explicitRelationshipIndex;

            using (Transaction transaction = Db.beginTx())
            {
                explicitNodeIndex         = Db.index().forNodes("explicitNodeIndex");
                explicitRelationshipIndex = Db.index().forRelationships("explicitRelationshipIndex");
                transaction.Success();
            }

            using (Transaction tx = Db.beginTx())
            {
                for (int i = 0; i < pairNumberOfNodesToCreate; i += 2)
                {
                    Node         node         = Db.createNode();
                    Node         otherNode    = Db.createNode();
                    Relationship relationship = node.CreateRelationshipTo(otherNode, RelationshipType.withName("rel"));

                    explicitNodeIndex.Add(node, "a", "b");
                    explicitNodeIndex.Add(otherNode, "c", "d");
                    explicitRelationshipIndex.add(relationship, "x", "y");
                }
                tx.Success();
            }
            Db.shutdown();
        }
예제 #19
0
        private DbRepresentation CreateTransactionWithWeirdRelationshipGroupRecord(File path)
        {
            _db = StartGraphDatabase(path);
            int              i = 0;
            Node             node;
            RelationshipType typeToDelete = RelationshipType.withName("A");
            RelationshipType theOtherType = RelationshipType.withName("B");
            int              defaultDenseNodeThreshold = int.Parse(GraphDatabaseSettings.dense_node_threshold.DefaultValue);

            using (Transaction tx = _db.beginTx())
            {
                node = _db.createNode();
                for ( ; i < defaultDenseNodeThreshold - 1; i++)
                {
                    node.CreateRelationshipTo(_db.createNode(), theOtherType);
                }
                node.CreateRelationshipTo(_db.createNode(), typeToDelete);
                tx.Success();
            }
            using (Transaction tx = _db.beginTx())
            {
                node.CreateRelationshipTo(_db.createNode(), theOtherType);
                foreach (Relationship relationship in node.GetRelationships(Direction.BOTH, typeToDelete))
                {
                    relationship.Delete();
                }
                tx.Success();
            }
            DbRepresentation result = DbRepresentation.of(_db);

            _db.shutdown();
            return(result);
        }
예제 #20
0
        /*
         * Tests for a particular bug with dense nodes. It used to be that if a dense node had relationships
         * for only one direction, if a request for relationships of the other direction was made, no relationships
         * would be returned, ever.
         */
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenDenseNodeWhenAskForWrongDirectionThenIncorrectNrOfRelsReturned()
        public virtual void GivenDenseNodeWhenAskForWrongDirectionThenIncorrectNrOfRelsReturned()
        {
            // Given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int denseNodeThreshold = int.Parse(org.neo4j.graphdb.factory.GraphDatabaseSettings.dense_node_threshold.getDefaultValue()) + 1;
            int denseNodeThreshold = int.Parse(GraphDatabaseSettings.dense_node_threshold.DefaultValue) + 1;

            Node node1;

            using (Transaction tx = Db.beginTx())
            {
                node1 = Db.createNode();
                Node node2 = Db.createNode();

                for (int i = 0; i < denseNodeThreshold; i++)
                {
                    node1.CreateRelationshipTo(node2, RelationshipType.withName("FOO"));
                }
                tx.Success();
            }

            // When/Then
            using (Transaction ignored = Db.beginTx())
            {
                Node node1b = Db.getNodeById(node1.Id);

                IEnumerable <Relationship> rels = node1b.GetRelationships(Direction.INCOMING);
                assertEquals(0, Iterables.count(rels));

                IEnumerable <Relationship> rels2 = node1b.GetRelationships(Direction.OUTGOING);
                assertEquals(denseNodeThreshold, Iterables.count(rels2));
            }
        }
예제 #21
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDefaultsAreSeparateForNodesAndRelationships()
        public virtual void TestDefaultsAreSeparateForNodesAndRelationships()
        {
            StopDb();
            _config = new Dictionary <string, string>();
            _config[GraphDatabaseSettings.node_keys_indexable.name()] = "propName";
            _config[GraphDatabaseSettings.node_auto_indexing.name()]  = "true";
            // Now only node properties named propName should be indexed.
            StartDb();

            NewTransaction();

            Node node1 = _graphDb.createNode();
            Node node2 = _graphDb.createNode();

            node1.SetProperty("propName", "node1");
            node2.SetProperty("propName", "node2");
            node2.SetProperty("propName_", "node2");

            Relationship rel = node1.CreateRelationshipTo(node2, RelationshipType.withName("DYNAMIC"));

            rel.SetProperty("propName", "rel1");

            NewTransaction();

            ReadableIndex <Node> autoIndex = _graphDb.index().NodeAutoIndexer.AutoIndex;

            assertEquals(node1, autoIndex.Get("propName", "node1").Single);
            assertEquals(node2, autoIndex.Get("propName", "node2").Single);
            assertFalse(_graphDb.index().RelationshipAutoIndexer.AutoIndex.get("propName", "rel1").hasNext());
        }
예제 #22
0
        private void PrepareDbWithDeletedRelationshipPartOfTheChain()
        {
            GraphDatabaseAPI db = ( GraphDatabaseAPI )(new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(_testDirectory.databaseDir()).setConfig(GraphDatabaseSettings.record_format, RecordFormatName).setConfig("dbms.backup.enabled", "false").newGraphDatabase();

            try
            {
                RelationshipType relationshipType = RelationshipType.withName("testRelationshipType");
                using (Transaction tx = Db.beginTx())
                {
                    Node node1 = set(Db.createNode());
                    Node node2 = set(Db.createNode(), property("key", "value"));
                    node1.CreateRelationshipTo(node2, relationshipType);
                    node1.CreateRelationshipTo(node2, relationshipType);
                    node1.CreateRelationshipTo(node2, relationshipType);
                    node1.CreateRelationshipTo(node2, relationshipType);
                    node1.CreateRelationshipTo(node2, relationshipType);
                    node1.CreateRelationshipTo(node2, relationshipType);
                    tx.Success();
                }

                RecordStorageEngine recordStorageEngine = Db.DependencyResolver.resolveDependency(typeof(RecordStorageEngine));

                NeoStores          neoStores          = recordStorageEngine.TestAccessNeoStores();
                RelationshipStore  relationshipStore  = neoStores.RelationshipStore;
                RelationshipRecord relationshipRecord = new RelationshipRecord(-1);
                RelationshipRecord record             = relationshipStore.GetRecord(4, relationshipRecord, RecordLoad.FORCE);
                record.InUse = false;
                relationshipStore.UpdateRecord(relationshipRecord);
            }
            finally
            {
                Db.shutdown();
            }
        }
예제 #23
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustDiscoverRelationshipInStoreMissingFromIndex() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void MustDiscoverRelationshipInStoreMissingFromIndex()
        {
            GraphDatabaseService db = CreateDatabase();

            using (Transaction tx = Db.beginTx())
            {
                Db.execute(format(RELATIONSHIP_CREATE, "rels", array("REL"), array("prop"))).close();
                tx.Success();
            }
            StoreIndexDescriptor indexDescriptor;
            long relId;

            using (Transaction tx = Db.beginTx())
            {
                Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                indexDescriptor = GetIndexDescriptor(first(Db.schema().Indexes));
                Node         node = Db.createNode();
                Relationship rel  = node.CreateRelationshipTo(node, RelationshipType.withName("REL"));
                rel.SetProperty("prop", "value");
                relId = rel.Id;
                tx.Success();
            }
            IndexingService indexes    = GetIndexingService(db);
            IndexProxy      indexProxy = indexes.GetIndexProxy(indexDescriptor.Schema());

            using (IndexUpdater updater = indexProxy.NewUpdater(IndexUpdateMode.ONLINE))
            {
                updater.Process(IndexEntryUpdate.remove(relId, indexDescriptor, Values.stringValue("value")));
            }

            Db.shutdown();

            ConsistencyCheckService.Result result = CheckConsistency();
            assertFalse(result.Successful);
        }
예제 #24
0
        // Attempt at recreating this issue without cypher
        // https://github.com/neo4j/neo4j/issues/4160
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAbortAsSoonAsPossible()
        public virtual void ShouldAbortAsSoonAsPossible()
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label A = org.neo4j.graphdb.Label.label("A");
            Label a = Label.label("A");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label B = org.neo4j.graphdb.Label.label("B");
            Label b = Label.label("B");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label C = org.neo4j.graphdb.Label.label("C");
            Label c = Label.label("C");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label D = org.neo4j.graphdb.Label.label("D");
            Label d = Label.label("D");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label E = org.neo4j.graphdb.Label.label("E");
            Label e = Label.label("E");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Label F = org.neo4j.graphdb.Label.label("F");
            Label f = Label.label("F");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.RelationshipType relType = org.neo4j.graphdb.RelationshipType.withName("TO");
            RelationshipType relType = RelationshipType.withName("TO");

            RecursiveSnowFlake(null, 0, 4, 5, new Label[] { a, b, c, d, e }, relType);
            Node a = GetNodeByLabel(a);

            using (ResourceIterator <Node> allE = GraphDb.findNodes(e))
            {
                while (allE.MoveNext())
                {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Node e = allE.Current;
                    Node e = allE.Current;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Node f = graphDb.createNode(F);
                    Node f = GraphDb.createNode(f);
                    f.CreateRelationshipTo(e, relType);
                }
            }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final CountingPathExpander countingPathExpander = new CountingPathExpander(org.neo4j.graphdb.PathExpanders.forTypeAndDirection(relType, org.neo4j.graphdb.Direction.OUTGOING));
            CountingPathExpander countingPathExpander = new CountingPathExpander(this, PathExpanders.forTypeAndDirection(relType, Direction.OUTGOING));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ShortestPath shortestPath = new ShortestPath(Integer.MAX_VALUE, countingPathExpander, Integer.MAX_VALUE);
            ShortestPath shortestPath = new ShortestPath(int.MaxValue, countingPathExpander, int.MaxValue);

            using (ResourceIterator <Node> allF = GraphDb.findNodes(f))
            {
                while (allF.MoveNext())
                {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Node f = allF.Current;
                    Node f = allF.Current;
                    shortestPath.FindAllPaths(a, f);
                }
            }
            assertEquals("There are 625 different end nodes. The algorithm should start one traversal for each such node. " + "That is 625*2 visited nodes if traversal is interrupted correctly.", 1250, countingPathExpander.NodesVisited.intValue());
        }
예제 #25
0
        private Relationship CreateRelationshipAssumingTxWith(string key, object value)
        {
            Node         a            = _db.createNode();
            Node         b            = _db.createNode();
            Relationship relationship = a.CreateRelationshipTo(b, RelationshipType.withName("FOO"));

            relationship.SetProperty(key, value);
            return(relationship);
        }
예제 #26
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void consistencyCheckerMustBeAbleToRunOnStoreWithFulltextIndexes() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ConsistencyCheckerMustBeAbleToRunOnStoreWithFulltextIndexes()
        {
            GraphDatabaseService db = CreateDatabase();

//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
            Label[] labels = IntStream.range(1, 7).mapToObj(i => Label.label("LABEL" + i)).toArray(Label[] ::new);
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
            RelationshipType[] relTypes = IntStream.range(1, 5).mapToObj(i => RelationshipType.withName("REL" + i)).toArray(RelationshipType[] ::new);
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
            string[]     propertyKeys = IntStream.range(1, 7).mapToObj(i => "PROP" + i).toArray(string[] ::new);
            RandomValues randomValues = RandomValues.create();

            using (Transaction tx = Db.beginTx())
            {
                ThreadLocalRandom rng  = ThreadLocalRandom.current();
                int          nodeCount = 1000;
                IList <Node> nodes     = new List <Node>(nodeCount);
                for (int i = 0; i < nodeCount; i++)
                {
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
                    Label[] nodeLabels = rng.ints(rng.Next(labels.Length), 0, labels.Length).distinct().mapToObj(x => labels[x]).toArray(Label[] ::new);
                    Node    node       = Db.createNode(nodeLabels);
                    Stream.of(propertyKeys).forEach(p => node.setProperty(p, rng.nextBoolean() ? p : randomValues.NextValue().asObject()));
                    nodes.Add(node);
                    int localRelCount = Math.Min(nodes.Count, 5);
                    rng.ints(localRelCount, 0, localRelCount).distinct().mapToObj(x => node.CreateRelationshipTo(nodes[x], relTypes[rng.Next(relTypes.Length)])).forEach(r => Stream.of(propertyKeys).forEach(p => r.setProperty(p, rng.nextBoolean() ? p : randomValues.NextValue().asObject())));
                }
                tx.Success();
            }

            using (Transaction tx = Db.beginTx())
            {
                for (int i = 1; i < labels.Length; i++)
                {
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
                    Db.execute(format(NODE_CREATE, "nodes" + i, array(java.util.labels.Take(i).Select(Label::name).ToArray(string[] ::new)), array(Arrays.copyOf(propertyKeys, i)))).close();
                }
                for (int i = 1; i < relTypes.Length; i++)
                {
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
                    Db.execute(format(RELATIONSHIP_CREATE, "rels" + i, array(java.util.relTypes.Take(i).Select(RelationshipType::name).ToArray(string[] ::new)), array(Arrays.copyOf(propertyKeys, i)))).close();
                }
                tx.Success();
            }

            using (Transaction tx = Db.beginTx())
            {
                Db.schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                tx.Success();
            }

            Db.shutdown();

            AssertIsConsistent(CheckConsistency());
        }
예제 #27
0
 protected internal override void generateInitialData(GraphDatabaseService graphDb)
 {
     using (Transaction tx = graphDb.BeginTx())
     {
         Node node1 = set(graphDb.CreateNode());
         Node node2 = set(graphDb.CreateNode(), property("key", "exampleValue"));
         node1.CreateRelationshipTo(node2, RelationshipType.withName("C"));
         tx.Success();
     }
 }
예제 #28
0
        private static Relationship MockRelationship(long id, Node start, string type, Node end, Properties properties)
        {
            Relationship relationship = MockPropertyContainer(typeof(Relationship), properties);

            when(relationship.Id).thenReturn(id);
            when(relationship.StartNode).thenReturn(start);
            when(relationship.EndNode).thenReturn(end);
            when(relationship.Type).thenReturn(RelationshipType.withName(type));
            return(relationship);
        }
예제 #29
0
 private static void CreateSomeData(GraphDatabaseService db)
 {
     using (Transaction tx = Db.beginTx())
     {
         Node node = Db.createNode();
         node.SetProperty("name", "Neo");
         Db.createNode().createRelationshipTo(node, RelationshipType.withName("KNOWS"));
         tx.Success();
     }
 }
 protected internal override void generateInitialData(GraphDatabaseService graphDb)
 {
     // TODO: create bigger sample graph here
     using (Org.Neo4j.Graphdb.Transaction tx = graphDb.BeginTx())
     {
         Node node1 = set(graphDb.CreateNode(label("Foo")));
         Node node2 = set(graphDb.CreateNode(label("Foo")), property("key", "value"));
         node1.CreateRelationshipTo(node2, RelationshipType.withName("C"));
         tx.Success();
     }
 }