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 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 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 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 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 Dispose()
{
context.Dispose();
context = null;
database.Dispose();
database = null;
}
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 LoadRecord(ORID orid, string fetchPlan, ODatabase database)
: this(database)
{
_orid = orid;
_fetchPlan = fetchPlan;
_database = database;
}
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);
}
}
