public void ShouldExecuteSimpleGremlinQuery() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { OVertex vertex1 = database .Create.Vertex<OVertex>() .Set("Foo", "foo string value 1") .Set("Bar", 12345) .Run(); OVertex vertex2 = database .Create.Vertex<OVertex>() .Set("Foo", "foo string value 2") .Set("Bar", 54321) .Run(); OEdge edge1 = database .Create.Edge<OEdge>() .From(vertex1) .To(vertex2) .Set("Foo", "foo string value 3") .Set("Bar", 123) .Run(); List<ODocument> documents = database.Gremlin("g.V"); } } }
public void Init() { _context = new TestDatabaseContext(); _database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); _database.Create.Class<Person>().Run(); }
public void ShouldCreateVertexFromObject() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class <TestProfileClass>() .Extends <OVertex>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; TestProfileClass createdVertex = database .Create.Vertex(profile) .Run <TestProfileClass>(); Assert.NotNull(createdVertex.ORID); Assert.Equal(typeof(TestProfileClass).Name, createdVertex.OClassName); Assert.Equal(profile.Name, createdVertex.Name); Assert.Equal(profile.Surname, createdVertex.Surname); } } }
/// <summary> /// Fills out a collection of models of type <typeparamref name="T"/> using <c>traverse</c>. <paramref name="db"/> must be open. /// </summary> /// <remarks> /// <para>Note that <c>traverse</c> can be slow, and <c>select</c> may be more appropriate. See /// http://www.orientechnologies.com/docs/last/orientdb.wiki/SQL-Traverse.html#should-i-use-traverse-or-select /// </para> /// <para>Lightweight edges are not followed when populating model properties. Make sure to use "heavyweight" edges with either /// <c>alter property MyEdgeClass.out MANDATORY=true</c> and <c>alter property MyEdgeClass.in MANDATORY=true</c>, or else /// use <c>alter database custom useLightweightEdges=false</c>.</para> /// </remarks> /// <typeparam name="T">The model type. Must extend <see cref="ABaseModel"/>, have a parameterless constructor, and most importantly it must be in the same /// namespace as <see cref="ABaseModel"/>.</typeparam> /// <param name="db">The database to query</param> /// <param name="from">A class, cluster, RID list, or RID to traverse. RIDs are in the form <c>#clusterId:clusterPosition</c>. Lists are in the form /// <c>[RID,RID,...]</c> with one or more elements (whitespace is ignored). Clusters are in the form <c>cluster:clusterName</c> or <c>cluster:clusterId</c>.</param> /// <exception cref="System.ArgumentException">If <paramref name="from"/> is an invalid format</exception> /// <returns>An enumerable collection of models of type <typeparamref name="T"/>. Public instance properties of the models will have their values populated /// based on all non-lightweight edges in the traversal.</returns> public static IEnumerable <T> Traverse <T>(this ODatabase db, string from) where T : ABaseModel, new() { // Sanity check on target bool matches = false; foreach (string pattern in legalTargets) { if (Regex.IsMatch(from, pattern)) { matches = true; break; } } if (!matches) { throw new ArgumentException("Traverse target must be a class, cluster, RID list, or single RID.", "from"); } bool fromSingleRecord = Regex.IsMatch(from, legalTargets[SINGLE_RID_TARGET_PATTERN_INDEX]); // Traverse DB string sql = string.Format("traverse * from {0}", from); List <ODocument> result = db.Query(sql); DatabaseTraversal traversal = new DatabaseTraversal(db, result); // Process result IEnumerable <T> models = traversal.ToModel <T>(); if (fromSingleRecord) { // Either Traverse(ORID) was called, or client code called Traverse with an RID string -- return a single element models = models.Where(m => m.ORID.ToString().Equals(from)); } return(models); }
public void ShouldInsertIntoClusterSet() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); database .Create.Cluster("TestCluster", OClusterType.Physical) .Run(); ODocument insertedDocument = database .Insert() .Into("TestClass") .Cluster("TestCluster") .Set("foo", "foo string value") .Set("bar", 12345) .Run(); Assert.IsTrue(insertedDocument.ORID != null); Assert.AreEqual(insertedDocument.OClassName, "TestClass"); Assert.AreEqual(insertedDocument.GetField <string>("foo"), "foo string value"); Assert.AreEqual(insertedDocument.GetField <int>("bar"), 12345); } } }
public void ShouldDeleteDocumentFromDocumentOClassName() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); database .Create.Document("TestClass") .Set("foo", "foo string value1") .Set("bar", 12345) .Run(); database .Create.Document("TestClass") .Set("foo", "foo string value2") .Set("bar", 54321) .Run(); ODocument document = new ODocument(); document.OClassName = "TestClass"; int documentsDeleted = database .Delete.Document(document) .Run(); Assert.Equal(documentsDeleted, 2); } } }
public LoadRecord(ORID orid, string fetchPlan, ODatabase database) : this(database) { _orid = orid; _fetchPlan = fetchPlan; _database = database; }
public void TestDatabaseClusterAddRemove() { using (ODatabase database = new ODatabase(_hostname, _port, _databaseName, ODatabaseType.Document, _username, _password)) { OCluster newCluster = database.AddCluster(OClusterType.Physical, "tempClusterTest001x"); Assert.IsTrue(newCluster.ID >= 0); Assert.IsTrue(!string.IsNullOrEmpty(newCluster.Name)); Assert.IsTrue(newCluster.RecordsCount == 0); database.Reload(); OCluster cluster = database.Clusters.Find(x => x.ID == newCluster.ID); Assert.IsTrue(cluster.ID >= newCluster.ID); Assert.IsTrue(cluster.Name.Equals(newCluster.Name, StringComparison.CurrentCultureIgnoreCase)); Assert.IsTrue(cluster.RecordsCount == newCluster.RecordsCount); database.RemoveCluster(newCluster.ID); OCluster cluster2 = database.Clusters.Find(x => x.ID == newCluster.ID); Assert.IsNull(cluster2); database.Reload(); OCluster cluster3 = database.Clusters.Find(x => x.ID == newCluster.ID); Assert.IsNull(cluster3); } }
public void ShouldCreateVertexFromDocument() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends<OVertex>() .Run(); ODocument document = new ODocument(); document.OClassName = "TestVertexClass"; document .SetField("foo", "foo string value") .SetField("bar", 12345); OVertex createdVertex = database .Create.Vertex(document) .Run(); Assert.IsNotNull(createdVertex.ORID); Assert.AreEqual("TestVertexClass", createdVertex.OClassName); Assert.AreEqual(document.GetField<string>("foo"), createdVertex.GetField<string>("foo")); Assert.AreEqual(document.GetField<int>("bar"), createdVertex.GetField<int>("bar")); } } }
public void ShouldCreateVertexSet() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends<OVertex>() .Run(); OVertex createdVertex = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value") .Set("bar", 12345) .Run(); Assert.IsTrue(createdVertex.ORID != null); Assert.AreEqual(createdVertex.OClassName, "TestVertexClass"); Assert.AreEqual(createdVertex.GetField<string>("foo"), "foo string value"); Assert.AreEqual(createdVertex.GetField<int>("bar"), 12345); } } }
public void ShouldCreateClassCluster() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { short clusterid1 = database .Create .Cluster("ClasterForTest1", OClusterType.None) .Run(); short clusterid2 = database .Create .Cluster("ClasterForTest2", OClusterType.None) .Run(); short classId1 = database .Create.Class("TestClass1") .Cluster(clusterid1) .Run(); Assert.IsTrue(classId1 > 0); short classId2 = database .Create.Class("TestClass2") .Cluster(clusterid2) .Run(); Assert.AreEqual(classId1 + 1, classId2); } } }
public void ShouldCreateDocumentClassSet() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document = new ODocument(); document.OClassName = "TestClass"; document .SetField("foo", "foo string value") .SetField("bar", 12345); ODocument createdDocument = database .Create.Document("TestClass") .Set(document) .Run(); Assert.NotNull(createdDocument.ORID); Assert.Equal("TestClass", createdDocument.OClassName); Assert.Equal(document.GetField<string>("foo"), createdDocument.GetField<string>("foo")); Assert.Equal(document.GetField<int>("bar"), createdDocument.GetField<int>("bar")); } } }
public void ShouldCreateDocumentFromObject() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class<TestProfileClass>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; TestProfileClass createdObject = database .Create.Document(profile) .Run<TestProfileClass>(); Assert.NotNull(createdObject.ORID); Assert.Equal(typeof(TestProfileClass).Name, createdObject.OClassName); Assert.Equal(profile.Name, createdObject.Name); Assert.Equal(profile.Surname, createdObject.Surname); } } }
public GitHub_issue23() { _context = new TestDatabaseContext(); _database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); _database.Create.Class<DemoEmployee>().Run(); }
public void ShouldDeleteVertexFromDocumentOrid() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); ODocument vertex1 = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value1") .Set("bar", 12345) .Run(); ODocument vertex2 = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value2") .Set("bar", 54321) .Run(); int documentsDeleted = database .Delete.Vertex(vertex2) .Run(); Assert.AreEqual(documentsDeleted, 1); } } }
public GitHub_issue4() { _context = new TestDatabaseContext(); _database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); _database.Create.Class("TestVertex").Run(); _database.Create.Property("_datetime", OType.DateTime).Class("TestVertex").Run(); }
public void TestLoadWithFetchPlanNoLinks() { using (var testContext = new TestDatabaseContext()) { using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document = new ODocument() .SetField("foo", "foo string value") .SetField("bar", 12345); ODocument insertedDocument = database .Insert(document) .Into("TestClass") .Run(); var loaded = database.Load.ORID(insertedDocument.ORID).FetchPlan("*:1").Run(); Assert.AreEqual(loaded.OClassName, "TestClass"); Assert.AreEqual(loaded.GetField <string>("foo"), document.GetField <string>("foo")); Assert.AreEqual(loaded.GetField <int>("bar"), document.GetField <int>("bar")); Assert.AreEqual(insertedDocument.ORID, loaded.ORID); } } }
public void ShouldUpdateCluster() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS)) { // prerequisites database .Create.Class("TestClass") .Run(); database .Create.Cluster("TestCluster", OClusterType.Physical) .Run(); ODocument document = new ODocument(); document.OClassName = "TestClass"; document .SetField("foo", "foo string value") .SetField("bar", 12345); database .Insert(document) .Cluster("TestCluster") .Run(); database .Insert(document) .Cluster("TestCluster") .Run(); document .SetField("bar", 54321) .SetField("baz", "new baz value"); int documentsUpdated = database .Update(document) .Cluster("TestCluster") .Run(); Assert.AreEqual(documentsUpdated, 2); List <ODocument> documents = database .Select() .From("cluster:TestCluster") .ToList(); Assert.AreEqual(documents.Count, 2); for (int i = 0; i < documents.Count; i++) { Assert.IsTrue(documents[i].ORID != null); Assert.AreEqual(documents[i].OClassName, document.OClassName); Assert.AreEqual(documents[i].GetField <string>("foo"), document.GetField <string>("foo")); Assert.AreEqual(documents[i].GetField <int>("bar"), document.GetField <int>("bar")); Assert.AreEqual(documents[i].GetField <string>("baz"), document.GetField <string>("baz")); } } } }
public XElement ToXElement() { XElement OElement = new XElement("Column", new XAttribute("Name", Name), new XAttribute("DataType", DataType), new XAttribute("MaxLength", MaxLength), new XAttribute("Nullable", Nullable), new XAttribute("DefaultValue", DefaultValue ?? ""), new XAttribute("PrimaryKey", PrimaryKey), new XAttribute("Required", Required), new XAttribute("AutoIncrement", AutoIncrement)); foreach (String OKey in FAdddionalMetadata.Keys) { OElement.Add(new XAttribute(OKey, FAdddionalMetadata[OKey])); } XElement ORelationships = new XElement("DatabaseRelationships"); OElement.Add(ORelationships); foreach (Database ODatabase in FDatabaseRelationships.Values) { ORelationships.Add(ODatabase.ToRelationshipXElement()); } return(OElement); }
public void ShouldCreateVertexFromDocument() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); ODocument document = new ODocument(); document.OClassName = "TestVertexClass"; document .SetField("foo", "foo string value") .SetField("bar", 12345); OVertex createdVertex = database .Create.Vertex(document) .Run(); Assert.IsTrue(createdVertex.ORID != null); Assert.AreEqual(createdVertex.OClassName, "TestVertexClass"); Assert.AreEqual(createdVertex.GetField <string>("foo"), document.GetField <string>("foo")); Assert.AreEqual(createdVertex.GetField <int>("bar"), document.GetField <int>("bar")); } } }
public override void Run(ConnectionOptions mainOptions, IEnumerable <string> addresses) { var inGroups = new List <List <string> >(); using (var mainDB = new ODatabase(mainOptions)) { foreach (var address in addresses) { var groups = mainDB.Query($"SELECT inE().tAddr AS address FROM (SELECT expand(inV) FROM (SELECT inV() FROM Link WHERE tAddr = '{address}' LIMIT 10000))").SelectMany(x => x.GetField <List <string> >("address")).Where(y => !string.IsNullOrEmpty(y)).Where(x => x.Count() > 1).Distinct().ToList(); try { inGroups.Add(groups); } catch (Exception e) { Console.WriteLine(address + " not in DB?"); } Console.WriteLine(address + " done."); } } var cc = new ClusteringCollapser(); cc.Collapse(inGroups); _result = cc.Clustering; }
public void ShouldCreateVertexFromObject() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GLOBAL_TEST_DATABASE_ALIAS)) { // prerequisites database .Create.Class <TestProfileClass>() .Extends <OVertex>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; TestProfileClass createdVertex = database .Create.Vertex(profile) .Run <TestProfileClass>(); Assert.IsTrue(createdVertex.ORID != null); Assert.AreEqual(createdVertex.OClassName, typeof(TestProfileClass).Name); Assert.AreEqual(createdVertex.Name, profile.Name); Assert.AreEqual(createdVertex.Surname, profile.Surname); } } }
public void ShouldFetchLinkedDocumentsFromSimpleQuery() { using (TestDatabaseContext testContext = new TestDatabaseContext()) using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { database.Create.Class("Owner").Extends("V").Run(); database.Create.Class("Computer").Extends("V").Run(); var owner = new ODocument { OClassName = "Owner" }; owner.SetField <String>("name", "Shawn"); owner = database.Create.Vertex(owner).Run(); var computer = new ODocument { OClassName = "Computer" }; computer.SetField <ORID>("owner", owner.ORID); database.Create.Vertex(computer).Run(); computer = database.Query("SELECT FROM Computer", "*:-1").FirstOrDefault(); Assert.True(database.ClientCache.ContainsKey(computer.GetField <ORID>("owner"))); var document = database.ClientCache[computer.GetField <ORID>("owner")]; Assert.Equal(document.GetField <string>("name"), "Shawn"); } }
static void Test() { _connection = new OServer(_hostname, _port, _rootName, _rootPassword); if (!_connection.DatabaseExist(_databaseName)) { _connection.CreateDatabase(_databaseName, ODatabaseType.Document, OStorageType.Local); } try { using (ODatabase database = new ODatabase(_hostname, _port, _databaseName, ODatabaseType.Document, _username, _password)) { Console.WriteLine("Session ID: {0}", database.SessionID); } } catch (OException ex) { //Console.WriteLine("{0}: {1}", ex.Type, ex.Description); } finally { // delete test database _connection.DeleteDatabase(_databaseName); _connection.Close(); } }
public RecordCreate(ODocument document, ODatabase database) : base(database) { _document = document; _database = database; _operationType = OperationType.RECORD_CREATE; }
static void TestCreateRecord() { using (ODatabase database = new ODatabase(_hostname, _port, _databaseName, ODatabaseType.Document, _username, _password)) { } }
public void ShouldInsertDocumentInto() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document = new ODocument() .SetField("foo", "foo string value") .SetField("bar", 12345); ODocument insertedDocument = database .Insert(document) .Into("TestClass") .Run(); Assert.IsTrue(insertedDocument.ORID != null); Assert.AreEqual(insertedDocument.OClassName, "TestClass"); Assert.AreEqual(insertedDocument.GetField<string>("foo"), document.GetField<string>("foo")); Assert.AreEqual(insertedDocument.GetField<int>("bar"), document.GetField<int>("bar")); } } }
public void Dispose() { context.Dispose(); context = null; database.Dispose(); database = null; }
public void Init() { _context = new TestDatabaseContext(); _database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); _database.Create.Class <Person>().Run(); }
public void ShouldDeleteDocumentFromDocumentOrid() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document1 = database .Create.Document("TestClass") .Set("foo", "foo string value1") .Set("bar", 12345) .Run(); ODocument document2 = database .Create.Document("TestClass") .Set("foo", "foo string value2") .Set("bar", 54321) .Run(); ODocument document = new ODocument(); document.OClassName = "TestClass"; int documentsDeleted = database .Delete.Document(document2) .Run(); Assert.AreEqual(documentsDeleted, 1); } } }
public void ShouldCreateEdgeFromOEdge() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { OVertex vertex1 = database .Create.Vertex <OVertex>() .Run(); OVertex vertex2 = database .Create.Vertex <OVertex>() .Run(); OEdge edge = new OEdge(); edge.SetField("Foo", "foo string value"); edge.SetField("Bar", 12345); OEdge createdEdge = database .Create.Edge(edge) .From(vertex1) .To(vertex2) .Run(); Assert.IsTrue(!string.IsNullOrEmpty(createdEdge.ORID.ToString())); Assert.AreEqual(createdEdge.Label, "E"); Assert.AreEqual(createdEdge.OClassName, "E"); Assert.AreEqual(createdEdge.InV, vertex2.ORID); Assert.AreEqual(createdEdge.OutV, vertex1.ORID); Assert.AreEqual(createdEdge.GetField <string>("Foo"), edge.GetField <string>("Foo")); Assert.AreEqual(createdEdge.GetField <int>("Bar"), edge.GetField <int>("Bar")); } } }
public void ShouldDeleteVertexFromObjectOrid() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class <TestProfileClass>() .Extends <OVertex>() .Run(); TestProfileClass vertex1 = database .Create.Vertex <TestProfileClass>() .Set("Name", "Johny") .Set("Surname", "Bravo") .Run <TestProfileClass>(); TestProfileClass vertex2 = database .Create.Vertex <TestProfileClass>() .Set("Name", "Julia") .Set("Surname", "Bravo") .Run <TestProfileClass>(); int documentsDeleted = database .Delete.Vertex(vertex2) .Run(); Assert.AreEqual(documentsDeleted, 1); } } }
public void ShouldReturnDatabaseToPoolAfterCloseAndDisposeCall() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { Assert.Equal( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); Assert.Equal( TestConnection.GlobalTestDatabasePoolSize - 1, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); database.Close(); Assert.Equal( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); database.Dispose(); Assert.Equal( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); } }
public void ShouldDeleteDocumentFromObjectOClassName() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class <TestProfileClass>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; database .Create.Document(profile) .Run(); database .Create.Document(profile) .Run(); int documentsDeleted = database .Delete.Document(profile) .Run(); Assert.Equal(documentsDeleted, 2); } } }
public void ShouldRetrieveRecordMetadata() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { database .Create .Class("TestClass") .Run(); var document = new ODocument(); document.OClassName = "TestClass"; document.SetField("bar", 12345); document.SetField("foo", "foo value 345"); var createdDocument = database .Create .Document(document) .Run(); var metadata = database .Metadata .ORID(createdDocument.ORID) .Run(); Assert.IsNotNull(metadata); Assert.AreEqual(createdDocument.ORID, metadata.ORID); Assert.AreEqual(createdDocument.OVersion, metadata.OVersion); } } }
public void ShouldFetchLinkedDocumentsFromSimpleQuery() { using (TestDatabaseContext testContext = new TestDatabaseContext()) using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { database.Create.Class("Owner").Extends("V").Run(); database.Create.Class("Computer").Extends("V").Run(); var owner = new ODocument { OClassName = "Owner" }; owner.SetField<String>("name", "Shawn"); owner = database.Create.Vertex(owner).Run(); var computer = new ODocument { OClassName = "Computer" }; computer.SetField<ORID>("owner", owner.ORID); database.Create.Vertex(computer).Run(); computer = database.Query("SELECT FROM Computer", "*:-1").FirstOrDefault(); Assert.That(database.ClientCache.ContainsKey(computer.GetField<ORID>("owner"))); var document = database.ClientCache[computer.GetField<ORID>("owner")]; Assert.That(document.GetField<string>("name"), Is.EqualTo("Shawn")); } }
public void ShouldReturnDatabaseToPoolAfterCloseAndDisposeCall() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { Assert.AreEqual( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); Assert.AreEqual( TestConnection.GlobalTestDatabasePoolSize - 1, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); database.Close(); Assert.AreEqual( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); database.Dispose(); Assert.AreEqual( TestConnection.GlobalTestDatabasePoolSize, OClient.DatabasePoolCurrentSize(TestConnection.GlobalTestDatabaseAlias) ); } }
public void TestLoadWithFetchPlanNoLinks() { using (var testContext = new TestDatabaseContext()) using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document = new ODocument() .SetField("foo", "foo string value") .SetField("bar", 12345); ODocument insertedDocument = database .Insert(document) .Into("TestClass") .Run(); var loaded = database.Load.ORID(insertedDocument.ORID).FetchPlan("*:1").Run(); Assert.AreEqual("TestClass", loaded.OClassName); Assert.AreEqual(document.GetField<string>("foo"), loaded.GetField<string>("foo")); Assert.AreEqual(document.GetField<int>("bar"), loaded.GetField<int>("bar")); Assert.AreEqual(insertedDocument.ORID, loaded.ORID); } }
public void TestCreateManyVertices() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); for (int i = 0; i < 1000; i++) { OVertex testVertex = new OVertex(); testVertex.OClassName = "TestVertexClass"; testVertex.SetField("foo", "foo string value"); testVertex.SetField("bar", i); database.Transaction.Add(testVertex); } database.Transaction.Commit(); var createdVertices = database.Select().From("V").ToList(); Assert.AreEqual(1000, createdVertices.Count); for (int i = 0; i < 1000; i++) { Assert.AreEqual(i, createdVertices[i].GetField <int>("bar")); } } } }
/// <summary> /// Create new <see cref="DatabaseTraversal"/> object. <paramref name="database"/> must be open. /// </summary> /// <param name="database">Database to traverse. Required for discovering edges.</param> /// <param name="documents">Documents produced by <c>traverse * from $target</c></param> public DatabaseTraversal(ODatabase database, IEnumerable <ODocument> documents) { this.documents = documents; documentMap = documents.ToDictionary <ODocument, ORID>(doc => doc.ORID); // Need to know which RIDs in documentMap are edges edges = database.Select().From("E").ToList <OEdge>().Where(edge => documentMap.ContainsKey(edge.ORID)); }
public void TestCreateVerticesAndEdge() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); var testVertex1 = CreateTestVertex(1); var testVertex2 = CreateTestVertex(2); database.Transaction.Add(testVertex1); database.Transaction.Add(testVertex2); testVertex1.OutE.Add(testVertex2.ORID); testVertex2.InE.Add(testVertex1.ORID); database.Transaction.Commit(); Assert.AreEqual(testVertex2.ORID, testVertex1.OutE.First()); Assert.AreEqual(testVertex1.ORID, testVertex2.InE.First()); var createdVertices = database.Select().From("V").ToList <OVertex>(); Assert.AreEqual(2, createdVertices.Count); Assert.AreEqual(createdVertices[1].ORID, createdVertices[0].OutE.First()); Assert.AreEqual(createdVertices[0].ORID, createdVertices[1].InE.First()); } } }
public void ShouldCreateEdgeFromOEdge() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { OVertex vertex1 = database .Create.Vertex<OVertex>() .Run(); OVertex vertex2 = database .Create.Vertex<OVertex>() .Run(); OEdge edge = new OEdge(); edge.SetField("Foo", "foo string value"); edge.SetField("Bar", 12345); OEdge createdEdge = database .Create.Edge(edge) .From(vertex1) .To(vertex2) .Run(); Assert.NotNull(createdEdge.ORID); Assert.Equal("E", createdEdge.Label); Assert.Equal("E", createdEdge.OClassName); Assert.Equal(vertex2.ORID, createdEdge.InV); Assert.Equal(vertex1.ORID, createdEdge.OutV); Assert.Equal(edge.GetField<string>("Foo"), createdEdge.GetField<string>("Foo")); Assert.Equal(edge.GetField<int>("Bar"), createdEdge.GetField<int>("Bar")); } } }
public void ShouldInsertDocument() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Run(); ODocument document = new ODocument(); document.OClassName = "TestClass"; document .SetField("foo", "foo string value") .SetField("bar", 12345); ODocument insertedDocument = database .Insert(document) .Run(); Assert.IsTrue(insertedDocument.ORID != null); Assert.AreEqual(insertedDocument.OClassName, "TestClass"); Assert.AreEqual(insertedDocument.GetField <string>("foo"), document.GetField <string>("foo")); Assert.AreEqual(insertedDocument.GetField <int>("bar"), document.GetField <int>("bar")); } } }
public override void Init(int flowCount, long flowRecordCount) { this.flowCount = flowCount; this.flowRecordCount = flowRecordCount; databases = new ODatabase[flowCount]; var connect = OClient.CreateDatabasePool(Server, Port, DatabaseTest, ODatabaseType.Document, Ussername, Password, flowCount, CollectionName); for (int i = 0; i < flowCount; i++) { ODatabase database = new ODatabase(CollectionName); databases[i] = database; } databases[0].Command("DROP CLASS Tick"); databases[0].Command("CREATE Class Tick"); databases[0].Command("CREATE PROPERTY Tick.Key long"); databases[0].Command("CREATE PROPERTY Tick.Symbol string"); databases[0].Command("CREATE PROPERTY Tick.Timestamp DATETIME"); databases[0].Command("CREATE PROPERTY Tick.Bid double"); databases[0].Command("CREATE PROPERTY Tick.Ask double"); databases[0].Command("CREATE PROPERTY Tick.BidSize integer"); databases[0].Command("CREATE PROPERTY Tick.AskSize integer"); databases[0].Command("CREATE PROPERTY Tick.Provider string"); databases[0].Command("CREATE INDEX Tick.Key Dictionary"); }
public void ShouldInsertObject() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class <TestProfileClass>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; TestProfileClass insertedDocument = database .Insert(profile) .Run <TestProfileClass>(); Assert.IsTrue(insertedDocument.ORID != null); Assert.AreEqual(insertedDocument.OClassName, typeof(TestProfileClass).Name); Assert.AreEqual(insertedDocument.Name, profile.Name); Assert.AreEqual(insertedDocument.Surname, profile.Surname); } } }
public void ShouldCreateVertexSet() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.ConnectionOptions)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); OVertex createdVertex = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value") .Set("bar", 12345) .Run(); Assert.IsTrue(createdVertex.ORID != null); Assert.AreEqual(createdVertex.OClassName, "TestVertexClass"); Assert.AreEqual(createdVertex.GetField <string>("foo"), "foo string value"); Assert.AreEqual(createdVertex.GetField <int>("bar"), 12345); } } }
public void ProblemDeseralizingObjectWithDateTimeFields_31() { using (TestDatabaseContext testContext = new TestDatabaseContext()) using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { var startRecords = database.CountRecords; // explicitly setting the timezone to UTC instead of the JVM default timezone // FIXME: this is a work around for now database.Command("ALTER DATABASE TIMEZONE UTC"); database.Create.Class<File>().Extends<OVertex>().CreateProperties().Run(); var dateTime = DateTime.UtcNow; // OrientDB truncates milliseconds, so do so here for a proper comparison dateTime = dateTime.AddTicks( - (dateTime.Ticks % TimeSpan.TicksPerSecond)); database.Insert(new File { Filename = "myfile", Created = dateTime }).Run(); var doc = database.Select().From<File>().ToList().First(); var file = doc.To<File>(); // FIXME: the time zone is off Assert.That(file.Created, Is.EqualTo(dateTime)); var endRecords = database.CountRecords; Assert.AreEqual(startRecords + 1, endRecords); } }
public void ShouldCreateVertexSet() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends <OVertex>() .Run(); OVertex createdVertex = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value") .Set("bar", 12345) .Run(); Assert.NotNull(createdVertex.ORID); Assert.Equal("TestVertexClass", createdVertex.OClassName); Assert.Equal("foo string value", createdVertex.GetField <string>("foo")); Assert.Equal(12345, createdVertex.GetField <int>("bar")); } } }
public void ShouldInsertObject() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class<TestProfileClass>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; TestProfileClass insertedDocument = database .Insert(profile) .Run<TestProfileClass>(); Assert.IsTrue(insertedDocument.ORID != null); Assert.AreEqual(insertedDocument.OClassName, typeof(TestProfileClass).Name); Assert.AreEqual(insertedDocument.Name, profile.Name); Assert.AreEqual(insertedDocument.Surname, profile.Surname); } } }
public void ShouldDeleteDocumentFromObjectOClassName() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class<TestProfileClass>() .Run(); TestProfileClass profile = new TestProfileClass(); profile.Name = "Johny"; profile.Surname = "Bravo"; database .Create.Document(profile) .Run(); database .Create.Document(profile) .Run(); int documentsDeleted = database .Delete.Document(profile) .Run(); Assert.AreEqual(documentsDeleted, 2); } } }
public void Init() { _context = new TestDatabaseContext(); _database = new ODatabase(TestConnection.GlobalTestDatabaseAlias); _database.Create.Class("TestVertex").Run(); _database.Create.Property("_datetime", OType.DateTime).Class("TestVertex").Run(); }
public ODataCommand(ODatabase database, string commandText, bool isIdempotent) { _database = database; _params = new ODataParameterCollection(); IsIdempotent = isIdempotent; CommandText = commandText; }
public void ShouldDeleteVertexFromDocumentOrid() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestVertexClass") .Extends<OVertex>() .Run(); ODocument vertex1 = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value1") .Set("bar", 12345) .Run(); ODocument vertex2 = database .Create.Vertex("TestVertexClass") .Set("foo", "foo string value2") .Set("bar", 54321) .Run(); int documentsDeleted = database .Delete.Vertex(vertex2) .Run(); Assert.AreEqual(documentsDeleted, 1); } } }
public void ShouldDeleteVertexFromObjectOrid() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class<TestProfileClass>() .Extends<OVertex>() .Run(); TestProfileClass vertex1 = database .Create.Vertex<TestProfileClass>() .Set("Name", "Johny") .Set("Surname", "Bravo") .Run<TestProfileClass>(); TestProfileClass vertex2 = database .Create.Vertex<TestProfileClass>() .Set("Name", "Julia") .Set("Surname", "Bravo") .Run<TestProfileClass>(); int documentsDeleted = database .Delete.Vertex(vertex2) .Run(); Assert.AreEqual(documentsDeleted, 1); } } }
public void ShouldCreateProperty() { using (TestDatabaseContext testContext = new TestDatabaseContext()) { using (ODatabase database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { // prerequisites database .Create.Class("TestClass") .Extends<OVertex>() .Run(); // Basic Test foreach (var item in Enum.GetNames(typeof(OType))) { database.Create .Property("_" + item.ToLower(), (OType)Enum.Parse(typeof(OType), item)) .Class("TestClass") .Run(); } var document = database.Query(_metadataQuery); foreach (var item in Enum.GetNames(typeof(OType))) { var metadata = document.Find(d => d.GetField<string>("name") == "_" + item.ToLower()); validateMetadata(metadata, (OType)Enum.Parse(typeof(OType), item)); } // Complex Test database .Create .Property("_embededlist_with_type", OType.EmbeddedList) .LinkedType(OType.Integer) .Class("TestClass") .Run(); database .Create .Property("_embededlist_with_class", OType.EmbeddedList) .LinkedClass("OUser") .Class("TestClass") .Run(); document = database.Query(_metadataQuery); var elwtMetadata = document.Find(d => d.GetField<string>("name") == "_embededlist_with_type"); validateMetadata(elwtMetadata, OType.EmbeddedList); Assert.AreEqual(OType.Integer, (OType)elwtMetadata.GetField<int>("linkedType")); var elwcMetadata = document.Find(d => d.GetField<string>("name") == "_embededlist_with_class"); validateMetadata(elwtMetadata, OType.EmbeddedList); Assert.AreEqual("OUser", elwcMetadata.GetField<string>("linkedClass")); } } }
public void ShouldReturnDatabaseSize() { using (var context = new TestDatabaseContext()) using (var database = new ODatabase(TestConnection.GlobalTestDatabaseAlias)) { var size = database.Size; Assert.IsTrue(size > 0); } }