/// <inheritdoc />
public IGraphTypeSerializer CreateSerializer(
IInternalSession session,
IReadOnlyDictionary <GraphProtocol, IReadOnlyDictionary <string, IGraphSONDeserializer> > customDeserializers,
IReadOnlyDictionary <GraphProtocol, IReadOnlyDictionary <Type, IGraphSONSerializer> > customSerializers,
GraphProtocol graphProtocol,
bool deserializeGraphNodes)
{
switch (graphProtocol)
{
case GraphProtocol.GraphSON1:
return(_graphSon1TypeSerializer);
case GraphProtocol.GraphSON2:
case GraphProtocol.GraphSON3:
IReadOnlyDictionary <Type, IGraphSONSerializer> serializers = null;
IReadOnlyDictionary <string, IGraphSONDeserializer> deserializers = null;
customDeserializers?.TryGetValue(graphProtocol, out deserializers);
customSerializers?.TryGetValue(graphProtocol, out serializers);
var cacheKey = new CacheKey(graphProtocol, serializers, deserializers, deserializeGraphNodes);
return(_graphTypeSerializers.GetOrAdd(cacheKey, k => new GraphTypeSerializer(
session,
graphProtocol,
deserializers,
serializers,
deserializeGraphNodes)));
default:
throw new DriverInternalError($"Invalid graph protocol: {graphProtocol.GetInternalRepresentation()}");
}
}
private static GraphNode GetGraphNode(string json, GraphProtocol protocol)
{
return(new GraphNode(new GraphSONNode(
new GraphTypeSerializer(
Mock.Of <IInternalSession>(), protocol, null, null, true),
"{\"result\": " + json + "}")));
}
public void To_Should_Parse_Nullable_Values(GraphProtocol protocol)
{
var nodes = new[] { GraphNodeGraphSONTests.GetGraphNode("null", protocol), GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Vertex\", \"@value\": null}", protocol) };
foreach (var node in nodes)
{
Assert.Null(node.To <short?>());
Assert.Null(node.To <int?>());
Assert.Null(node.To <long?>());
Assert.Null(node.To <decimal?>());
Assert.Null(node.To <float?>());
Assert.Null(node.To <double?>());
Assert.Null(node.To <Guid?>());
Assert.Null(node.To <TimeUuid?>());
Assert.Null(node.To <BigInteger?>());
Assert.Null(node.To <Duration?>());
Assert.Null(node.To <DateTimeOffset?>());
}
Assert.AreEqual(1, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"gx:Int16\", \"@value\": 1}", protocol).To <short?>());
Assert.AreEqual(1, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Int32\", \"@value\": 1}", protocol).To <int?>());
Assert.AreEqual(1L, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Int64\", \"@value\": 1}", protocol).To <long?>());
Assert.AreEqual(1M, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"gx:BigDecimal\", \"@value\": 1}", protocol).To <decimal?>());
Assert.AreEqual(1F, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Float\", \"@value\": 1}", protocol).To <float?>());
Assert.AreEqual(1D, GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Double\", \"@value\": 1}", protocol).To <double?>());
Assert.AreEqual(null, GraphNodeGraphSONTests.GetGraphNode(
"{\"@type\": \"gx:Int16\", \"@value\": null}", protocol).To <Guid?>());
Assert.AreEqual((TimeUuid)Guid.Parse("2cc83ef0-5da4-11e7-8c51-2578d2fa5d3a"), GraphNodeGraphSONTests.GetGraphNode(
"{\"@type\": \"g:UUID\", \"@value\": \"2cc83ef0-5da4-11e7-8c51-2578d2fa5d3a\"}", protocol).To <TimeUuid?>());
Assert.AreEqual(BigInteger.Parse("1"),
GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"gx:Int16\", \"@value\": 1}", protocol).To <BigInteger?>());
Assert.AreEqual(Duration.Parse("12h"),
GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"gx:Duration\", \"@value\": \"12h\"}", protocol).To <Duration?>());
Assert.AreEqual(DateTimeOffset.Parse("1970-01-01 00:00:01Z"),
GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Timestamp\", \"@value\": 1000}", protocol).To <DateTimeOffset?>());
}
public void Should_IgnoreProtocolOnOptionsAndStatement_When_ResolvingDefaultGraphProtocol(
GraphProtocol expected, bool coreGraph, GraphProtocol?optionsLevel, GraphProtocol?statementLevel)
{
var ks = $"ks{Guid.NewGuid().GetHashCode()}";
var session = MockSession(ks, coreGraph);
var factory = new GraphTypeSerializerFactory();
var options = new GraphOptions().SetName(ks);
IGraphStatement statement = new SimpleGraphStatement("");
if (optionsLevel.HasValue)
{
options = options.SetGraphProtocolVersion(optionsLevel.Value);
}
else
{
Assert.IsNull(options.GraphProtocolVersion);
}
if (statementLevel.HasValue)
{
statement = statement.SetGraphProtocolVersion(statementLevel.Value);
}
else
{
Assert.IsNull(statement.GraphProtocolVersion);
}
var actual = factory.GetDefaultGraphProtocol(session, statement, options);
Assert.AreEqual(expected, actual);
}
public void Should_UseStatementGraphNameBeforeOptions_When_ResolvingDefaultGraphProtocol(
GraphProtocol expected, string coreGraphName, string optionsLevel, string statementLevel)
{
var session = MockSession(coreGraphName, true);
var factory = new GraphTypeSerializerFactory();
var options = new GraphOptions();
IGraphStatement statement = new SimpleGraphStatement("");
if (optionsLevel != null)
{
options = options.SetName(optionsLevel);
}
else
{
Assert.IsNull(options.Name);
}
if (statementLevel != null)
{
statement = statement.SetGraphName(statementLevel);
}
else
{
Assert.IsNull(statement.GraphName);
}
var actual = factory.GetDefaultGraphProtocol(session, statement, options);
Assert.AreEqual(expected, actual);
}
public void Should_Execute_Batch_Of_Traversals(string graphName, GraphProtocol protocol)
{
if (graphName == BaseIntegrationTest.DefaultCoreGraphName &&
!TestDseVersion.VersionMatch(
new Version(6, 8), TestClusterManager.DseVersion, Comparison.GreaterThanOrEqualsTo))
{
Assert.Ignore("Test requires DSE 6.8");
}
var g = DseGraph.Traversal(Session, new GraphOptions().SetName(graphName));
if (graphName == BaseIntegrationTest.DefaultCoreGraphName)
{
g = g.With("allow-filtering");
}
var batch = DseGraph.Batch(new GraphOptions().SetName(graphName).SetWriteConsistencyLevel(ConsistencyLevel.LocalQuorum));
batch
.Add(g.AddV("character").Property("name", "Matias").Property("age", 12).Property("tag", "batch1"))
.Add(g.AddV("character").Property("name", "Olivia").Property("age", 8).Property("tag", "batch1"));
var rs = Session.ExecuteGraph(batch);
Assert.AreEqual(protocol, rs.GraphProtocol);
var list = g.V().Has("character", "tag", "batch1").Values <string>("name").ToList();
CollectionAssert.AreEquivalent(new [] { "Matias", "Olivia" }, list);
}
public GraphTypeSerializer(
IInternalSession session,
GraphProtocol protocol,
IReadOnlyDictionary <string, IGraphSONDeserializer> customDeserializers,
IReadOnlyDictionary <Type, IGraphSONSerializer> customSerializers,
bool deserializeGraphNodes)
{
_session = session;
_typeConverter = GraphTypeSerializer.DefaultTypeConverter;
DefaultDeserializeGraphNodes = deserializeGraphNodes;
GraphProtocol = protocol;
customDeserializers = customDeserializers ?? GraphTypeSerializer.EmptyDeserializersDict;
customSerializers = customSerializers ?? GraphTypeSerializer.EmptySerializersDict;
switch (protocol)
{
case GraphProtocol.GraphSON2:
_reader = new CustomGraphSON2Reader(token => new GraphNode(new GraphSONNode(this, token)), customDeserializers, this);
_writer = new CustomGraphSON2Writer(customSerializers, this);
break;
case GraphProtocol.GraphSON3:
_reader = new CustomGraphSON3Reader(token => new GraphNode(new GraphSONNode(this, token)), customDeserializers, this);
_writer = new CustomGraphSON3Writer(customSerializers, this);
break;
default:
throw new ArgumentException($"Can not create graph type serializer for {protocol.GetInternalRepresentation()}");
}
_rowParser = row => new GraphNode(new GraphSONNode(this, row.GetValue <string>("gremlin")));
}
public void HasProperty_Should_Check_For_JSON_Objects(GraphProtocol protocol)
{
const string json = "{\"prop1\": {\"@type\": \"g:Double\", \"@value\": 789}}";
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
Assert.True(node.HasProperty("prop1"));
Assert.False(node.HasProperty("propZ"));
}
public void Get_T_Should_Navigate_Properties_Of_Json_Objects(GraphProtocol protocol)
{
const string json = "{\"prop1\": {\"@type\": \"g:Double\", \"@value\": 789}," +
" \"prop2\": true}";
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
Assert.AreEqual(789D, node.Get <double>("prop1"));
Assert.AreEqual(true, node.Get <bool>("prop2"));
}
public void To_Should_Parse_Null_Vertex_Edge_Or_Path(GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode("null", protocol);
Assert.Null(node.To <Vertex>());
Assert.Null(node.To <Edge>());
Assert.Null(node.To <Path>());
Assert.Null(node.To <IVertex>());
Assert.Null(node.To <IEdge>());
Assert.Null(node.To <IPath>());
}
/// <summary>
/// Clone a graph options object, replacing the graph protocol version.
/// </summary>
internal GraphOptions(GraphOptions other, GraphProtocol version)
{
_language = other._language;
_name = other._name;
_source = other._source;
_readConsistencyLevel = Interlocked.Read(ref other._readConsistencyLevel);
_writeConsistencyLevel = Interlocked.Read(ref other._writeConsistencyLevel);
_readTimeout = other._readTimeout;
_nullableGraphProtocol = version;
RebuildDefaultPayload();
}
public CacheKey(
GraphProtocol protocol,
IReadOnlyDictionary <Type, IGraphSONSerializer> serializers,
IReadOnlyDictionary <string, IGraphSONDeserializer> deserializers,
bool deserializeGraphNodes)
{
GraphProtocol = protocol;
Serializers = serializers;
Deserializers = deserializers;
DeserializeGraphNodes = deserializeGraphNodes;
}
public void Dynamic_Should_Navigate_Properties_Of_GraphSON_Objects(GraphProtocol protocol)
{
dynamic node = GraphNodeGraphSONTests.GetGraphNode(
"{\"@type\": \"g:MyObject\", \"@value\": {" +
"\"id\":{\"@type\":\"g:Int32\",\"@value\":150}," +
"\"label\":\"topic\"" +
"}}", protocol);
int id = node.id;
Assert.AreEqual(150, id);
Assert.AreEqual("topic", node.label.ToString());
}
public void HasProperty_Should_Check_For_TypedGraphSON_Objects(GraphProtocol protocol)
{
const string json = "{\"@type\": \"gex:ObjectTree\", \"@value\": " +
" {" +
" \"prop1\": {\"@type\": \"g:Int32\", \"@value\": 789}," +
" \"prop2\": \"prop2 value\"" +
" }" +
"}";
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
Assert.True(node.HasProperty("prop1"));
Assert.False(node.HasProperty("propZ"));
}
public void To_Should_Parse_Instant_Values(string json, string stringValue, GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
if (stringValue == null)
{
Assert.AreEqual(null, node.To <DateTimeOffset?>());
}
else
{
Assert.AreEqual(DateTimeOffset.Parse(stringValue, CultureInfo.InvariantCulture), node.To <DateTimeOffset>());
Assert.AreEqual(DateTimeOffset.Parse(stringValue, CultureInfo.InvariantCulture), node.To <DateTimeOffset?>());
}
}
public void To_Should_Throw_For_Structs_With_Null(GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode("null", protocol);
Assert.Throws <InvalidOperationException>(() => node.To <short>());
Assert.Throws <InvalidOperationException>(() => node.To <int>());
Assert.Throws <InvalidOperationException>(() => node.To <long>());
Assert.Throws <InvalidOperationException>(() => node.To <decimal>());
Assert.Throws <InvalidOperationException>(() => node.To <float>());
Assert.Throws <InvalidOperationException>(() => node.To <double>());
Assert.Throws <InvalidOperationException>(() => node.To <Guid>());
Assert.Throws <InvalidOperationException>(() => node.To <TimeUuid>());
Assert.Throws <InvalidOperationException>(() => node.To <BigInteger>());
Assert.Throws <InvalidOperationException>(() => node.To <Duration>());
}
public void To_Should_Not_Throw_For_Nullables_With_Null(GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode("null", protocol);
Assert.IsNull(node.To <short?>());
Assert.IsNull(node.To <int?>());
Assert.IsNull(node.To <long?>());
Assert.IsNull(node.To <decimal?>());
Assert.IsNull(node.To <float?>());
Assert.IsNull(node.To <double?>());
Assert.IsNull(node.To <Guid?>());
Assert.IsNull(node.To <TimeUuid?>());
Assert.IsNull(node.To <BigInteger?>());
Assert.IsNull(node.To <Duration?>());
}
public void Get_T_Should_Navigate_Properties_Of_TypedGraphSON_Objects(GraphProtocol protocol)
{
const string json = "{\"@type\": \"gex:ObjectTree\", \"@value\": " +
" {" +
" \"prop1\": {\"@type\": \"g:Int32\", \"@value\": 789}," +
" \"prop2\": \"prop2 value\"" +
" }" +
"}";
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
Assert.AreEqual(789, node.Get <int>("prop1"));
Assert.AreEqual("prop2 value", node.Get <string>("prop2"));
var prop = node.Get <IGraphNode>("prop1");
Assert.AreEqual(789, prop.To <int>());
Assert.AreEqual("prop2 value", node.Get <IGraphNode>("prop2").ToString());
}
public void Implicit_Conversion_Operators_Test(GraphProtocol protocol)
{
var intNode = GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"gx:Int16\", \"@value\": 123}", protocol);
Assert.AreEqual(123, (int)intNode);
Assert.AreEqual(123L, (long)intNode);
Assert.AreEqual((short)123, (short)intNode);
string stringValue = GraphNodeGraphSONTests.GetGraphNode("\"something\"", protocol);
Assert.AreEqual("something", stringValue);
bool boolValue = GraphNodeGraphSONTests.GetGraphNode("true", protocol);
Assert.True(boolValue);
var floatNode = GraphNodeGraphSONTests.GetGraphNode("{\"@type\": \"g:Float\", \"@value\": 123.1}", protocol);
Assert.AreEqual(123.1f, (float)floatNode);
Assert.AreEqual((double)123.1f, (double)floatNode);
}
private GraphResultSet(RowSet rs, GraphProtocol protocol, Func <Row, GraphNode> factory)
{
_rs = rs ?? throw new ArgumentNullException(nameof(rs));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
GraphProtocol = protocol;
}
public IGraphStatement SetGraphProtocolVersion(GraphProtocol graphProtocol)
{
GraphProtocolVersion = graphProtocol;
return(this);
}
public async Task Should_Execute_Batch_Of_Traversals_Asynchronously_With_Edges(string graphName, GraphProtocol protocol)
{
if (graphName == BaseIntegrationTest.DefaultCoreGraphName &&
!TestDseVersion.VersionMatch(
new Version(6, 8), TestClusterManager.DseVersion, Comparison.GreaterThanOrEqualsTo))
{
Assert.Ignore("Test requires DSE 6.8");
}
var g = DseGraph.Traversal(Session, new GraphOptions().SetName(graphName));
if (graphName == BaseIntegrationTest.DefaultCoreGraphName)
{
g = g.With("allow-filtering");
}
var batch = DseGraph.Batch(new GraphOptions().SetName(graphName).SetWriteConsistencyLevel(ConsistencyLevel.LocalQuorum));
batch
.Add(g.AddV("character").Property("name", "Matias").Property("age", 12).Property("tag", "batch2"))
.Add(g.AddV("character").Property("name", "Olivia").Property("age", 8).Property("tag", "batch2"))
.Add(g.V().Has("name", "Matias").Has("tag", "batch2").AddE("knows").To(
__.V().Has("name", "Olivia").Has("tag", "batch2")));
var rs = await Session.ExecuteGraphAsync(batch).ConfigureAwait(false);
Assert.AreEqual(protocol, rs.GraphProtocol);
var characters = g.V().Has("character", "tag", "batch2").Values <string>("name").ToList();
CollectionAssert.AreEquivalent(new [] { "Matias", "Olivia" }, characters);
var knowsOut = g.V().Has("name", "Matias").Has("tag", "batch2")
.Out("knows").Values <string>("name").ToList();
Assert.AreEqual(new [] { "Olivia" }, knowsOut);
}
private ConvertedStatementResult ConvertGraphStatement(
IGraphStatement graphStmt, GraphOptions options, GraphProtocol graphProtocol)
{
string jsonParams;
string query;
IGraphTypeSerializer serializer;
if (graphStmt is SimpleGraphStatement simpleGraphStatement)
{
serializer = _graphTypeSerializerFactory.CreateSerializer(_session, null, null, graphProtocol, true);
query = simpleGraphStatement.Query;
if (simpleGraphStatement.ValuesDictionary != null)
{
jsonParams = serializer.ToDb(simpleGraphStatement.ValuesDictionary);
}
else if (simpleGraphStatement.Values != null)
{
jsonParams = serializer.ToDb(Utils.GetValues(simpleGraphStatement.Values));
}
else
{
jsonParams = null;
}
}
else if (graphStmt is FluentGraphStatement fluentGraphStatement)
{
serializer = _graphTypeSerializerFactory.CreateSerializer(
_session,
fluentGraphStatement.CustomDeserializers,
fluentGraphStatement.CustomSerializers,
graphProtocol,
fluentGraphStatement.DeserializeGraphNodes);
query = serializer.ToDb(fluentGraphStatement.QueryBytecode);
jsonParams = null;
}
else
{
throw new NotSupportedException("Statement of type " + graphStmt.GetType().FullName + " not supported");
}
IStatement stmt = jsonParams != null
? new TargettedSimpleStatement(query, jsonParams)
: new TargettedSimpleStatement(query);
//Set Cassandra.Statement properties
if (graphStmt.Timestamp != null)
{
stmt.SetTimestamp(graphStmt.Timestamp.Value);
}
var readTimeout = graphStmt.ReadTimeoutMillis != 0 ? graphStmt.ReadTimeoutMillis : options.ReadTimeoutMillis;
if (readTimeout <= 0)
{
// Infinite (-1) is not supported in the core driver, set an arbitrarily large int
readTimeout = int.MaxValue;
}
stmt = stmt
.SetIdempotence(false)
.SetConsistencyLevel(graphStmt.ConsistencyLevel)
.SetReadTimeoutMillis(readTimeout)
.SetOutgoingPayload(options.BuildPayload(graphStmt));
return(new ConvertedStatementResult
{
Serializer = serializer,
Statement = stmt
});
}
public static string GetInternalRepresentation(this GraphProtocol version)
{
return(GraphProtocolExtensions.EnumToNameMap[version]);
}
/// <summary>
/// Sets the graph protocol version to use in graph queries. See <see cref="GraphProtocolVersion"/>.
/// </summary>
public GraphOptions SetGraphProtocolVersion(GraphProtocol version)
{
_nullableGraphProtocol = version;
RebuildDefaultPayload();
return(this);
}
public void To_Should_Parse_Blob_Values(string json, string stringValue, GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
CollectionAssert.AreEqual(Encoding.UTF8.GetBytes(stringValue), node.To <byte[]>());
}
public void To_Should_Parse_LocalTime_Values(string json, string stringValue, GraphProtocol protocol)
{
var node = GraphNodeGraphSONTests.GetGraphNode(json, protocol);
Assert.AreEqual(LocalTime.Parse(stringValue), node.To <LocalTime>());
}
internal static GraphResultSet CreateNew(RowSet rs, GraphProtocol protocol, Func <Row, GraphNode> rowParser)
{
return(new GraphResultSet(rs, protocol, rowParser));
}
